Make keepalive registration self-healing

d4a0852ee81d3a22b6339426124c3783e2c37481

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

public/scripts/extensions/keepalive/index.js+30 -6 Viewed

 let refreshPromise = null;
 let refreshRequested = false;
 let refreshTimer = null;
 +let generationRefreshTimer = null;
 +let retryTimer = null;
 let preparingJob = false;
 let lifecycleVersion = 0;
 // Whether keepalive is "armed" for the CURRENT chat. It stays dormant until the user sends a new

 async function stopBackendJob() {
     lifecycleVersion++;
     jobRegistered = false;
 +    clearTimeout(retryTimer);
     try {
         await postKeepaliveBackend('stop', {});
     } catch (error) {

+}
 async function sendBackendHeartbeat(activity = false) {
     if (!jobRegistered || !armed || !isKeepaliveEnabledForActive()) {
 +        return;
 +    }
 +    // Registration is normally created as soon as a response finishes. If that one-shot event
 +    // was missed (or registration failed), the regular heartbeat must self-heal instead of doing
 +    // nothing forever.
 +    if (!jobRegistered) {
 +        queueJobRefresh();
         return;
+    }
     try {

@@ -278,11 +288,13 @@ async function registerBackendJob() {
278	288	await stopBackendJob();
279	289	return;
280	290	}
	291	+ clearTimeout(retryTimer);
281	292	jobRegistered = true;
282	293	} catch (error) {
283	294	jobRegistered = false;
284	295	console.debug('[Keepalive] Could not register backend job:', error);
285	296	setTimeoutclearTimeout(queueJobRefresh, RETRY_INTERVAL_MSretryTimer);
	297	+ retryTimer = setTimeout(queueJobRefresh, RETRY_INTERVAL_MS);
286	298	}
287	299	}
288	300

     refreshTimer = setTimeout(queueJobRefresh, SETTINGS_REFRESH_DELAY_MS);
+}
 +function scheduleGenerationJobRefresh() {
 +    clearTimeout(generationRefreshTimer);
 +    generationRefreshTimer = setTimeout(() => {
 +        if (armed && isKeepaliveEnabledForActive()) {
 +            queueJobRefresh();
 +        }
 +    }, SETTINGS_REFRESH_DELAY_MS);
 +}
++
 function setupHeartbeatLoop() {
     clearInterval(heartbeatTimer);
     heartbeatTimer = setInterval(() => void sendBackendHeartbeat(), HEARTBEAT_INTERVAL_MS);

 function onGenerationEnded() {
     markActivity();
 -    if (armed && isKeepaliveEnabledForActive()) {
 +    scheduleGenerationJobRefresh();
 -        queueJobRefresh();
 +}
 -    }
++
 +function onMessageReceived() {
 +    markActivity();
 +    scheduleGenerationJobRefresh();
+}
 function onChatContentChanged() {

     // Activity resets the backend deadline but never arms keepalive on its own. A completed
     // generation or a chat edit also refreshes the stored request so the server always replays
     // the latest prompt assembled by the UI.
     eventSource.on(event_types.MESSAGE_RECEIVED, markActivityonMessageReceived);
     eventSource.on(event_types.GENERATION_STARTED, onGenerationStarted);
     eventSource.on(event_types.GENERATION_ENDED, onGenerationEnded);
     eventSource.on(event_types.MESSAGE_EDITED, onChatContentChanged);

src/endpoints/keepalive.js+3 -0 Viewed

     const timeout = setTimeout(() => controller.abort(new Error('Keepalive request timed out')), 120000);
     timeout.unref?.();
     try {
 +        console.info(`[Keepalive] Dispatching job ${job.id} to ${job.endpoint}`);
         const response = await fetch(`${job.request.origin}${job.endpoint}`, {
             method: 'POST',
             headers: job.request.headers,

@@ -163,6 +164,7 @@ async function dispatchKeepaliveRequest(job) {
163	164	if (!response.ok) {
164	165	throw new Error(`HTTP ${response.status}`);
165	166	}
	167	+ console.info(`[Keepalive] Job ${job.id} completed successfully`);
166	168	} finally {
167	169	clearTimeout(timeout);
168	170	}

             delayMs: request.body.delayMs,
             request: getReplayRequest(request),
         });
 +        console.info(`[Keepalive] Registered job ${id}; first run in ${job.nextRun - Date.now()}ms, interval ${job.intervalMs}ms`);
         return response.send({ ok: true, nextRun: job.nextRun, leaseMs: FRONTEND_LEASE_MS });
     } catch (error) {
         return response.status(400).send({ error: String(error.message || error) });