Cache Keepalive: per-profile idle tracking + per-profile enable; ping only the active profile

edc60c58a76d3dafc9d41f2f0496991d0d92acf5

permissionBRICK <permissionBRICK@gmail.com>

Parents: 03bd47c310151c3524cab3143c7aef2797018041

public/scripts/extensions/keepalive/index.js+145 -33 Viewed

 // cache), but we never pay for a full completion.
 const KEEPALIVE_RESPONSE_LENGTH = 1;
+// Idle-tracking key used when no connection profile is active (manual API panel).
+const NONE_KEY = '__none__';
+// When the active profile is already past its timeout (e.g. you just switched back
+// to a profile that went cold), wait this short grace before pinging so an imminent
+// user message can pre-empt the keepalive.
+const EXPIRED_GRACE_MS = 3000;
 const defaultSettings = {
     enabled: false,
     timeoutSeconds: 295,
     message: 'Keep the cache warm.',
+    // Per-profile enable map: { [profileId]: boolean }. Unlisted profiles default to enabled.
+    profiles: {},
 };
 let idleTimer = null;
 let keepaliveActive = false;
+// Per-profile "time since last message", keyed by connection profile id (or NONE_KEY).
+// In-memory only: on reload every profile is treated as freshly active.
+const lastActivity = {};
+/**
+ * @returns {string} The active connection profile id, or NONE_KEY for a manual connection.
+ */
+function getActiveProfileKey() {
+    return extension_settings.connectionManager?.selectedProfile || NONE_KEY;
+}
+/**
+ * Whether keepalive should run for the CURRENTLY ACTIVE connection. Requires the global
+ * master switch; for a real profile it also requires that profile's per-profile toggle
+ * (default on). A manual connection (no profile selected) is governed by the master switch alone.
+ * @returns {boolean}
+ */
+function isKeepaliveEnabledForActive() {
+    const s = extension_settings[MODULE];
+    if (!s.enabled) {
+        return false;
+    }
+    const profileId = extension_settings.connectionManager?.selectedProfile;
+    if (!profileId) {
+        return true;
+    }
+    const perProfile = s.profiles?.[profileId];
+    return perProfile === undefined ? true : !!perProfile;
+}
 /**
  * Clears the pending idle timer, if any.

+}
 /**
- * Restarts the idle timer based on the current settings.
+ * (Re)schedules the keepalive for the ACTIVE profile based on how long it has been since
- * Does nothing (and leaves the timer cleared) when the feature is disabled.
+ * that profile's last message. Does nothing (and leaves the timer cleared) when keepalive is
+ * disabled for the active connection. Called on activity AND whenever the active profile
+ * changes, so each profile keeps its own independent idle clock.
  */
-function resetIdleTimer() {
+function scheduleIdleTimer() {
     clearIdleTimer();
-    const s = extension_settings[MODULE];
+    if (!isKeepaliveEnabledForActive()) {
-    if (!s.enabled) {
         return;
+    }
-    idleTimer = setTimeout(fireKeepalive, Math.max(60, Number(s.timeoutSeconds) || 295) * 1000);
+    const timeoutMs = Math.max(60, Number(extension_settings[MODULE].timeoutSeconds) || 295) * 1000;
+    const last = lastActivity[getActiveProfileKey()] ?? Date.now();
+    const remaining = timeoutMs - (Date.now() - last);
+    idleTimer = setTimeout(fireKeepalive, remaining > 0 ? remaining : EXPIRED_GRACE_MS);
+}
+/**
+ * Marks the active profile as just-used (resets its idle clock) and reschedules its keepalive.
+ */
+function markActivity() {
+    lastActivity[getActiveProfileKey()] = Date.now();
+    scheduleIdleTimer();
+}
 /**

  * completion is capped to a single token (KEEPALIVE_RESPONSE_LENGTH) so we never
  * pay for a real response.
+ *
- * Quiet generations are forced non-streaming by the core (Generate excludes
+ * Only the CURRENTLY ACTIVE profile is ever pinged — keepalive never switches the
- * type === 'quiet' from the StreamingProcessor) and are never saved to chat, so
+ * connection in the background. Each profile's idle clock is tracked separately, so
- * the output is simply discarded. We deliberately do NOT hook the global
+ * switching profiles re-targets the timer at whichever profile is now active.
- * STREAM_TOKEN_RECEIVED / stopGeneration() path: quiet requests never emit it,
- * and using it would risk aborting a concurrent user generation.
+ *
- * generateQuietPrompt's responseLength applies a *global* temporary
+ * Quiet generations are forced non-streaming by the core (Generate excludes
- * response-length override for the duration of the request. To make sure a user
+ * type === 'quiet' from the StreamingProcessor) and are never saved to chat, so the
- * generation can never start (and inherit that override) while the keepalive is
+ * output is simply discarded. generateQuietPrompt's responseLength applies a *global*
- * in flight, we hold the same generation lock the blocking summary path uses:
+ * temporary response-length override for the duration of the request, so we hold the
- * setSendButtonState(true) flips `is_send_press`, which every user send entry
+ * same generation lock the blocking summary path uses — setSendButtonState(true) flips
- * point checks and bails on, and deactivateSendButtons() reflects the busy
+ * `is_send_press` (which every user send entry point checks and bails on) and
- * state in the UI. Both are released in `finally`.
+ * deactivateSendButtons() reflects the busy state — and release both in `finally`.
  */
 async function fireKeepalive() {
-    const s = extension_settings[MODULE];
+    if (!isKeepaliveEnabledForActive()) {
-    if (!s.enabled) {
         return;
+    }
     // Never start while any generation is in progress, or while a previous
     // keepalive is still running. Reschedule and bail.
     if (keepaliveActive || isGenerating() || streamingProcessor) {
-        resetIdleTimer();
+        scheduleIdleTimer();
         return;
+    }

     deactivateSendButtons();
     try {
-        await generateQuietPrompt({ quietPrompt: s.message, responseLength: KEEPALIVE_RESPONSE_LENGTH });
+        await generateQuietPrompt({ quietPrompt: extension_settings[MODULE].message, responseLength: KEEPALIVE_RESPONSE_LENGTH });
+        // The ping kept this profile warm; treat it as fresh activity so the next
+        // keepalive for it is a full timeout away.
+        lastActivity[getActiveProfileKey()] = Date.now();
     } catch (error) {
         // Best-effort: any failure here is harmless and intentionally swallowed.
         console.debug('[Keepalive] Background generation ended:', error);

         setSendButtonState(false);
         activateSendButtons();
         keepaliveActive = false;
-        resetIdleTimer();
+        scheduleIdleTimer();
+    }
+}
+/**
+ * Renders the per-profile enable checkboxes from the current Connection Manager profiles.
+ */
+function renderProfileToggles() {
+    const container = $('#keepalive_profiles_list');
+    if (!container.length) {
+        return;
+    }
+    container.empty();
+    const profiles = extension_settings.connectionManager?.profiles;
+    if (!Array.isArray(profiles) || profiles.length === 0) {
+        container.append(
+            $('<small>')
+                .attr('data-i18n', 'ext_keepalive_no_profiles')
+                .text('No connection profiles found. Keepalive uses the active model, governed by the master toggle above.'),
+        );
+        return;
+    }
+    const perProfile = extension_settings[MODULE].profiles || {};
+    const sorted = profiles.slice().sort((a, b) => String(a.name).localeCompare(String(b.name)));
+    for (const profile of sorted) {
+        const enabled = perProfile[profile.id] === undefined ? true : !!perProfile[profile.id];
+        const label = $('<label>').addClass('checkbox_label');
+        const input = $('<input>')
+            .attr('type', 'checkbox')
+            .addClass('keepalive_profile_toggle')
+            .attr('data-profile-id', profile.id)
+            .prop('checked', enabled);
+        const span = $('<span>').text(profile.name);
+        label.append(input, span);
+        container.append(label);
+    }
+}

         extension_settings[MODULE] = {};
+    }
-    if (Object.keys(extension_settings[MODULE]).length === 0) {
-        Object.assign(extension_settings[MODULE], defaultSettings);
-    }
     for (const key of Object.keys(defaultSettings)) {
         if (extension_settings[MODULE][key] === undefined) {
-            extension_settings[MODULE][key] = defaultSettings[key];
+            extension_settings[MODULE][key] = structuredClone(defaultSettings[key]);
+        }
+    }
+    // Guard against a corrupted/legacy value for the per-profile map.
+    if (typeof extension_settings[MODULE].profiles !== 'object' || extension_settings[MODULE].profiles === null) {
+        extension_settings[MODULE].profiles = {};
+    }
     $('#keepalive_enabled').prop('checked', extension_settings[MODULE].enabled);
     $('#keepalive_timeout').val(extension_settings[MODULE].timeoutSeconds);
     $('#keepalive_message').val(extension_settings[MODULE].message);
+    renderProfileToggles();
+}
 /**

     $('#keepalive_enabled').on('change', function () {
         extension_settings[MODULE].enabled = !!$(this).prop('checked');
         saveSettingsDebounced();
-        resetIdleTimer();
+        scheduleIdleTimer();
     });
     $('#keepalive_timeout').on('input', function () {
         extension_settings[MODULE].timeoutSeconds = Number($(this).val()) || 295;
         saveSettingsDebounced();
-        resetIdleTimer();
+        scheduleIdleTimer();
     });
     $('#keepalive_message').on('input', function () {
         extension_settings[MODULE].message = String($(this).val());
         saveSettingsDebounced();
     });
+    // Per-profile toggles are rendered dynamically; use a delegated handler.
+    $('#keepalive_profiles_list').on('change', '.keepalive_profile_toggle', function () {
+        const profileId = $(this).attr('data-profile-id');
+        if (!profileId) {
+            return;
+        }
+        extension_settings[MODULE].profiles[profileId] = !!$(this).prop('checked');
+        saveSettingsDebounced();
+        // If the toggled profile is the one currently active, reschedule immediately.
+        if (profileId === extension_settings.connectionManager?.selectedProfile) {
+            scheduleIdleTimer();
+        }
+    });
+}
 async function init() {

     loadSettings();
     setupListeners();
-    // Reset the idle timer on any chat or generation activity.
+    // Any chat or generation activity counts as "using" the active profile.
     const activityEvents = [
         event_types.MESSAGE_SENT,
         event_types.MESSAGE_RECEIVED,

         event_types.CHAT_CHANGED,
     ];
     for (const event of activityEvents) {
-        eventSource.on(event, resetIdleTimer);
+        eventSource.on(event, markActivity);
+    }
-    resetIdleTimer();
+    // 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).
+    eventSource.on(event_types.CONNECTION_PROFILE_LOADED, scheduleIdleTimer);
+    // Keep the per-profile toggle list in sync with Connection Manager.
+    eventSource.on(event_types.CONNECTION_PROFILE_CREATED, renderProfileToggles);
+    eventSource.on(event_types.CONNECTION_PROFILE_UPDATED, renderProfileToggles);
+    eventSource.on(event_types.CONNECTION_PROFILE_DELETED, renderProfileToggles);
+    scheduleIdleTimer();
+}

public/scripts/extensions/keepalive/settings.html+8 -2 Viewed

         <div class="inline-drawer-content">
             <label class="checkbox_label" for="keepalive_enabled">
                 <input id="keepalive_enabled" type="checkbox" />
-                <span data-i18n="ext_keepalive_enable">Enable cache keepalive</span>
+                <span data-i18n="ext_keepalive_enable">Enable cache keepalive (master switch)</span>
             </label>
             <label for="keepalive_timeout" data-i18n="ext_keepalive_timeout">Idle timeout (seconds)</label>

             <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 with no chat activity, a hidden background prompt (the current chat plus this message) is sent to the active model to keep the 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.</small>
+            <small data-i18n="ext_keepalive_help">After this many seconds without activity on the active connection profile, a hidden background prompt (the current chat plus this message) is sent 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.</small>
+            <hr>
+            <label data-i18n="ext_keepalive_profiles_label">Keepalive per connection profile</label>
+            <small data-i18n="ext_keepalive_profiles_desc">Turn keepalive on only for the profiles whose providers support prompt caching (leave the others off so you don't waste requests). The master switch above must be enabled. Profiles default to on.</small>
+            <div id="keepalive_profiles_list" class="keepalive_profiles_list"></div>
         </div>
     </div>
 </div>