@listen-fire/anthropic 0.12.0-rc.6 → 0.12.0-rc.8

package/dist/client.js

@@ -10,7 +10,6 @@ const node_async_hooks_1 = require("node:async_hooks");
 const node_crypto_1 = require("node:crypto");
 const exponential_backoff_1 = require("exponential-backoff");
 const behaviour_json_1 = __importDefault(require("./behaviour.json"));
-const retry_after_1 = require("./retry_after");
 const structured_1 = require("./structured");
 const web_tools_1 = require("./web_tools");
 const limiter_1 = require("@listen-fire/engine/public/limiter");
@@ -18,47 +17,63 @@ const log_1 = require("@listen-fire/engine/public/log");
 const models_1 = require("@listen-fire/engine/public/models");
 const types_1 = require("@listen-fire/engine/public/types");
 const SECOND = 1000;
+/** Who every model request is made as: where the vendor's rate limit lands
+ *  (its throttle key) and what `@lf/anthropic`'s declared limit counts. */
+const MODELS_CALLER = { module: '@lf/anthropic', team: '' };
 /** Requests in flight at once: `@lf/anthropic`'s own declared limit, kept by
  *  the limiter slot (services/limiter), as lf's Rust client keeps it. A
- *  request holds its place through its retries. */
-const MODELS_REQUEST = (0, limiter_1.limitRequest)({ module: '@lf/anthropic', team: '' }, [
+ *  request holds its place through its retries, but not through a vendor's
+ *  rate limit: that is a throttle on the caller, waited out in the queue. */
+const MODELS_REQUEST = (0, limiter_1.limitRequest)(MODELS_CALLER, [
     { scope: 'module', concurrent: behaviour_json_1.default.concurrentRequests },
 ]);
 // behaviour.json, which the Rust lf's client is held to as well.
 const RETRY_LIMIT = behaviour_json_1.default.retry.attempts;
 const INITIAL_DELAY = behaviour_json_1.default.retry.initialDelayMs;
 const TIME_MULTIPLE = behaviour_json_1.default.retry.multiple;
-const RATE_LIMIT_DELAY = behaviour_json_1.default.retry.rateLimitWaitMs;
+const RATE_LIMIT_WAIT = behaviour_json_1.default.retry.rateLimitWaitMs;
+function rateLimited(e) {
+    return e instanceof Error && e.message.includes('429');
+}
 async function enqueueQuery(fn, signal) {
     // Every request — each turn of a tool loop, each continuation — first asks
     // whether its run has spent its cost cap. Here, in the caller's own async
     // context: the queued job may be started from another job's.
     (0, models_1.assertRunBudget)();
-    return (0, limiter_1.limited)((0, limiter_1.limiterSlot)(), MODELS_REQUEST, async () => {
-        return (0, exponential_backoff_1.backOff)(fn, {
-            jitter: 'none',
-            numOfAttempts: RETRY_LIMIT,
-            startingDelay: INITIAL_DELAY,
-            timeMultiple: TIME_MULTIPLE,
-            retry: async (e, attempt) => {
-                if (signal?.aborted)
-                    return false;
-                if (e instanceof Error && e.message.includes('429')) {
-                    const asked = (0, retry_after_1.rateLimitDelayMs)(e);
-                    const wait = asked ?? RATE_LIMIT_DELAY;
-                    log_1.logger.info(`Hit model vendor rate limit, waiting ${wait / SECOND}s (${asked === undefined ? 'default' : 'from retry-after'})`);
-                    await new Promise((resolve) => setTimeout(resolve, wait));
-                }
-                else if (e instanceof Error && e.message.includes('401')) {
-                    return false;
-                }
-                if (attempt < RETRY_LIMIT) {
-                    log_1.logger.info(`Retrying Anthropic query in ${(INITIAL_DELAY / SECOND) * TIME_MULTIPLE ** (attempt - 1)}s`, { error: e });
-                }
-                return true;
-            },
-        });
-    });
+    for (let rateLimits = 1;; rateLimits++) {
+        try {
+            return await (0, limiter_1.limited)((0, limiter_1.limiterSlot)(), MODELS_REQUEST, async () => {
+                return (0, exponential_backoff_1.backOff)(fn, {
+                    jitter: 'none',
+                    numOfAttempts: RETRY_LIMIT,
+                    startingDelay: INITIAL_DELAY,
+                    timeMultiple: TIME_MULTIPLE,
+                    retry: async (e, attempt) => {
+                        if (signal?.aborted)
+                            return false;
+                        // Out of the permit: the throttle below holds every request
+                        // made as this caller, not just this one.
+                        if (rateLimited(e))
+                            return false;
+                        if (e instanceof Error && e.message.includes('401'))
+                            return false;
+                        if (attempt < RETRY_LIMIT) {
+                            log_1.logger.info(`Retrying Anthropic query in ${(INITIAL_DELAY / SECOND) * TIME_MULTIPLE ** (attempt - 1)}s`, { error: e });
+                        }
+                        return true;
+                    },
+                });
+            });
+        }
+        catch (e) {
+            if (!rateLimited(e) || signal?.aborted || rateLimits >= RETRY_LIMIT)
+                throw e;
+            const asked = (0, limiter_1.vendorWaitMs)(e);
+            const wait = asked ?? RATE_LIMIT_WAIT;
+            log_1.logger.info(`Hit model vendor rate limit, throttling model requests for ${wait / SECOND}s (${asked === undefined ? 'default' : 'from retry-after'})`);
+            await (0, limiter_1.throttleAfter)((0, limiter_1.limiterSlot)(), MODELS_CALLER, wait);
+        }
+    }
 }
 function emptyTally() {
     return {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@listen-fire/anthropic",
   "license": "Apache-2.0",
-  "version": "0.12.0-rc.6",
+  "version": "0.12.0-rc.8",
   "description": "The models slot's module for Claude (`@lf/anthropic`): the client every model call goes through (chat, structured output, the tool loop, web chat with Anthropic's hosted search and fetch), the chat seam a provider stands behind, Anthropic's API on a key the caller holds, the price table every call is billed from (prices.json, which the Rust lf embeds too), and the extraction and `AI()` clients the engine's models slot is filled with.",
   "engines": {
     "node": "22.20.0"
@@ -14,7 +14,7 @@
     "exponential-backoff": "3.1.1",
     "jsonrepair": "3.8.0",
     "zod": "4.1.12",
-    "@listen-fire/engine": "^0.12.0-rc.6"
+    "@listen-fire/engine": "^0.12.0-rc.8"
   },
   "devDependencies": {
     "@types/jest": "29.5.14",

package/dist/retry_after.d.ts

@@ -1,6 +0,0 @@
-/**
- * How long the vendor asked a rate-limited caller to wait, or undefined when
- * it did not say. Clamped to [1s, 120s] so a hostile or absurd value can
- * neither spin nor stall a queue slot.
- */
-export declare function rateLimitDelayMs(e: unknown, now?: number): number | undefined;

package/dist/retry_after.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rateLimitDelayMs = rateLimitDelayMs;
-const SECOND = 1000;
-const MIN_DELAY = 1 * SECOND;
-const MAX_DELAY = 120 * SECOND;
-function clamp(ms) {
-    return Math.min(MAX_DELAY, Math.max(MIN_DELAY, Math.round(ms)));
-}
-/** `Retry-After` is either whole seconds or an HTTP date. */
-function fromHeaderValue(value, now) {
-    const trimmed = value.trim();
-    if (/^\d+(\.\d+)?$/.test(trimmed))
-        return Number(trimmed) * SECOND;
-    const date = Date.parse(trimmed);
-    return Number.isNaN(date) ? undefined : date - now;
-}
-function readHeader(headers, name) {
-    if (!headers || typeof headers !== 'object')
-        return undefined;
-    if ('get' in headers && typeof headers.get === 'function') {
-        const value = headers.get(name);
-        return typeof value === 'string' ? value : undefined;
-    }
-    for (const [key, value] of Object.entries(headers)) {
-        if (key.toLowerCase() === name && typeof value === 'string')
-            return value;
-    }
-    return undefined;
-}
-/**
- * Google's `google.rpc.RetryInfo` detail: `"retryDelay": "17s"` (or
- * `"17.5s"`) on the wire, `{ seconds: 17 }` in a decoded form. The genai SDK's
- * `ApiError` carries the JSON body only as text in its message.
- */
-function fromRetryInfo(text) {
-    const quoted = /"retryDelay"\s*:\s*"(\d+(?:\.\d+)?)s"/.exec(text);
-    if (quoted)
-        return Number(quoted[1]) * SECOND;
-    const object = /"retryDelay"\s*:\s*\{\s*"seconds"\s*:\s*"?(\d+)"?/.exec(text);
-    return object ? Number(object[1]) * SECOND : undefined;
-}
-/**
- * How long the vendor asked a rate-limited caller to wait, or undefined when
- * it did not say. Clamped to [1s, 120s] so a hostile or absurd value can
- * neither spin nor stall a queue slot.
- */
-function rateLimitDelayMs(e, now = Date.now()) {
-    const headers = typeof e === 'object' && e !== null && 'headers' in e ? e.headers : undefined;
-    const header = readHeader(headers, 'retry-after');
-    const fromHeader = header === undefined ? undefined : fromHeaderValue(header, now);
-    if (fromHeader !== undefined)
-        return clamp(fromHeader);
-    const text = e instanceof Error ? e.message : undefined;
-    const fromBody = text === undefined ? undefined : fromRetryInfo(text);
-    return fromBody === undefined ? undefined : clamp(fromBody);
-}