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 been "armed" this browser-tab session. It stays dormant until the
+// Whether keepalive is "armed" for the CURRENT chat. It stays dormant until the user sends a new
-// first real message/generation happens in the tab, because on a fresh load (even with chat
+// message in the open chat — on a freshly loaded or switched-to chat (even with history already
-// history already present) we have no way to know whether anything is still cached
+// present) we have no way to know whether its prompt is still cached server-side, so pinging would
-// server-side — so pinging before then would be pointless. Resets on page reload.
+// be pointless. Reset 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 this tab session, or when it is disabled for the active connection.
+ * has been armed for the current chat, 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 onChatActivity() {
+function onMessageSent() {
     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
-    // real message re-arms keepalive, exactly like a freshly opened tab.
+    // sent message re-arms keepalive, exactly like a freshly opened chat.
     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 activationEvents) {
+    for (const event of activityEvents) {
-        eventSource.on(event, onChatActivity);
+        eventSource.on(event, markActivity);
+    }
-    // 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 at least one message since opening the tab (a freshly loaded chat isn't proof anything is still cached).</small>
+            <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 send a new message in the current chat (opening, switching to, or reloading a chat isn't proof its 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>