ag-ai 0.4.1 → 0.4.3

package/dist/k8s/opencode.js

@@ -1,8 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.opencodeStack = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
 const ag_rpi_mega_1 = require("ag-rpi-mega");
 const common_1 = require("./common");
+/** The runtime's tier table is the single source of truth for which model and effort each tier runs. */
+const MODEL_TIERS = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.join(__dirname, '..', '..', 'runtime', 'model-tiers.json'), 'utf8'));
 /** The published OpenCode CLI is installed into a writable emptyDir at pod start. */
 const OPENCODE_PACKAGE = 'opencode-ai@1.18.31';
 const OPENCODE_PREFIX = '/opt/opencode';
@@ -49,19 +56,17 @@ const opencodeStack = (context) => {
             (0, common_1.env)('XDG_CACHE_HOME', '/data/opencode/cache'),
             // The unrestricted /provider response processes thousands of models from
             // unconfigured providers on every request, exceeding the runner's budget.
-            // Each advertised model carries the reasoning effort its consumer asks
-            // for: sol at high for draft copy, 5.5 at high for draft images, and luna
-            // at max for the client's cluster fallback. OpenCode merges these entries
-            // with its model catalogue; it does not replace it.
+            // Each advertised model carries the reasoning effort of the tier that
+            // selects it. OpenCode merges these entries with its model catalogue; it
+            // does not replace it.
             (0, common_1.env)('OPENCODE_CONFIG_CONTENT', JSON.stringify({
                 enabled_providers: ['openai', 'google'],
                 provider: {
                     openai: {
-                        models: {
-                            'gpt-5.6-sol': { options: { reasoningEffort: 'high' } },
-                            'gpt-5.6-luna': { options: { reasoningEffort: 'max' } },
-                            'gpt-5.5': { options: { reasoningEffort: 'high' } },
-                        },
+                        models: Object.fromEntries(Object.values(MODEL_TIERS).map(({ model, reasoningEffort }) => [
+                            model,
+                            { options: { reasoningEffort } },
+                        ])),
                     },
                 },
             })),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ag-ai",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "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/model-tiers.json

@@ -0,0 +1,4 @@
+{
+  "fast": { "model": "gpt-6-luna", "reasoningEffort": "medium" },
+  "quality": { "model": "gpt-6.1-sol", "reasoningEffort": "medium" }
+}

package/runtime/protocol.mjs

@@ -3,6 +3,15 @@
 // differ.
 
 import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+
+/**
+ * The only place that names a model: each `prefer` tier maps to one model and
+ * effort. Callers send a tier; the model is resolved when the call is made.
+ */
+const MODEL_TIERS = JSON.parse(
+  readFileSync(new URL('./model-tiers.json', import.meta.url), 'utf8'),
+);
 
 const GENERATION_VERSION = 1;
 const MAX_TEXT_BYTES = 2 * 1024 * 1024;
@@ -257,21 +266,9 @@ const normalizeGenerationRequest = (value, models) => {
   if (prefer !== undefined && prefer !== 'fast' && prefer !== 'quality') {
     throw new GenerationProtocolError(400, 'invalid_request', 'prefer is invalid');
   }
-  let requestedModel;
-  if (request.model !== undefined) {
-    requestedModel = boundedString(request.model, 160, 'model');
-  } else if (prefer === 'fast') {
-    requestedModel = catalog.find((candidate) => candidate.prefer.includes('fast'))?.id;
-    requestedModel ??= catalog.find((candidate) => /(?:mini|luna)$/i.test(candidate.id))?.id;
-    if (!requestedModel) throw unsupported('fast model preference');
-  } else {
-    requestedModel =
-      catalog.find((candidate) => candidate.isDefault && candidate.prefer.includes('quality'))
-        ?.id ??
-      catalog.find((candidate) => candidate.isDefault)?.id ??
-      catalog.find((candidate) => candidate.prefer.includes('quality'))?.id ??
-      catalog[0].id;
-  }
+  const tier = MODEL_TIERS[prefer ?? 'quality'];
+  const requestedModel =
+    request.model === undefined ? tier.model : boundedString(request.model, 160, 'model');
   const model =
     catalog.find((candidate) => candidate.id === requestedModel) ??
     (requestedModel.includes('/') ? undefined : uniqueSuffixModel(catalog, requestedModel));
@@ -290,7 +287,9 @@ const normalizeGenerationRequest = (value, models) => {
   const output = normalizeOutput(request.output, capabilities);
   const reasoningEffort =
     request.reasoningEffort === undefined
-      ? (capabilities.defaultReasoningEffort ?? capabilities.supportedReasoningEfforts[0])
+      ? request.model === undefined
+        ? tier.reasoningEffort
+        : (capabilities.defaultReasoningEffort ?? capabilities.supportedReasoningEfforts[0])
       : boundedString(request.reasoningEffort, 32, 'reasoningEffort');
   if (!reasoningEffort) {
     throw new GenerationProtocolError(
@@ -358,6 +357,7 @@ const publicModelCatalog = (models, { ready = true } = {}) => ({
 
 export {
   GENERATION_VERSION,
+  MODEL_TIERS,
   MAX_INPUT_ATTACHMENT_BYTES,
   MAX_INPUT_TOTAL_BYTES,
   GenerationProtocolError,

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;
+    },
+  };
+};