ag-ai 0.3.5 → 0.3.7

package/dist/k8s/runner.js

@@ -40,6 +40,8 @@ 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');
@@ -93,6 +95,7 @@ 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),
@@ -168,8 +171,9 @@ const runnerStack = (context) => {
             name: 'install-ag-ai',
             image: facilities.image('ag-ai-runner'),
             command: ['npm'],
-            // The runtime imports only Node builtins. Client-only dependencies are
-            // optional, so omitting them keeps the pod install lean.
+            // The runtime needs only dynamodb-reactive (for the push channel) beyond Node
+            // builtins. Client-only dependencies are optional, so omitting them keeps the
+            // pod install lean.
             args: [
                 'install',
                 '--prefix',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ag-ai",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Provider-neutral AI client and cluster runtime for the rpi-mega cluster.",
   "license": "ISC",
   "author": "admin@gec.dev",
@@ -24,7 +24,9 @@
     "./image": "./runtime/image/adapter.mjs",
     "./package.json": "./package.json"
   },
-  "dependencies": {},
+  "dependencies": {
+    "dynamodb-reactive": "^0.3.0"
+  },
   "devDependencies": {
     "@kubernetes/client-node": "2.0.0",
     "@types/node": "^26.6.4",

package/runtime/bridge.mjs

@@ -10,6 +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 { createLocalRunner, startGenerationServer } from './server.mjs';
 import { GenerationStore } from './store.mjs';
 import { AnalyticaEvents } from './telemetry.mjs';
@@ -827,6 +828,10 @@ 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,
     analyticaToken,
     token,
   };
@@ -974,6 +979,17 @@ const main = async () => {
   process.once('SIGTERM', () => void stop('SIGTERM'));
   process.once('SIGINT', () => void stop('SIGINT'));
 
+  const workSignal = createWorkSignal({ enabled: config.pushEnabled });
+  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);
   const healthTimer = setInterval(() => void refreshHealth(), HEALTH_INTERVAL_MS);
   const claimLocal = async () => {
@@ -994,6 +1010,7 @@ const main = async () => {
     }
   };
   const claimCloud = async () => {
+    if (!workSignal.shouldClaim()) return undefined;
     let claimResponse;
     try {
       claimResponse = await runner.claim();
@@ -1002,7 +1019,10 @@ const main = async () => {
       if (error instanceof UncertainRequestError) return { uncertain: true };
       return undefined;
     }
-    if (!claimResponse?.job) return undefined;
+    if (!claimResponse?.job) {
+      workSignal.drained();
+      return undefined;
+    }
     try {
       return { source: 'cloud', runner, job: validateJobEnvelope(claimResponse.job) };
     } catch (error) {
@@ -1037,7 +1057,7 @@ const main = async () => {
         continue;
       }
       if (!selection) {
-        await delay(CLAIM_INTERVAL_MS);
+        await workSignal.wait(CLAIM_INTERVAL_MS);
         continue;
       }
       const activeRunner = selection.runner;
@@ -1056,6 +1076,7 @@ const main = async () => {
   } finally {
     clearInterval(heartbeatTimer);
     clearInterval(healthTimer);
+    push?.stop();
     await stop('shutdown');
   }
 };

package/runtime/push.mjs

@@ -0,0 +1,101 @@
+/* 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.
+
+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';
+
+/**
+ * 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,
+}) => {
+  // 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. */
+    drained: () => {
+      pending = false;
+      nextFallbackAt = now() + fallbackMs;
+    },
+    /** Work was pushed: claim on the next loop, waking an idle wait now. */
+    wake: () => {
+      pending = true;
+      wakeWaiter?.();
+    },
+    /** Idle wait that a push ends early. */
+    wait: (milliseconds) =>
+      new Promise((resolve) => {
+        const done = () => {
+          clearTimeout(timer);
+          if (wakeWaiter === done) wakeWaiter = undefined;
+          resolve();
+        };
+        const timer = setTimeout(done, milliseconds);
+        wakeWaiter = done;
+      }),
+  };
+};
+
+/**
+ * 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.
+ */
+export const startPushChannel = ({
+  baseUrl,
+  token,
+  ticketPath = DEFAULT_PUSH_TICKET_PATH,
+  httpPath = DEFAULT_PUSH_HTTP_PATH,
+  onWork,
+  log,
+  connect,
+}) => {
+  const controller = new AbortController();
+  let client;
+  let subscription;
+  const ready = (async () => {
+    const connectClusterWorker =
+      connect ?? (await import('dynamodb-reactive/cluster')).connectClusterWorker;
+    client = await connectClusterWorker({
+      baseUrl,
+      runnerToken: token,
+      ticketPath,
+      httpPath,
+      signal: controller.signal,
+      onRetry: (error) => log(`push connect failed; retrying: ${error.message}`),
+      client: { onError: (error) => log(`push socket error: ${error.message}`) },
+    });
+    if (controller.signal.aborted) {
+      client.disconnect();
+      return;
+    }
+    subscription = client.subscribe(CLUSTER_WORK_PATH, {
+      onData: (items) => {
+        if (Array.isArray(items) && items.length > 0) onWork();
+      },
+      onError: (error) => log(`push subscription error: ${error.message}`),
+    });
+    log('push channel connected');
+  })().catch((error) => {
+    if (!controller.signal.aborted) log(`push channel stopped: ${error?.message ?? error}`);
+  });
+  return {
+    ready,
+    stop: () => {
+      controller.abort();
+      subscription?.unsubscribe();
+      client?.disconnect();
+    },
+  };
+};