ag-ai 0.4.1 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ag-ai",
-  "version": "0.4.1",
+  "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, 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;
@@ -921,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(
@@ -950,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,9 +989,15 @@ const main = async () => {
     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 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;
@@ -1026,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();
@@ -1067,7 +1081,7 @@ const main = async () => {
       await jobPromise;
     }
   } finally {
-    clearInterval(heartbeatTimer);
+    clearInterval(statusTimer);
     clearInterval(healthTimer);
     push.stop();
     await stop('shutdown');

package/runtime/push.mjs

@@ -43,10 +43,13 @@ export const createWorkSignal = () => {
  * 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, 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;
@@ -57,7 +60,16 @@ export const startPushChannel = ({ baseUrl, token, onWork, log, connect }) => {
       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();
@@ -75,6 +87,7 @@ export const startPushChannel = ({ baseUrl, token, onWork, log, connect }) => {
   });
   return {
     ready,
+    connected: () => isConnected,
     stop: () => {
       controller.abort();
       subscription?.unsubscribe();
@@ -82,3 +95,31 @@ export const startPushChannel = ({ baseUrl, token, onWork, log, connect }) => {
     },
   };
 };
+
+/**
+ * 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;
+    },
+  };
+};