@zenera/neo 1.1.9 → 1.1.10

package/dist/embeddings/openrouter.js

@@ -1,4 +1,5 @@
 import { embeddingResponse } from "../embedding.js";
+import { RETRY_STATUS_CODES } from "../models/openrouter.js";
 import { zeroUsage } from "../types.js";
 // ---------------------------------------------------------------------------
 // OpenRouter embeddings adapter
@@ -31,7 +32,7 @@ export class OpenRouterEmbedder {
             // branch of `embedding` below is what catches a gateway that
             // decides otherwise.
         };
-        const res = await this.#client.embeddings.generate({ requestBody }, { fetchOptions: { signal: req.signal } });
+        const res = await this.#client.embeddings.generate({ requestBody }, { fetchOptions: { signal: req.signal }, retryCodes: RETRY_STATUS_CODES });
         // The response is declared as the body *or* a bare string, so the
         // parsed shape has to be established before anything is read off it.
         if (typeof res === 'string') {

package/dist/models/factory.js

@@ -342,6 +342,48 @@ export class ModelRegistry {
         return declared ?? (isProviderKind(name) ? name : 'openai');
     }
 }
+// ---------------------------------------------------------------------------
+// Retries
+// ---------------------------------------------------------------------------
+/**
+ * One backoff policy for every vendor, because a 429 is not a failure of the
+ * run — it is the provider asking to be called again later, and an agent that
+ * gives up on the first one loses the whole trajectory to a wait of a few
+ * seconds. Every SDK here can retry, but none of them agree on what happens
+ * when nothing is configured: the OpenAI and Anthropic clients retry twice,
+ * `@google/genai` does not retry *at all* unless `retryOptions` is present, and
+ * OpenRouter's generated client retries `5XX` only — so a Vertex or OpenRouter
+ * 429 was fatal by default. These constants are what make the four behave the
+ * same; `ProviderSpec.maxRetries` (0 disables) is the per-provider override.
+ *
+ * Retries live at the transport, not around `Model.generate`, so a retried call
+ * is one that never started: no partial stream is replayed, and a `Retry-After`
+ * header is honoured by the SDK that read it.
+ */
+const DEFAULT_MAX_RETRIES = 4;
+/** wait after the first failure; doubles per attempt up to `RETRY_MAX_MS` */
+const RETRY_INITIAL_MS = 1_000;
+const RETRY_MAX_MS = 60_000;
+const RETRY_EXPONENT = 2;
+function retriesOf(opts) {
+    return Math.max(0, opts.maxRetries ?? DEFAULT_MAX_RETRIES);
+}
+/**
+ * The same schedule expressed as a wall-clock budget, which is the only shape
+ * OpenRouter's client accepts. It is the sum of the waits a count of `retries`
+ * would spend, so the two agree on how long a hopeless call may take — not on
+ * exactly how many times it is made, since this budget also has to cover the
+ * requests themselves.
+ */
+function retryWindowMs(retries) {
+    let wait = RETRY_INITIAL_MS;
+    let total = 0;
+    for (let i = 0; i < retries; i++) {
+        total += Math.min(wait, RETRY_MAX_MS);
+        wait *= RETRY_EXPONENT;
+    }
+    return total;
+}
 /**
  * Credential resolution, in one place so a `${VAR}` reference behaves the same
  * whether it came from yaml or from application code. `creds` may be a model
@@ -375,7 +417,7 @@ function buildClient(name, kind, creds, opts) {
         baseURL,
         defaultHeaders: headers,
         timeout: opts.timeoutMs,
-        maxRetries: opts.maxRetries,
+        maxRetries: retriesOf(opts),
         ...(opts.token ? { fetch: bearerFetch(opts.token) } : {}),
     };
     if (defaults.protocol === 'anthropic') {
@@ -408,13 +450,25 @@ function buildOpenRouter(kind, apiKey, baseURL, headers, opts) {
         });
     }
     const { token } = opts;
+    const retries = retriesOf(opts);
     return new OpenRouter({
         apiKey: token ? async () => token() : apiKey,
         serverURL: baseURL,
         timeoutMs: opts.timeoutMs,
         // A count of zero is the one value that has to change shape: this SDK
         // says "do not retry" with a strategy, not with a number.
-        retryConfig: opts.maxRetries === 0 ? { strategy: 'none' } : undefined,
+        retryConfig: retries === 0
+            ? { strategy: 'none' }
+            : {
+                strategy: 'backoff',
+                backoff: {
+                    initialInterval: RETRY_INITIAL_MS,
+                    maxInterval: RETRY_MAX_MS,
+                    exponent: RETRY_EXPONENT,
+                    maxElapsedTime: retryWindowMs(retries),
+                },
+                retryConnectionErrors: true,
+            },
         httpClient,
     });
 }
@@ -438,7 +492,15 @@ function buildOpenRouter(kind, apiKey, baseURL, headers, opts) {
  */
 function buildGenAI(kind, apiKey, baseURL, headers, opts, where) {
     const { GoogleGenAI } = sdk('@google/genai', kind);
-    const httpOptions = { baseUrl: baseURL, headers, timeout: opts.timeoutMs };
+    // `attempts` counts the initial call, so a retry budget of zero is one
+    // attempt. Delays are fractions of a second here, unlike everywhere else.
+    const retryOptions = {
+        attempts: retriesOf(opts) + 1,
+        initialDelay: RETRY_INITIAL_MS / 1000,
+        maxDelay: RETRY_MAX_MS / 1000,
+        expBase: RETRY_EXPONENT,
+    };
+    const httpOptions = { baseUrl: baseURL, headers, timeout: opts.timeoutMs, retryOptions };
     if (kind !== 'vertex') {
         return new GoogleGenAI({ apiKey, httpOptions });
     }

package/dist/models/openrouter.d.ts

@@ -2,6 +2,16 @@ import type { OpenRouter } from '@openrouter/sdk';
 import type { ChatRequestPlugin, ProviderPreferences } from '@openrouter/sdk/models';
 import type { StreamDelta } from '../events.ts';
 import type { Model, ModelRequest, ModelResponse } from '../model.ts';
+/**
+ * Which failures the SDK's backoff applies to: rate limits, request timeouts,
+ * and the upstream's own errors. Families are written `5XX` in this matcher.
+ *
+ * It has to be passed per call. The generated client resolves `retryCodes` at
+ * the *operation*, defaulting it to `5XX` alone, and no client-wide option
+ * reaches it — so configuring a retry policy and leaving this out gives a
+ * client that backs off diligently on 500s and dies on the first 429.
+ */
+export declare const RETRY_STATUS_CODES: string[];
 /**
  * Effort levels, spelled out rather than imported: the SDK's is an *open* enum
  * (its literals plus any string), which would let a typo through, and naming

package/dist/models/openrouter.js

@@ -1,5 +1,31 @@
 var _a;
 import { zeroUsage } from "../types.js";
+// ---------------------------------------------------------------------------
+// OpenRouter adapter
+//
+// Not the chat-completions adapter pointed at another base url. OpenRouter's
+// own SDK is a different wire contract in TypeScript terms — camelCase fields
+// remapped to snake_case on the way out, a response union that covers both
+// streaming and not, assistant content that may arrive as an array — so it
+// gets its own adapter rather than a widened `OpenAIModel`.
+//
+// What that buys is the part of OpenRouter the OpenAI client cannot express:
+// provider routing, a model fallback chain, and per-call cost. What it costs
+// is that responses are zod-parsed on the way in, so a provider returning a
+// shape the schema does not know raises `ResponseValidationError` where the
+// OpenAI client would have shrugged. `kind: openai-compatible` against the
+// same base url remains the way back if that ever bites.
+// ---------------------------------------------------------------------------
+/**
+ * Which failures the SDK's backoff applies to: rate limits, request timeouts,
+ * and the upstream's own errors. Families are written `5XX` in this matcher.
+ *
+ * It has to be passed per call. The generated client resolves `retryCodes` at
+ * the *operation*, defaulting it to `5XX` alone, and no client-wide option
+ * reaches it — so configuring a retry policy and leaving this out gives a
+ * client that backs off diligently on 500s and dies on the first 429.
+ */
+export const RETRY_STATUS_CODES = ['408', '429', '5XX'];
 function toStopReason(finish) {
     switch (finish) {
         case 'tool_calls':
@@ -154,7 +180,7 @@ export class OpenRouterModel {
      * SDK keeps transport concerns out of the body it validates.
      */
     #send(req, stream) {
-        return this.#client.chat.send({ chatRequest: this.#request(req, stream) }, { fetchOptions: { signal: req.signal } });
+        return this.#client.chat.send({ chatRequest: this.#request(req, stream) }, { fetchOptions: { signal: req.signal }, retryCodes: RETRY_STATUS_CODES });
     }
     #request(req, stream) {
         const o = this.#options;

package/dist/project/config.d.ts

@@ -47,10 +47,10 @@ declare const modelSpec: z.ZodObject<{
     thinkingBudgetTokens: z.ZodOptional<z.ZodInt>;
     thinkingBudget: z.ZodOptional<z.ZodInt>;
     thinkingLevel: z.ZodOptional<z.ZodEnum<{
+        minimal: "minimal";
         low: "low";
         medium: "medium";
         high: "high";
-        minimal: "minimal";
     }>>;
     includeThoughts: z.ZodOptional<z.ZodBoolean>;
     routing: z.ZodOptional<z.ZodObject<{
@@ -185,10 +185,10 @@ export declare const projectSchema: z.ZodObject<{
         thinkingBudgetTokens: z.ZodOptional<z.ZodInt>;
         thinkingBudget: z.ZodOptional<z.ZodInt>;
         thinkingLevel: z.ZodOptional<z.ZodEnum<{
+            minimal: "minimal";
             low: "low";
             medium: "medium";
             high: "high";
-            minimal: "minimal";
         }>>;
         includeThoughts: z.ZodOptional<z.ZodBoolean>;
         routing: z.ZodOptional<z.ZodObject<{

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zenera/neo",
-    "version": "1.1.9",
+    "version": "1.1.10",
     "description": "A multi-agent runtime for Node.js: agents, models, tools, skills, memory and an append-only trajectory.",
     "keywords": [
         "agents",