@juspay/neurolink 10.12.7 → 10.12.9

package/dist/cli/commands/proxyAnalyze.js

@@ -28,6 +28,9 @@ function printAnalysis(report) {
     }
     if (report.coverage.attempts) {
         logger.always(`    Attempts: ${report.attempts.total}, ${report.attempts.errors} errors${report.attempts.errors > 0 ? ` ${JSON.stringify(report.attempts.errorTypes)}` : ""}`);
+        if (Object.keys(report.attempts.transportScopes).length > 0) {
+            logger.always(`    Transport scopes: ${JSON.stringify(report.attempts.transportScopes)}`);
+        }
     }
     logger.always(report.coverage.lifecycle
         ? `    Lifecycle: ${report.lifecycle.accepted} accepted, ${report.lifecycle.terminal} terminal, ${report.lifecycle.unsettled} unsettled`
@@ -49,6 +52,10 @@ function printAnalysis(report) {
     if (report.coverage.routingDecisions) {
         logger.always(`    Decisions: ${report.routing.totalRecords} (${report.routing.records.length} retained), modes: ${JSON.stringify(report.routing.modes)}`);
         logger.always(`    Selection reasons: ${JSON.stringify(report.routing.selectionReasons)}`);
+        const productionQuotaProbes = report.routing.selectionReasons.quota_probe ?? 0;
+        if (productionQuotaProbes > 0) {
+            logger.always(chalk.yellow(`    WARNING: ${productionQuotaProbes} production request(s) were selected for quota discovery`));
+        }
         logger.always(`    Initial accounts: ${JSON.stringify(report.routing.initialAccounts)}`);
         logger.always(`    Final account changed after retry: ${report.routing.finalAccountChanges}, outside candidate set: ${report.routing.finalOutsideCandidateSet}`);
     }

package/dist/core/modules/GenerationHandler.js

@@ -25,7 +25,7 @@ import { calculateCacheSavingsPercent, extractCacheCreationTokens, extractCacheR
 import { DEFAULT_MAX_STEPS, DEFAULT_WRAPUP_TIME_LEAD_MS, } from "../constants.js";
 import { createStepBudgetGuard, estimateFixedOverheadTokens, } from "../../context/stepBudgetGuard.js";
 import { isTemperatureDeprecatedError, isSchemaComplexityError, isToolsSchemaConflictError, isToolsSchemaExclusionInForce, } from "./structuredOutputPolicy.js";
-import { coerceJsonToSchema } from "../../utils/json/coerce.js";
+import { coerceJsonToSchema, recoverScalarRoot, schemaAccepts, } from "../../utils/json/coerce.js";
 import { convertZodToJsonSchema } from "../../utils/schemaConversion.js";
 import { NoObjectGeneratedError } from "../../utils/generationErrors.js";
 import { Output, stepCountIs } from "../../utils/tool.js";
@@ -800,26 +800,35 @@ export class GenerationHandler {
                 }
                 return coerced.content;
             }
-            try {
-                const scalar = JSON.parse(strippedText);
-                if (scalar === "") {
+            const scalar = recoverScalarRoot(strippedText, options.schema);
+            switch (scalar.kind) {
+                case "empty":
                     // A JSON-encoded empty string is an EMPTY completion, not a
                     // recovered scalar — normalize to a true empty ('' content, no
                     // structuredData) so callers' empty-response handling fires
                     // instead of a literal '""' reaching the user.
                     logger.warn("[GenerationHandler] schema requested but the model returned an empty JSON string; normalizing to empty content", { provider: this.providerName, model: this.modelName });
                     return "";
-                }
-                if (scalar !== null && scalar !== undefined) {
-                    structuredData = scalar;
+                case "accepted":
+                    // A JSON scalar root is only real structured data when the caller's
+                    // schema actually accepts it. Under an OBJECT schema a recovered
+                    // string/number is the raw completion in disguise (the shape a
+                    // truncated response degrades to) — publishing it would hand the
+                    // caller a `structuredData` that violates the schema they passed.
+                    structuredData = scalar.value;
+                    return strippedText;
+                case "rejected":
+                    logger.warn("[GenerationHandler] recovered a JSON scalar the requested schema rejects; leaving structuredData unset", {
+                        provider: this.providerName,
+                        model: this.modelName,
+                        scalarType: typeof scalar.value,
+                    });
+                    return strippedText;
+                case "nullish":
+                case "not-json":
+                    logger.warn("[GenerationHandler] schema requested but no JSON could be recovered from model text; returning raw text", { provider: this.providerName, model: this.modelName });
                     return strippedText;
-                }
-            }
-            catch {
-                // not JSON at all — fall through to raw text + WARN
             }
-            logger.warn("[GenerationHandler] schema requested but no JSON could be recovered from model text; returning raw text", { provider: this.providerName, model: this.modelName });
-            return strippedText;
         };
         if (useStructuredOutput) {
             try {
@@ -834,7 +843,20 @@ export class GenerationHandler {
                 // (a string identical to the step text) and coerce it instead.
                 const rawTextEcho = typeof experimentalOutput === "string" &&
                     experimentalOutput === (generateResult.text ?? "");
-                if (experimentalOutput !== undefined && !rawTextEcho) {
+                // The equality check above only catches an EXACT echo. On a multi-step
+                // or truncated turn the echo can differ from `text` (a different step's
+                // text, a fence, trailing whitespace), and a raw string would then be
+                // published as `structuredData` under an object schema — the "returned
+                // a string instead of the schema object" failure. A string is trusted
+                // as structured output ONLY when the caller's schema accepts it
+                // (string-root schemas keep working); otherwise it is coerced like any
+                // other raw model text.
+                const untrustedStringOutput = typeof experimentalOutput === "string" &&
+                    !!options.schema &&
+                    !schemaAccepts(options.schema, experimentalOutput);
+                if (experimentalOutput !== undefined &&
+                    !rawTextEcho &&
+                    !untrustedStringOutput) {
                     // AI-SDK already parsed + schema-validated the object. Expose it
                     // directly and serialise canonically — no hand-parsing needed.
                     structuredData = experimentalOutput;

package/dist/lib/core/modules/GenerationHandler.js

@@ -25,7 +25,7 @@ import { calculateCacheSavingsPercent, extractCacheCreationTokens, extractCacheR
 import { DEFAULT_MAX_STEPS, DEFAULT_WRAPUP_TIME_LEAD_MS, } from "../constants.js";
 import { createStepBudgetGuard, estimateFixedOverheadTokens, } from "../../context/stepBudgetGuard.js";
 import { isTemperatureDeprecatedError, isSchemaComplexityError, isToolsSchemaConflictError, isToolsSchemaExclusionInForce, } from "./structuredOutputPolicy.js";
-import { coerceJsonToSchema } from "../../utils/json/coerce.js";
+import { coerceJsonToSchema, recoverScalarRoot, schemaAccepts, } from "../../utils/json/coerce.js";
 import { convertZodToJsonSchema } from "../../utils/schemaConversion.js";
 import { NoObjectGeneratedError } from "../../utils/generationErrors.js";
 import { Output, stepCountIs } from "../../utils/tool.js";
@@ -800,26 +800,35 @@ export class GenerationHandler {
                 }
                 return coerced.content;
             }
-            try {
-                const scalar = JSON.parse(strippedText);
-                if (scalar === "") {
+            const scalar = recoverScalarRoot(strippedText, options.schema);
+            switch (scalar.kind) {
+                case "empty":
                     // A JSON-encoded empty string is an EMPTY completion, not a
                     // recovered scalar — normalize to a true empty ('' content, no
                     // structuredData) so callers' empty-response handling fires
                     // instead of a literal '""' reaching the user.
                     logger.warn("[GenerationHandler] schema requested but the model returned an empty JSON string; normalizing to empty content", { provider: this.providerName, model: this.modelName });
                     return "";
-                }
-                if (scalar !== null && scalar !== undefined) {
-                    structuredData = scalar;
+                case "accepted":
+                    // A JSON scalar root is only real structured data when the caller's
+                    // schema actually accepts it. Under an OBJECT schema a recovered
+                    // string/number is the raw completion in disguise (the shape a
+                    // truncated response degrades to) — publishing it would hand the
+                    // caller a `structuredData` that violates the schema they passed.
+                    structuredData = scalar.value;
+                    return strippedText;
+                case "rejected":
+                    logger.warn("[GenerationHandler] recovered a JSON scalar the requested schema rejects; leaving structuredData unset", {
+                        provider: this.providerName,
+                        model: this.modelName,
+                        scalarType: typeof scalar.value,
+                    });
+                    return strippedText;
+                case "nullish":
+                case "not-json":
+                    logger.warn("[GenerationHandler] schema requested but no JSON could be recovered from model text; returning raw text", { provider: this.providerName, model: this.modelName });
                     return strippedText;
-                }
-            }
-            catch {
-                // not JSON at all — fall through to raw text + WARN
             }
-            logger.warn("[GenerationHandler] schema requested but no JSON could be recovered from model text; returning raw text", { provider: this.providerName, model: this.modelName });
-            return strippedText;
         };
         if (useStructuredOutput) {
             try {
@@ -834,7 +843,20 @@ export class GenerationHandler {
                 // (a string identical to the step text) and coerce it instead.
                 const rawTextEcho = typeof experimentalOutput === "string" &&
                     experimentalOutput === (generateResult.text ?? "");
-                if (experimentalOutput !== undefined && !rawTextEcho) {
+                // The equality check above only catches an EXACT echo. On a multi-step
+                // or truncated turn the echo can differ from `text` (a different step's
+                // text, a fence, trailing whitespace), and a raw string would then be
+                // published as `structuredData` under an object schema — the "returned
+                // a string instead of the schema object" failure. A string is trusted
+                // as structured output ONLY when the caller's schema accepts it
+                // (string-root schemas keep working); otherwise it is coerced like any
+                // other raw model text.
+                const untrustedStringOutput = typeof experimentalOutput === "string" &&
+                    !!options.schema &&
+                    !schemaAccepts(options.schema, experimentalOutput);
+                if (experimentalOutput !== undefined &&
+                    !rawTextEcho &&
+                    !untrustedStringOutput) {
                     // AI-SDK already parsed + schema-validated the object. Expose it
                     // directly and serialise canonically — no hand-parsing needed.
                     structuredData = experimentalOutput;

package/dist/lib/neurolink.d.ts

@@ -775,6 +775,21 @@ export declare class NeuroLink {
     private applyClassifierRouting;
     private prepareGenerateAugmentations;
     private buildGenerateTextOptions;
+    /**
+     * Provider-agnostic JSON recovery for schema requests. Structured-output
+     * enforcement makes valid JSON the overwhelming case; for every other
+     * provider path — including generate() overrides (Vertex, Anthropic,
+     * Bedrock, Google AI Studio) — object/array roots are recovered here via
+     * balanced-scan + jsonrepair and scalar JSON roots via plain JSON.parse,
+     * with the parsed value exposed as `structuredData`. If nothing JSON-shaped
+     * is recoverable (pure prose), the raw text is returned, `structuredData`
+     * stays undefined, and a WARN makes the case observable.
+     *
+     * Mutates `textResult` in place, and must run BEFORE the end-of-generation
+     * emits so event consumers see the same content/structuredData the caller
+     * receives.
+     */
+    private recoverStructuredData;
     private finalizeGenerateRequestResult;
     private emitGenerateErrorEvent;
     /**

package/dist/lib/neurolink.js

@@ -74,7 +74,7 @@ import { CircuitBreaker, ERROR_CODES, ErrorFactory, isAbortError, isRetriableErr
 import { hasLifecycleErrorFired, markLifecycleErrorFired, } from "./utils/lifecycleCallbacks.js";
 import { resolveLifecycleTimeoutMs } from "./utils/lifecycleTimeout.js";
 import { cloneOptionsForCallIsolation } from "./utils/cloneOptions.js";
-import { coerceJsonToSchema } from "./utils/json/coerce.js";
+import { coerceJsonToSchema, recoverScalarRoot, schemaAccepts, } from "./utils/json/coerce.js";
 // Factory processing imports
 import { createCleanStreamOptions, enhanceTextGenerationOptions, processFactoryOptions, processStreamingFactoryOptions, validateFactoryConfig, } from "./utils/factoryProcessing.js";
 import { logger, mcpLogger } from "./utils/logger.js";
@@ -4058,52 +4058,85 @@ Current user's request: ${currentInput}`;
         }
         return textOptions;
     }
-    finalizeGenerateRequestResult(params) {
-        const { generateSpan, options, textOptions, textResult, factoryResult, originalPrompt, startTime, } = params;
-        // Provider-agnostic JSON coercion for schema requests. Structured-output
-        // enforcement makes valid JSON the overwhelming case; for every other
-        // provider path — including generate() overrides (Vertex, Anthropic,
-        // Bedrock, Google AI Studio) — object/array roots are recovered here via
-        // balanced-scan + jsonrepair and scalar JSON roots via plain JSON.parse,
-        // with the parsed value exposed as `structuredData`. If nothing
-        // JSON-shaped is recoverable (pure prose), the raw text is returned,
-        // `structuredData` stays undefined, and a WARN makes the case observable.
-        // Runs BEFORE the end-of-generation emits below so event consumers see
-        // the same coerced content/structuredData the caller receives.
-        if (textOptions.schema &&
-            textResult.structuredData === undefined &&
-            typeof textResult.content === "string") {
-            const coerced = coerceJsonToSchema(textResult.content, textOptions.schema);
-            if (coerced) {
-                textResult.content = coerced.content;
-                textResult.structuredData = coerced.structuredData;
-                if (coerced.repaired) {
-                    textResult.jsonRepaired = true;
-                }
-                if (coerced.truncated) {
-                    textResult.jsonTruncated = true;
-                }
+    /**
+     * Provider-agnostic JSON recovery for schema requests. Structured-output
+     * enforcement makes valid JSON the overwhelming case; for every other
+     * provider path — including generate() overrides (Vertex, Anthropic,
+     * Bedrock, Google AI Studio) — object/array roots are recovered here via
+     * balanced-scan + jsonrepair and scalar JSON roots via plain JSON.parse,
+     * with the parsed value exposed as `structuredData`. If nothing JSON-shaped
+     * is recoverable (pure prose), the raw text is returned, `structuredData`
+     * stays undefined, and a WARN makes the case observable.
+     *
+     * Mutates `textResult` in place, and must run BEFORE the end-of-generation
+     * emits so event consumers see the same content/structuredData the caller
+     * receives.
+     */
+    recoverStructuredData(textResult, schema) {
+        // A provider path that produced its own `structuredData` normally owns it.
+        // The one exception is a STRING the caller's schema rejects: that is the
+        // raw completion leaking through as structured output (the shape a
+        // truncated response degrades to), so re-run recovery over the text rather
+        // than handing back a value the declared schema forbids.
+        const structuredIsRejectedString = typeof textResult.structuredData === "string" &&
+            !schemaAccepts(schema, textResult.structuredData);
+        if (!schema ||
+            (textResult.structuredData !== undefined &&
+                !structuredIsRejectedString) ||
+            typeof textResult.content !== "string") {
+            return;
+        }
+        if (structuredIsRejectedString) {
+            textResult.structuredData = undefined;
+        }
+        const coerced = coerceJsonToSchema(textResult.content, schema);
+        if (coerced) {
+            textResult.content = coerced.content;
+            textResult.structuredData = coerced.structuredData;
+            if (coerced.repaired) {
+                textResult.jsonRepaired = true;
             }
-            else {
-                try {
-                    const scalar = JSON.parse(textResult.content);
-                    if (scalar === "") {
-                        // A JSON-encoded empty string is an EMPTY completion, not a
-                        // recovered scalar — normalize to a true empty so callers'
-                        // empty-response handling fires instead of a literal '""'
-                        // reaching the user. `structuredData` stays undefined.
-                        textResult.content = "";
-                        logger.warn("[NeuroLink] schema requested but the model returned an empty JSON string; normalizing to empty content", { provider: textResult.provider, model: textResult.model });
-                    }
-                    else if (scalar !== null && scalar !== undefined) {
-                        textResult.structuredData = scalar;
-                    }
-                }
-                catch {
-                    logger.warn("[NeuroLink] schema requested but no JSON could be recovered from model output; returning raw text", { provider: textResult.provider, model: textResult.model });
-                }
+            if (coerced.truncated) {
+                textResult.jsonTruncated = true;
             }
+            return;
         }
+        const scalar = recoverScalarRoot(textResult.content, schema);
+        switch (scalar.kind) {
+            case "empty":
+                // A JSON-encoded empty string is an EMPTY completion, not a recovered
+                // scalar — normalize to a true empty so callers' empty-response
+                // handling fires instead of a literal '""' reaching the user.
+                // `structuredData` stays undefined.
+                textResult.content = "";
+                logger.warn("[NeuroLink] schema requested but the model returned an empty JSON string; normalizing to empty content", { provider: textResult.provider, model: textResult.model });
+                break;
+            case "accepted":
+                // Only publish a scalar root the caller's schema actually accepts.
+                // Under an OBJECT schema a recovered string is the raw completion in
+                // disguise — the shape a truncated response degrades to — and exposing
+                // it hands the caller a `structuredData` that violates the schema they
+                // passed.
+                textResult.structuredData = scalar.value;
+                break;
+            case "rejected":
+                logger.warn("[NeuroLink] recovered a JSON scalar the requested schema rejects; leaving structuredData unset", {
+                    provider: textResult.provider,
+                    model: textResult.model,
+                    scalarType: typeof scalar.value,
+                });
+                break;
+            case "nullish":
+                // JSON null/undefined — no structured value to publish.
+                break;
+            case "not-json":
+                logger.warn("[NeuroLink] schema requested but no JSON could be recovered from model output; returning raw text", { provider: textResult.provider, model: textResult.model });
+                break;
+        }
+    }
+    finalizeGenerateRequestResult(params) {
+        const { generateSpan, options, textOptions, textResult, factoryResult, originalPrompt, startTime, } = params;
+        this.recoverStructuredData(textResult, textOptions.schema);
         // Surface truncation when a schema was requested: either the provider
         // reported finishReason="length" or the recovered JSON came from an
         // unclosed span. Either way `structuredData` may be incomplete — warn at

package/dist/lib/providers/anthropic/client.js

@@ -1206,6 +1206,9 @@ export class AnthropicProvider extends BaseProvider {
                 }
                 const content = [];
                 let finalResultText;
+                // Text emitted in forced-json mode, kept only as a fallback (see below).
+                const jsonModeText = [];
+                let jsonToolAnswered = false;
                 for (const block of response.content) {
                     if (block.type === "thinking") {
                         content.push({ type: "reasoning", text: block.thinking });
@@ -1213,13 +1216,17 @@ export class AnthropicProvider extends BaseProvider {
                     else if (block.type === "text") {
                         // In forced-json mode the payload arrives via the tool input, not
                         // text — pass text through only in normal mode.
-                        if (!jsonTool) {
+                        if (jsonTool) {
+                            jsonModeText.push(block.text);
+                        }
+                        else {
                             content.push({ type: "text", text: block.text });
                         }
                     }
                     else if (block.type === "tool_use") {
                         if (jsonTool && block.name === jsonTool) {
                             // Unwrap the synthetic tool call back into text JSON.
+                            jsonToolAnswered = true;
                             content.push({
                                 type: "text",
                                 text: stringifyToolInput(block.input),
@@ -1241,6 +1248,15 @@ export class AnthropicProvider extends BaseProvider {
                         }
                     }
                 }
+                // Forced-json mode normally drops text blocks because the payload rides
+                // in the synthetic tool's input. But when the response is cut short
+                // (stop_reason "max_tokens") the tool call can be missing entirely, and
+                // dropping the text would leave an EMPTY completion with nothing for
+                // coerceJsonToSchema to recover. Fall back to the text so a partial
+                // object can still be salvaged and flagged truncated.
+                if (jsonTool && !jsonToolAnswered && jsonModeText.length > 0) {
+                    content.push({ type: "text", text: jsonModeText.join("") });
+                }
                 // final_result is terminal — parity with the native Claude-on-Vertex
                 // and Gemini loops, which break out of the tool loop the moment it
                 // arrives. Reasoning blocks are kept; any prose preamble and any tool

package/dist/lib/proxy/accountQuotaRefreshCoordinator.d.ts

@@ -0,0 +1,19 @@
+import type { AccountUsageFetchResult, ProxyPassthroughAccount, ProxyQuotaRefreshRunResult, ProxyQuotaRefreshMetrics, ProxyQuotaRefreshRuntimeState } from "../types/index.js";
+export declare class AccountQuotaRefreshCoordinator {
+    private readonly inFlight;
+    private readonly states;
+    private metrics;
+    getState(accountKey: string): ProxyQuotaRefreshRuntimeState;
+    /**
+     * Run one refresh per account. `trigger` must identify the quota window or
+     * handoff condition so repeated requests deduplicate without hiding a later
+     * reset window.
+     */
+    run(account: ProxyPassthroughAccount, trigger: string, fetcher: (candidate: ProxyPassthroughAccount) => Promise<AccountUsageFetchResult>, options?: {
+        force?: boolean;
+        now?: number;
+    }): Promise<ProxyQuotaRefreshRunResult>;
+    clear(): void;
+    getMetrics(): ProxyQuotaRefreshMetrics;
+    private getOrCreateState;
+}

package/dist/lib/proxy/accountQuotaRefreshCoordinator.js

@@ -0,0 +1,105 @@
+const FAILURE_BACKOFF_MS = [30_000, 2 * 60_000, 10 * 60_000];
+const MAX_FAILURE_BACKOFF_MS = 30 * 60_000;
+export class AccountQuotaRefreshCoordinator {
+    inFlight = new Map();
+    states = new Map();
+    metrics = {
+        attempted: 0,
+        succeeded: 0,
+        failed: 0,
+        coalesced: 0,
+        backoffSuppressed: 0,
+        triggerDeduplicated: 0,
+    };
+    getState(accountKey) {
+        const state = this.states.get(accountKey);
+        return state
+            ? { ...state, inFlight: this.inFlight.has(accountKey) }
+            : { inFlight: false, consecutiveFailures: 0, coalesced: 0 };
+    }
+    /**
+     * Run one refresh per account. `trigger` must identify the quota window or
+     * handoff condition so repeated requests deduplicate without hiding a later
+     * reset window.
+     */
+    run(account, trigger, fetcher, options = {}) {
+        const existing = this.inFlight.get(account.key);
+        if (existing) {
+            const state = this.getOrCreateState(account.key);
+            state.coalesced += 1;
+            this.metrics.coalesced += 1;
+            return existing;
+        }
+        const now = options.now ?? Date.now();
+        const state = this.getOrCreateState(account.key);
+        if (!options.force && state.lastCompletedTrigger === trigger) {
+            this.metrics.triggerDeduplicated += 1;
+            return Promise.resolve({ kind: "not_due" });
+        }
+        if (!options.force && now < (state.nextEligibleAt ?? 0)) {
+            this.metrics.backoffSuppressed += 1;
+            return Promise.resolve({
+                kind: "backoff",
+                nextEligibleAt: state.nextEligibleAt ?? now,
+            });
+        }
+        state.lastAttemptAt = now;
+        this.metrics.attempted += 1;
+        const task = fetcher(account)
+            .catch((error) => ({
+            ok: false,
+            reason: "network",
+            error: error instanceof Error ? error.message : String(error),
+        }))
+            .then((result) => {
+            const completedAt = options.now ?? Date.now();
+            if (result.ok === false) {
+                this.metrics.failed += 1;
+                state.consecutiveFailures += 1;
+                state.lastFailureReason = result.reason;
+                const backoffBase = FAILURE_BACKOFF_MS[Math.max(0, state.consecutiveFailures - 1)] ??
+                    MAX_FAILURE_BACKOFF_MS;
+                const jitter = 0.9 + Math.random() * 0.2;
+                state.nextEligibleAt = completedAt + Math.round(backoffBase * jitter);
+            }
+            else {
+                this.metrics.succeeded += 1;
+                state.lastSuccessAt = completedAt;
+                state.nextEligibleAt = undefined;
+                state.consecutiveFailures = 0;
+                state.lastFailureReason = undefined;
+                state.lastCompletedTrigger = trigger;
+            }
+            return { kind: "completed", result, startedAt: now };
+        })
+            .finally(() => {
+            this.inFlight.delete(account.key);
+        });
+        this.inFlight.set(account.key, task);
+        return task;
+    }
+    clear() {
+        this.inFlight.clear();
+        this.states.clear();
+        this.metrics = {
+            attempted: 0,
+            succeeded: 0,
+            failed: 0,
+            coalesced: 0,
+            backoffSuppressed: 0,
+            triggerDeduplicated: 0,
+        };
+    }
+    getMetrics() {
+        return { ...this.metrics };
+    }
+    getOrCreateState(accountKey) {
+        let state = this.states.get(accountKey);
+        if (!state) {
+            state = { inFlight: false, consecutiveFailures: 0, coalesced: 0 };
+            this.states.set(accountKey, state);
+        }
+        return state;
+    }
+}
+//# sourceMappingURL=accountQuotaRefreshCoordinator.js.map

package/dist/lib/proxy/accountUsage.d.ts

@@ -1,15 +1,15 @@
 /**
  * On-Demand Account Usage Fetch
  *
- * Manual refetch path for account limits: queries Anthropic's OAuth usage
- * endpoint (the same call Claude Code's /usage makes) to get FRESH session /
- * weekly / model-scoped windows for an account without consuming any tokens
- * and without starting a 5h session window.
+ * Lightweight account-limit refresh: queries Anthropic's OAuth usage endpoint
+ * (the same call Claude Code's /usage makes) to get fresh session / weekly /
+ * model-scoped windows without consuming tokens or starting a 5h session.
  *
  * This complements — never replaces — the passive header capture in
  * accountQuota.ts: `usageToQuota` normalizes the endpoint payload into the
  * same `AccountQuota` shape so refreshed data flows through the existing
- * save/merge/cooldown chain.
+ * save/merge/cooldown chain. Manual refresh and adaptive proxy prewarming use
+ * the same transport through the route-owned single-flight coordinator.
  *
  * Only OAuth (Bearer) accounts have subscription windows; api_key accounts
  * are skipped and keep their header-derived absolute limits.

package/dist/lib/proxy/accountUsage.js

@@ -1,15 +1,15 @@
 /**
  * On-Demand Account Usage Fetch
  *
- * Manual refetch path for account limits: queries Anthropic's OAuth usage
- * endpoint (the same call Claude Code's /usage makes) to get FRESH session /
- * weekly / model-scoped windows for an account without consuming any tokens
- * and without starting a 5h session window.
+ * Lightweight account-limit refresh: queries Anthropic's OAuth usage endpoint
+ * (the same call Claude Code's /usage makes) to get fresh session / weekly /
+ * model-scoped windows without consuming tokens or starting a 5h session.
  *
  * This complements — never replaces — the passive header capture in
  * accountQuota.ts: `usageToQuota` normalizes the endpoint payload into the
  * same `AccountQuota` shape so refreshed data flows through the existing
- * save/merge/cooldown chain.
+ * save/merge/cooldown chain. Manual refresh and adaptive proxy prewarming use
+ * the same transport through the route-owned single-flight coordinator.
  *
  * Only OAuth (Bearer) accounts have subscription windows; api_key accounts
  * are skipped and keep their header-derived absolute limits.

package/dist/lib/proxy/providerTransportCoordinator.d.ts

@@ -0,0 +1,17 @@
+import type { ProxyProviderTransportPermit } from "../types/index.js";
+export declare class ProviderTransportCoordinator {
+    private generation;
+    private degraded;
+    private backoffUntil;
+    private lastErrorCode;
+    private lastTransportScope;
+    private probe;
+    acquire(signal?: AbortSignal): Promise<ProxyProviderTransportPermit>;
+    reportSuccess(permit: ProxyProviderTransportPermit): void;
+    reportTransportFailure(errorCode: string | undefined, transportScope: "shared_provider_transport" | "connection_transport", permit: ProxyProviderTransportPermit): void;
+    reportProbeAbandoned(permit: ProxyProviderTransportPermit): void;
+    clear(): void;
+    private wait;
+    private waitForProbe;
+    private waitForProbeOrAbort;
+}