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(Re)schedules the idlekeepalive timerfor the ACTIVE profile based on thehow currentlong settings.it has been since
  * that profile's last message. Does nothing (and leaves the timer cleared) when the featurekeepalive is disabled.
 + * disabled for the active connection. Called on activity AND whenever the active profile
 + * changes, so each profile keeps its own independent idle clock.
  */
 function resetIdleTimerscheduleIdleTimer() {
     clearIdleTimer();
 -    const s = extension_settings[MODULE];
 +    if (!isKeepaliveEnabledForActive()) {
 -    if (!s.enabled) {
         return;
+    }
     idleTimerconst =timeoutMs setTimeout(fireKeepalive,= Math.max(60, Number(sextension_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'connection fromin the StreamingProcessor)background. andEach areprofile's neveridle savedclock tois chattracked 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*
  * intemporary flight,response-length weoverride holdfor the same generationduration lockof the blockingrequest, summaryso pathwe uses:hold the
 - * setSendButtonState(true) flips `is_send_press`, which every user send entry
 + * same generation lock the blocking summary path uses — setSendButtonState(true) flips
  * `is_send_press` (which every user send entry point checks and bails on, and deactivateSendButtons() reflects the busyand
  * statedeactivateSendButtons() inreflects the UI.busy Bothstate are— releasedand 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) {
         resetIdleTimerscheduleIdleTimer();
         return;
+    }

     deactivateSendButtons();
     try {
         await generateQuietPrompt({ quietPrompt: sextension_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;
         resetIdleTimerscheduleIdleTimer();
 +    }
 +}
++
 +/**
 + * 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] = 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();
         resetIdleTimerscheduleIdleTimer();
     });
     $('#keepalive_timeout').on('input', function () {
         extension_settings[MODULE].timeoutSeconds = Number($(this).val()) || 295;
         saveSettingsDebounced();
         resetIdleTimerscheduleIdleTimer();
     });
     $('#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();
     // ResetAny thechat idleor timergeneration onactivity anycounts chatas or"using" generationthe activityactive profile.
     const activityEvents = [
         event_types.MESSAGE_SENT,
         event_types.MESSAGE_RECEIVED,

         event_types.CHAT_CHANGED,
     ];
     for (const event of activityEvents) {
         eventSource.on(event, resetIdleTimermarkActivity);
+    }
 -    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 (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 withwithout noactivity chaton activitythe active connection profile, a hidden background prompt (the current chat plus this message) is sent to the activethat modelprofile to keep theits 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>