ag-ai 0.4.0 → 0.4.1

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.1",
   "description": "Provider-neutral AI client and cluster runtime for the rpi-mega cluster.",
   "license": "ISC",
   "author": "admin@gec.dev",

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 { createWorkSignal, startPushChannel } from './push.mjs';
 import { createLocalRunner, startGenerationServer } from './server.mjs';
 import { GenerationStore } from './store.mjs';
 import { AnalyticaEvents } from './telemetry.mjs';
@@ -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,
   };
@@ -981,20 +975,14 @@ 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(),
+    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);
   const healthTimer = setInterval(() => void refreshHealth(), HEALTH_INTERVAL_MS);
   const claimLocal = async () => {
@@ -1081,7 +1069,7 @@ const main = async () => {
   } finally {
     clearInterval(heartbeatTimer);
     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,18 +40,10 @@ 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, log, connect }) => {
   const controller = new AbortController();
   let client;
   let subscription;
@@ -81,8 +53,8 @@ export const startPushChannel = ({
     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}`) },