ag-ai 0.4.0 → 0.4.2

package/dist/k8s/runner.js

@@ -40,8 +40,6 @@ const runnerStack = (context) => {
         throw new Error('AG_AI_GENERATION_CIDR is required');
     const imageProvider = context.env.AG_AI_IMAGE_PROVIDER ?? 'openai';
     const opencodeProvider = context.env.AG_AI_OPENCODE_PROVIDER;
-    // '1' makes the bridge claim cloud work when the queue pushes it (see runtime/push.mjs).
-    const push = context.env.AG_AI_PUSH;
     const agAiPackage = context.env.AG_AI_PACKAGE;
     if (!agAiPackage)
         throw new Error('AG_AI_PACKAGE is required');
@@ -95,7 +93,6 @@ const runnerStack = (context) => {
             (0, common_1.env)('AG_AI_OPENCODE_URL', opencodeUrl),
             (0, common_1.env)('AG_AI_OPENCODE_PASSWORD_FILE', secrets.opencode.file),
             ...(opencodeProvider === undefined ? [] : [(0, common_1.env)('AG_AI_OPENCODE_PROVIDER', opencodeProvider)]),
-            ...(push === undefined ? [] : [(0, common_1.env)('AG_AI_PUSH', push)]),
             (0, common_1.env)('AG_AI_IMAGE_PROVIDER', imageProvider),
             (0, common_1.env)('AG_AI_IMAGE_API_KEY_FILE', secrets.image.file),
             (0, common_1.env)('AG_AI_RUNNER_ID', common_1.RUNNER_APP),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ag-ai",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Provider-neutral AI client and cluster runtime for the rpi-mega cluster.",
   "license": "ISC",
   "author": "admin@gec.dev",
@@ -25,7 +25,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "dynamodb-reactive": "^0.3.0"
+    "dynamodb-reactive": "^0.5.0"
   },
   "devDependencies": {
     "@kubernetes/client-node": "2.0.0",

package/runtime/bridge.mjs

@@ -10,7 +10,7 @@ import { fileURLToPath } from 'node:url';
 import { createOpenCodeExecutor, DEFAULT_OPENCODE_URL } from './executor/opencode.mjs';
 import { createImageAdapter } from './image/adapter.mjs';
 import { normalizeGenerationRequest } from './protocol.mjs';
-import { createWorkSignal, parsePushFallbackMs, startPushChannel } from './push.mjs';
+import { createStatusReporter, createWorkSignal, startPushChannel } from './push.mjs';
 import { createLocalRunner, startGenerationServer } from './server.mjs';
 import { GenerationStore } from './store.mjs';
 import { AnalyticaEvents } from './telemetry.mjs';
@@ -25,7 +25,7 @@ const DEFAULT_GENERATION_STORE = '/generation-jobs';
 const DEFAULT_GENERATION_TOKEN_FILE = '/var/run/secrets/ag-ai-generation/token';
 const DEFAULT_ANALYTICA_TOKEN_FILE = '/var/run/secrets/ag-ai-analytica/token';
 const DEFAULT_IMAGE_PROVIDER = 'openai';
-const HEARTBEAT_INTERVAL_MS = 10_000;
+const STATUS_INTERVAL_MS = 10_000;
 const LEASE_HEARTBEAT_INTERVAL_MS = 5_000;
 const HEALTH_INTERVAL_MS = 30_000;
 const CLAIM_INTERVAL_MS = 5_000;
@@ -828,12 +828,6 @@ const readConfig = async (env = process.env) => {
     generationPort: env.AG_AI_GENERATION_PORT ?? DEFAULT_GENERATION_PORT,
     generationStore: path.resolve(env.AG_AI_GENERATION_STORE ?? DEFAULT_GENERATION_STORE),
     generationTokenFile: env.AG_AI_GENERATION_TOKEN_FILE ?? DEFAULT_GENERATION_TOKEN_FILE,
-    // AG_AI_PUSH=1 claims cloud work when the queue pushes it instead of every few seconds.
-    pushEnabled: env.AG_AI_PUSH === '1',
-    pushTicketPath: env.AG_AI_PUSH_TICKET_PATH,
-    pushHttpPath: env.AG_AI_PUSH_HTTP_PATH,
-    // How long a healthy push channel goes without a safety-net claim.
-    pushFallbackMs: parsePushFallbackMs(env.AG_AI_PUSH_FALLBACK_MS),
     analyticaToken,
     token,
   };
@@ -927,21 +921,29 @@ const main = async () => {
     return state.healthPromise;
   };
 
-  let heartbeatPromise;
-  const sendHeartbeat = async () => {
-    if (heartbeatPromise) {
-      return heartbeatPromise;
+  // The queue learns the runner is alive from the push socket's pings, so status is
+  // sent only when it changes or the socket reconnects, never on a timer.
+  const statusReporter = createStatusReporter(({ activeJobs, serverReady, modelReady }) =>
+    runner.heartbeat(activeJobs, serverReady, modelReady),
+  );
+  let statusPromise;
+  const reportStatus = async () => {
+    if (statusPromise) {
+      return statusPromise;
     }
-    heartbeatPromise = runner
-      // oxlint-disable-next-line typescript/no-unnecessary-condition -- state.job is assigned in the claim loop.
-      .heartbeat(state.job ? 1 : 0, state.health.serverReady, state.health.modelReady)
-      .then(() => true)
+    statusPromise = statusReporter
+      .update({
+        // oxlint-disable-next-line typescript/no-unnecessary-condition -- state.job is assigned in the claim loop.
+        activeJobs: state.job ? 1 : 0,
+        serverReady: state.health.serverReady,
+        modelReady: state.health.modelReady,
+      })
       .catch((error) => {
-        console.error(`[runner] runner heartbeat failed: ${redact(error, [config.token])}`);
-        return false;
+        console.error(`[runner] runner status report failed: ${redact(error, [config.token])}`);
       })
-      .then(async (workerReachable) => {
+      .then(async () => {
         // Probe data is private to this sidecar and contains no credentials.
+        const workerReachable = push.connected();
         const backendReady = state.health.serverReady && state.health.modelReady;
         const lanReady = generationServer !== undefined && backendReady;
         await writeFile(
@@ -956,9 +958,9 @@ const main = async () => {
       })
       .catch(() => console.error('[runner] could not update local health probe'))
       .finally(() => {
-        heartbeatPromise = undefined;
+        statusPromise = undefined;
       });
-    return heartbeatPromise;
+    return statusPromise;
   };
 
   let shutdownPromise;
@@ -981,21 +983,21 @@ const main = async () => {
   process.once('SIGTERM', () => void stop('SIGTERM'));
   process.once('SIGINT', () => void stop('SIGINT'));
 
-  const workSignal = createWorkSignal({
-    enabled: config.pushEnabled,
-    fallbackMs: config.pushFallbackMs,
+  // The queue pushes queued work over a WebSocket; cloud claims follow pushes.
+  const workSignal = createWorkSignal();
+  const push = startPushChannel({
+    baseUrl: new URL(config.queueUrl).origin,
+    token: config.token,
+    onWork: () => workSignal.wake(),
+    // A fresh connection may follow a queue restart, so the status is sent again.
+    onConnect: () => {
+      statusReporter.reset();
+      void reportStatus();
+    },
+    log: (message) => console.log(`[runner] ${redact(message, [config.token])}`),
   });
-  const push = config.pushEnabled
-    ? startPushChannel({
-        baseUrl: new URL(config.queueUrl).origin,
-        token: config.token,
-        ticketPath: config.pushTicketPath,
-        httpPath: config.pushHttpPath,
-        onWork: () => workSignal.wake(),
-        log: (message) => console.log(`[runner] ${redact(message, [config.token])}`),
-      })
-    : undefined;
-  const heartbeatTimer = setInterval(() => void sendHeartbeat(), HEARTBEAT_INTERVAL_MS);
+  // Local only: refreshes the health probe and sends status if it changed.
+  const statusTimer = setInterval(() => void reportStatus(), STATUS_INTERVAL_MS);
   const healthTimer = setInterval(() => void refreshHealth(), HEALTH_INTERVAL_MS);
   const claimLocal = async () => {
     if (!generationStore) return undefined;
@@ -1038,7 +1040,7 @@ const main = async () => {
   let preferLocal = false;
   try {
     await refreshHealth();
-    await sendHeartbeat();
+    await reportStatus();
     while (!state.stopping) {
       if (!state.health.serverReady || !state.health.modelReady) {
         await refreshHealth();
@@ -1079,9 +1081,9 @@ const main = async () => {
       await jobPromise;
     }
   } finally {
-    clearInterval(heartbeatTimer);
+    clearInterval(statusTimer);
     clearInterval(healthTimer);
-    push?.stop();
+    push.stop();
     await stop('shutdown');
   }
 };

package/runtime/push.mjs

@@ -1,43 +1,23 @@
 /* eslint-disable import/extensions -- Native Node ESM requires file extensions. */
 // Push-driven cloud claims. The queue pushes "work queued" over a reactive
-// WebSocket, so the runner claims only when there is work, plus a slow fallback
-// claim that covers missed pushes and queues without a push channel.
+// WebSocket, so the runner claims only when there is work. Every (re)connect
+// delivers a fresh snapshot of queued work, so work queued while the socket was
+// down is claimed on reconnect.
 
 export const CLUSTER_WORK_PATH = 'cluster.work';
-export const DEFAULT_PUSH_FALLBACK_MS = 60_000;
-export const DEFAULT_PUSH_TICKET_PATH = '/api/cluster/token';
-export const DEFAULT_PUSH_HTTP_PATH = '/api/cluster/reactive';
+const TICKET_PATH = '/api/cluster/token';
+const HTTP_PATH = '/api/cluster/reactive';
 
-/**
- * Reads AG_AI_PUSH_FALLBACK_MS. Unset, blank or invalid values keep the default,
- * so a typo can never stop the fallback claim.
- */
-export const parsePushFallbackMs = (value) => {
-  const milliseconds = Number(value);
-  return value?.trim() && Number.isSafeInteger(milliseconds) && milliseconds >= 1_000
-    ? milliseconds
-    : DEFAULT_PUSH_FALLBACK_MS;
-};
-
-/**
- * Decides when a cloud claim is worth a request. Disabled, it always claims, which
- * keeps the original polling behaviour.
- */
-export const createWorkSignal = ({
-  enabled,
-  fallbackMs = DEFAULT_PUSH_FALLBACK_MS,
-  now = Date.now,
-}) => {
+/** Decides when a cloud claim is worth a request: on start, and after each push. */
+export const createWorkSignal = () => {
   // Claim once at start: work may have been queued while the runner was down.
   let pending = true;
-  let nextFallbackAt = 0;
   let wakeWaiter;
   return {
-    shouldClaim: () => !enabled || pending || now() >= nextFallbackAt,
-    /** A claim found no work: wait for a push or the fallback. */
+    shouldClaim: () => pending,
+    /** A claim found no work: wait for the next push. */
     drained: () => {
       pending = false;
-      nextFallbackAt = now() + fallbackMs;
     },
     /** Work was pushed: claim on the next loop, waking an idle wait now. */
     wake: () => {
@@ -60,32 +40,36 @@ export const createWorkSignal = ({
 
 /**
  * Holds the reactive WebSocket and calls `onWork` whenever the pushed snapshot
- * lists queued work. Never throws: failures are logged and the fallback claim
- * keeps the runner working.
+ * lists queued work. Never throws: failures are logged and the connection keeps
+ * retrying, and the reconnect snapshot catches up on anything queued meanwhile.
  */
-export const startPushChannel = ({
-  baseUrl,
-  token,
-  ticketPath = DEFAULT_PUSH_TICKET_PATH,
-  httpPath = DEFAULT_PUSH_HTTP_PATH,
-  onWork,
-  log,
-  connect,
-}) => {
+export const startPushChannel = ({ baseUrl, token, onWork, onConnect, log, connect }) => {
   const controller = new AbortController();
   let client;
   let subscription;
+  // The socket is the runner's liveness: the hub sees its pings, and the client
+  // replaces it when a ping goes unanswered, so this flag tracks real reachability.
+  let isConnected = false;
   const ready = (async () => {
     const connectClusterWorker =
       connect ?? (await import('dynamodb-reactive/cluster')).connectClusterWorker;
     client = await connectClusterWorker({
       baseUrl,
       runnerToken: token,
-      ticketPath,
-      httpPath,
+      ticketPath: TICKET_PATH,
+      httpPath: HTTP_PATH,
       signal: controller.signal,
       onRetry: (error) => log(`push connect failed; retrying: ${error.message}`),
-      client: { onError: (error) => log(`push socket error: ${error.message}`) },
+      client: {
+        onError: (error) => log(`push socket error: ${error.message}`),
+        onConnect: () => {
+          isConnected = true;
+          onConnect?.();
+        },
+        onDisconnect: () => {
+          isConnected = false;
+        },
+      },
     });
     if (controller.signal.aborted) {
       client.disconnect();
@@ -103,6 +87,7 @@ export const startPushChannel = ({
   });
   return {
     ready,
+    connected: () => isConnected,
     stop: () => {
       controller.abort();
       subscription?.unsubscribe();
@@ -110,3 +95,31 @@ export const startPushChannel = ({
     },
   };
 };
+
+/**
+ * Sends the runner's status only when it changes, or after `reset` (each push
+ * reconnect), instead of on a timer: the push socket already proves liveness.
+ * A failed send is retried by the next `update`.
+ */
+export const createStatusReporter = (send) => {
+  let reported;
+  let inFlight;
+  return {
+    update: (status) => {
+      const key = JSON.stringify(status);
+      if (inFlight) return inFlight;
+      if (key === reported) return Promise.resolve();
+      inFlight = send(status)
+        .then(() => {
+          reported = key;
+        })
+        .finally(() => {
+          inFlight = undefined;
+        });
+      return inFlight;
+    },
+    reset: () => {
+      reported = undefined;
+    },
+  };
+};