Cache Keepalive: arm per-chat (only on MESSAGE_SENT, disarm on CHAT_CHANGED); fixes false-arming on chat open

cd3be6486e9ca988e7821634e09e245a326e3a56

permissionBRICK <40219477+permissionBRICK@users.noreply.github.com>

Parents: d82870e0eac66ac100238311f8ea2dbdbcfa78b0

public/scripts/extensions/keepalive/index.js+31 -18 Viewed

 let idleTimer = null;
 let keepaliveActive = false;
 // Whether keepalive has beenis "armed" thisfor browser-tabthe sessionCURRENT chat. It stays dormant until the user sends a new
 // first real message/generation happens in the tab,open becausechat — on a freshfreshly loadloaded or switched-to chat (even with chathistory already
 // history already present) we have no way to know whether anythingits prompt is still cached server-side, so pinging would
 // server-side — so pinging before then would be pointless. ResetsReset on page reload and whenever the chat changes.
 let armed = false;
 // Wall-clock time (Date.now() + delay) the pending idle timer is expected to fire, or null when
 // none is scheduled. Used to detect a timer that fired far too late (sleep/throttle).

 /**
  * (Re)schedules the keepalive for the ACTIVE profile based on how long it has been since
  * that profile's last message. Does nothing (and leaves the timer cleared) until keepalive
  * has been armed for thisthe tabcurrent sessionchat, or when it is disabled for the active connection.
  * Called on activity AND whenever the active profile changes, so each profile keeps its own
  * independent idle clock.
  */

+}
 /**
 - * Real message/generation activity: arms keepalive for this tab session (if it wasn't already)
 + * The user sent a new message in the current chat — the ONLY thing that arms keepalive.
 - * and records the activity. Loading a chat's history does NOT call this.
 + * Background/quiet generations, swipes, regenerations, and loading chat history deliberately do
 + * NOT arm it: none of those prove the user is actively continuing THIS chat from a known-cached
 + * prompt (GENERATION_STARTED in particular fires for every quiet/background generation too).
  */
 function onChatActivityonMessageSent() {
     armed = true;
     markActivity();
+}
 /**
 + * Opening or switching chats disarms keepalive: a freshly loaded chat is not proof its prompt is
 + * still cached server-side, so we wait for a new sent message in that chat before running again.
 + */
 +function onChatChanged() {
 +    armed = false;
 +    scheduleIdleTimer();
 +}
++
 +/**
  * Fires a background ("quiet") generation against the active model to keep the
  * server-side prompt cache warm. The full prompt prefix (current chat context +
  * the keepalive message) is sent — which is what refreshes the cache — while the

     // If the timer fired much later than scheduled (machine sleep, background-tab throttling,
     // etc.), far more wall-clock time has elapsed than the idle interval, so the cache has
     // almost certainly expired. Don't ping on a stale assumption — go dormant until the next
     // realsent message re-arms keepalive, exactly like a freshly opened tabchat.
     if (scheduledFireTime !== null && (Date.now() - scheduledFireTime) > MAX_TIMER_DRIFT_MS) {
         console.debug('[Keepalive] Idle timer fired', Date.now() - scheduledFireTime, 'ms late; skipping and disarming until next activity.');
         armed = false;

     loadSettings();
     setupListeners();
 -    // A real message/generation arms keepalive for this tab session and counts as using the
 +    // Only the user sending a new message arms keepalive (for the current chat).
 -    // active profile. (Keepalive stays dormant until the first one — see `armed`.)
 +    eventSource.on(event_types.MESSAGE_SENT, onMessageSent);
 -    const activationEvents = [
++
 -        event_types.MESSAGE_SENT,
 +    // These reset the active profile's idle clock (so generation time isn't counted as idle) but
 +    // never arm keepalive on their own — they also fire for background/quiet generations and while
 +    // a chat is loading. They only re-arm the timer if a sent message already armed it.
 +    const activityEvents = [
         event_types.MESSAGE_RECEIVED,
         event_types.GENERATION_STARTED,
         event_types.GENERATION_ENDED,
     ];
     for (const event of activationEventsactivityEvents) {
         eventSource.on(event, onChatActivitymarkActivity);
+    }
 -    // Switching chats re-targets the per-profile idle clock but does NOT arm keepalive on its
 +    // Opening/switching a chat disarms keepalive — it must be re-armed by a new sent message.
 -    // own — opening/loading a chat is not proof that anything is cached server-side.
 +    eventSource.on(event_types.CHAT_CHANGED, onChatChanged);
 -    eventSource.on(event_types.CHAT_CHANGED, markActivity);
     // When the active profile changes, re-target the idle timer at the new profile using
     // ITS own last-activity time (do NOT mark activity — switching is not using it).

public/scripts/extensions/keepalive/settings.html+1 -1 Viewed

             <label for="keepalive_message" data-i18n="ext_keepalive_message">Keepalive message</label>
             <input id="keepalive_message" class="text_pole" type="text" />
             <small data-i18n="ext_keepalive_help">After this many seconds without activity on the active connection profile, the current chat plus this message (sent as a hidden user message) is submitted to that profile to keep its server-side prompt cache warm. The completion is capped to a single token and is never saved to the chat. Sending is briefly locked while it runs. Only the profile you're currently using is pinged; each profile has its own idle timer. Keepalive stays off until you've sent atsend leasta onenew message since openingin the tabcurrent chat (aopening, freshlyswitching loadedto, or reloading a chat isn't proof anythingits prompt is still cached), and it also skips a ping if its timer fired far later than scheduled (e.g. after the machine slept).</small>
             <hr>