@columenlabs/lumen-ai 0.1.268 → 0.1.270

package/dist/agent/agent.js

@@ -633,6 +633,7 @@ export class LumenAgent extends Think {
         let meter = new UsageMeter(plan.model, `${plan.label} · compact`, !!plan.key.plan);
         this.#owed.push(meter);
         const r = await generateText({
+            maxRetries: 0,
             model: this.#model(plan, () => {
                 const fb = plan.fallback;
                 if (!fb)

package/dist/agent/backoff.d.ts

@@ -0,0 +1,4 @@
+/** The wait a refused answer asks for, in ms, or undefined when it names none. */
+export declare function retryAfterMs(h: Headers): number | undefined;
+/** `base` with the retry policy above. */
+export declare function backoffFetch(base?: typeof fetch): typeof fetch;

package/dist/agent/backoff.js

@@ -0,0 +1,63 @@
+/**
+ * One retry policy for every model provider call. A call refused for load or a limit (408, 409,
+ * 429, 5xx, 529) is sent again after the wait the provider asks for (`retry-after-ms`,
+ * `retry-after` in seconds or as a date), else an exponential wait with jitter (1, 2, 4, 8 s).
+ * It stops at 4 retries or 30 s of waiting in all, at once on the caller's abort, and never retries a
+ * body it cannot send twice (a stream). Its last answer goes back as it came, so the caller still
+ * sees the provider's status and message. The SDKs' own retries are off where this runs, so a call
+ * is never retried twice over.
+ */
+const RETRY = new Set([408, 409, 429, 500, 502, 503, 504, 529]);
+const TRIES = 4;
+const BUDGET_MS = 30_000;
+const BASE_MS = 1_000;
+/** The wait a refused answer asks for, in ms, or undefined when it names none. */
+export function retryAfterMs(h) {
+    const ms = Number(h.get('retry-after-ms'));
+    if (Number.isFinite(ms) && ms > 0)
+        return ms;
+    const v = h.get('retry-after');
+    if (!v)
+        return undefined;
+    const s = Number(v);
+    if (Number.isFinite(s))
+        return s >= 0 ? s * 1000 : undefined;
+    const at = Date.parse(v);
+    return Number.isFinite(at) ? Math.max(0, at - Date.now()) : undefined;
+}
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted)
+        return reject(signal.reason);
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener('abort', () => {
+        clearTimeout(t);
+        reject(signal.reason);
+    }, { once: true });
+});
+/** `base` with the retry policy above. */
+export function backoffFetch(base = fetch) {
+    return async (input, init) => {
+        const body = init?.body;
+        const resendable = body == null ||
+            typeof body === 'string' ||
+            body instanceof ArrayBuffer ||
+            ArrayBuffer.isView(body) ||
+            body instanceof URLSearchParams ||
+            body instanceof Blob;
+        if (!resendable || input instanceof Request)
+            return base(input, init);
+        let waited = 0;
+        for (let n = 0;; n += 1) {
+            const res = await base(input, init);
+            if (!RETRY.has(res.status) || n >= TRIES)
+                return res;
+            const asked = retryAfterMs(res.headers);
+            const wait = asked ?? BASE_MS * 2 ** n * (0.75 + Math.random() * 0.5);
+            if (waited + wait > BUDGET_MS)
+                return res;
+            await res.body?.cancel().catch(() => undefined);
+            await sleep(wait, init?.signal);
+            waited += wait;
+        }
+    };
+}

package/dist/agent/models.js

@@ -7,6 +7,7 @@ import { createAnthropic } from '@ai-sdk/anthropic';
 import { createOpenAI } from '@ai-sdk/openai';
 import { Stream } from 'openai/core/streaming';
 import { XAI_BASE_URL } from '../assistant/models.js';
+import { backoffFetch } from './backoff.js';
 /**
  * A ChatGPT plan sign-in takes function tools only inside one namespace and no output cap, and a
  * forced call is the one tool offered with any call required (developers.openai.com/siwc, Preview
@@ -133,16 +134,13 @@ function textOf(content) {
 }
 /** The AI SDK model a tier runs: its provider's client on the payer's key. */
 export function aiModel(model, key, o = {}) {
+    // Every provider call backs off the same way on a limit or overload (backoff.ts).
+    const f = backoffFetch(o.fetch ?? fetch);
     if (model.provider === 'anthropic')
-        return createAnthropic({ apiKey: key.apiKey, ...(o.fetch ? { fetch: o.fetch } : {}) })(model.id);
+        return createAnthropic({ apiKey: key.apiKey, fetch: f })(model.id);
     if (model.provider === 'xai')
-        return createOpenAI({
-            apiKey: key.apiKey,
-            baseURL: XAI_BASE_URL,
-            ...(o.fetch ? { fetch: o.fetch } : {}),
-        }).responses(model.id);
-    const f = key.plan ? planFetch(o.fetch, o.name) : o.fetch;
-    return createOpenAI({ apiKey: key.apiKey, ...(f ? { fetch: f } : {}) }).responses(model.id);
+        return createOpenAI({ apiKey: key.apiKey, baseURL: XAI_BASE_URL, fetch: f }).responses(model.id);
+    return createOpenAI({ apiKey: key.apiKey, fetch: key.plan ? planFetch(f, o.name) : f }).responses(model.id);
 }
 /**
  * Claude's prompt cache. The request's own breakpoint follows the newest block, so a turn's later

package/dist/assistant/engine.js

@@ -11,6 +11,7 @@ import Anthropic from '@anthropic-ai/sdk';
 import { HAND_OFF_WHYS } from '@columenlabs/lumen-ui-types/assistant';
 import { generateText, jsonSchema, stepCountIs, tool } from 'ai';
 import OpenAI, { toFile } from 'openai';
+import { backoffFetch } from '../agent/backoff.js';
 import { aiModel, turnSettings } from '../agent/models.js';
 import { webLookupTools } from '../subagents/web.js';
 import { bearings } from './bearings.js';
@@ -96,8 +97,50 @@ function shownError(err) {
             return { message: `${who} is overloaded. Try again shortly.`, code: 'overloaded' };
         return { message: `${who} refused the request (${status ?? 'error'}).`, code: 'model_error' };
     }
+    // The AI SDK's errors (APICallError, and RetryError around its last one) carry the HTTP status as
+    // statusCode: say what that status means, never the body; the body goes to the log only.
+    const call = sdkCall(err);
+    if (call) {
+        console.error(JSON.stringify({
+            event: 'assistant_upstream_error',
+            provider: 'ai-sdk',
+            status: call.status ?? null,
+            message: call.message.slice(0, 500),
+        }));
+        if (call.status === 401 || call.status === 403)
+            return { message: `The model key was refused (${call.status}).`, code: 'key_refused' };
+        if (call.status === 429)
+            return {
+                message: 'The model is busy or hit a rate limit (429). Try again shortly.',
+                code: 'rate_limited',
+            };
+        if ((call.status ?? 0) >= 500)
+            return {
+                message: `The model is overloaded (${call.status}). Try again shortly.`,
+                code: 'overloaded',
+            };
+        return {
+            message: `The model refused the request (${call.status ?? 'error'}).`,
+            code: 'model_error',
+        };
+    }
     return { message: 'Something went wrong while answering.', code: 'internal' };
 }
+/** An AI SDK call error's status and message, through RetryError's lastError and `cause`. */
+function sdkCall(err, depth = 0) {
+    if (!err || typeof err !== 'object' || depth > 3)
+        return null;
+    const e = err;
+    const name = typeof e.name === 'string' ? e.name : '';
+    if (name === 'AI_RetryError' || name === 'RetryError')
+        return sdkCall(e.lastError, depth + 1);
+    if (name === 'AI_APICallError' || name === 'APICallError' || typeof e.statusCode === 'number')
+        return {
+            ...(typeof e.statusCode === 'number' && { status: e.statusCode }),
+            message: typeof e.message === 'string' ? e.message : '',
+        };
+    return e.cause ? sdkCall(e.cause, depth + 1) : null;
+}
 /**
  * A plain sentence for an error OpenAI sends inside the answer's stream (an `error` event, or a
  * failed response): what happened and what to do, by its code, with OpenAI's code in brackets so
@@ -198,26 +241,26 @@ export class Assistant {
         Object.defineProperty(view, 'state', { value: this.state.withDocs(this.state.docs.cached()) });
         return view;
     }
+    // The SDKs' own retries are off: every call backs off once, the same way (agent/backoff.ts).
     anthropic(apiKey) {
-        const f = this.o.fetch;
-        return new Anthropic({ apiKey, maxRetries: 1, ...(f ? { fetch: f } : {}) });
+        return new Anthropic({ apiKey, maxRetries: 0, fetch: backoffFetch(this.o.fetch ?? fetch) });
     }
-    openai(apiKey, plan = false) {
-        const f = this.o.fetch;
-        // A plan sign-in's calls are not retried: a usage limit is final for now.
-        return new OpenAI({ apiKey, maxRetries: plan ? 0 : 1, ...(f ? { fetch: f } : {}) });
+    openai(apiKey) {
+        return new OpenAI({ apiKey, maxRetries: 0, fetch: backoffFetch(this.o.fetch ?? fetch) });
     }
     xai(apiKey) {
-        const f = this.o.fetch;
-        return new OpenAI({ apiKey, baseURL: XAI_BASE_URL, maxRetries: 1, ...(f ? { fetch: f } : {}) });
+        return new OpenAI({
+            apiKey,
+            baseURL: XAI_BASE_URL,
+            maxRetries: 0,
+            fetch: backoffFetch(this.o.fetch ?? fetch),
+        });
     }
     clients(paying) {
         const { keys, plans } = paying;
         return {
             ...(keys.anthropic ? { anthropic: this.anthropic(keys.anthropic) } : {}),
-            ...(keys.openai
-                ? { openai: this.openai(keys.openai, !!plans.openai), openaiPlan: !!plans.openai }
-                : {}),
+            ...(keys.openai ? { openai: this.openai(keys.openai), openaiPlan: !!plans.openai } : {}),
             ...(keys.xai ? { xai: this.xai(keys.xai) } : {}),
         };
     }
@@ -554,6 +597,7 @@ export class Assistant {
                 const t0 = Date.now();
                 try {
                     const r = await generateText({
+                        maxRetries: 0,
                         model: aiModel(sub.model, key, {
                             ...(this.o.fetch ? { fetch: this.o.fetch } : {}),
                             name: this.name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@columenlabs/lumen-ai",
-  "version": "0.1.268",
+  "version": "0.1.270",
   "description": "Lumen's assistant and agent parts: a chat assistant's server (Claude tiers, tools over MCP, the web, hand off, spend caps), serving an MCP server from a Worker, read-only tool sets and metered tool calls.",
   "license": "MIT",
   "type": "module",
@@ -56,8 +56,8 @@
     "@ai-sdk/openai": "4.0.108",
     "@anthropic-ai/sdk": "0.133.0",
     "@cloudflare/think": "0.23.0",
-    "@columenlabs/lumen-ops": "0.1.268",
-    "@columenlabs/lumen-ui-types": "0.1.268",
+    "@columenlabs/lumen-ops": "0.1.270",
+    "@columenlabs/lumen-ui-types": "0.1.270",
     "agents": "0.32.0",
     "ai": "7.0.162",
     "just-bash": "3.6.0",