@jsonstudio/llms 0.6.2979 → 0.6.3238

package/dist/conversion/shared/responses-response-utils.js

@@ -1,6 +1,6 @@
 import { extractOutputSegments } from './output-content-normalizer.js';
-import { createBridgeActionState, runBridgeActionPipeline } from './bridge-actions.js';
-import { resolveBridgePolicy, resolvePolicyActions } from './bridge-policies.js';
+import { createBridgeActionState, runBridgeActionPipeline } from '../bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from '../bridge-policies.js';
 import { registerResponsesPayloadSnapshot, registerResponsesPassthrough } from './responses-reasoning-registry.js';
 import { normalizeFunctionCallIdWithNative, sanitizeReasoningTaggedTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 import { sanitizeResponsesFunctionNameWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
@@ -153,6 +153,60 @@ function collectRawReasoningSegments(response) {
     }
     return segments;
 }
+function collectReasoningSummarySegments(response) {
+    const segments = [];
+    const outputItems = Array.isArray(response.output) ? response.output : [];
+    for (const item of outputItems) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const type = typeof item.type === 'string' ? String(item.type).toLowerCase() : '';
+        if (type !== 'reasoning')
+            continue;
+        const summary = Array.isArray(item.summary) ? item.summary : [];
+        for (const entry of summary) {
+            if (typeof entry === 'string') {
+                segments.push(entry);
+                continue;
+            }
+            if (entry && typeof entry === 'object' && typeof entry.text === 'string') {
+                segments.push(entry.text);
+            }
+        }
+    }
+    return segments;
+}
+function collectReasoningEncryptedContent(response) {
+    const outputItems = Array.isArray(response.output) ? response.output : [];
+    for (const item of outputItems) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const type = typeof item.type === 'string' ? String(item.type).toLowerCase() : '';
+        if (type !== 'reasoning')
+            continue;
+        const encrypted = item.encrypted_content;
+        if (typeof encrypted === 'string' && encrypted.trim().length) {
+            return encrypted;
+        }
+    }
+    return undefined;
+}
+function buildReasoningPayload(options) {
+    const { summarySegments, contentSegments, encryptedContent } = options;
+    const summary = summarySegments.length
+        ? summarySegments.map((text) => ({ type: 'summary_text', text }))
+        : undefined;
+    const content = contentSegments.length
+        ? contentSegments.map((text) => ({ type: 'reasoning_text', text }))
+        : undefined;
+    if (!summary && !content && encryptedContent === undefined) {
+        return undefined;
+    }
+    return {
+        summary,
+        content,
+        encrypted_content: encryptedContent
+    };
+}
 function registerPassthroughSnapshot(payload) {
     const ids = new Set();
     const requestId = typeof payload?.request_id === 'string' ? payload.request_id.trim() : '';
@@ -165,6 +219,23 @@ function registerPassthroughSnapshot(payload) {
         registerResponsesPassthrough(candidate, payload);
     }
 }
+function cloneSnapshot(value) {
+    try {
+        const structuredCloneImpl = globalThis.structuredClone;
+        if (typeof structuredCloneImpl === 'function') {
+            return structuredCloneImpl(value);
+        }
+    }
+    catch {
+        /* ignore structuredClone failures */
+    }
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return { ...value };
+    }
+}
 export function buildChatResponseFromResponses(payload) {
     if (!payload || typeof payload !== 'object')
         return payload;
@@ -185,8 +256,13 @@ export function buildChatResponseFromResponses(payload) {
     const toolCalls = collectToolCallsFromResponses(response);
     const { textParts, reasoningParts } = extractOutputSegments(response);
     const rawReasoningSegments = collectRawReasoningSegments(response);
-    const explicitOutput = typeof response.output_text === 'string' && response.output_text.trim().length
-        ? sanitizeReasoningTaggedTextWithNative(response.output_text)
+    const summaryReasoningSegments = collectReasoningSummarySegments(response);
+    const encryptedReasoning = collectReasoningEncryptedContent(response);
+    const outputTextRaw = typeof response.output_text === 'string' && response.output_text.trim().length
+        ? response.output_text
+        : undefined;
+    const explicitOutput = typeof outputTextRaw === 'string'
+        ? sanitizeReasoningTaggedTextWithNative(outputTextRaw)
         : undefined;
     const messageContentText = explicitOutput || textParts.join('\n').trim();
     const messageContent = messageContentText || '';
@@ -218,7 +294,9 @@ export function buildChatResponseFromResponses(payload) {
     if (toolCalls.length) {
         message.tool_calls = toolCalls;
     }
-    const reasoningSegments = rawReasoningSegments.length ? rawReasoningSegments : reasoningParts;
+    const reasoningSegments = rawReasoningSegments.length
+        ? rawReasoningSegments
+        : (reasoningParts.length ? reasoningParts : summaryReasoningSegments);
     if (reasoningSegments.length) {
         message.reasoning_content = reasoningSegments.join('\n');
     }
@@ -237,13 +315,18 @@ export function buildChatResponseFromResponses(payload) {
         ]
     };
     const hasOutputTextField = Object.prototype.hasOwnProperty.call(response, 'output_text');
-    if (rawReasoningSegments.length) {
-        chat.__responses_reasoning = rawReasoningSegments;
+    const reasoningPayload = buildReasoningPayload({
+        summarySegments: summaryReasoningSegments,
+        contentSegments: rawReasoningSegments.length ? rawReasoningSegments : reasoningParts,
+        encryptedContent: encryptedReasoning
+    });
+    if (reasoningPayload) {
+        chat.__responses_reasoning = reasoningPayload;
     }
     chat.__responses_output_text_meta = {
         hasField: hasOutputTextField,
-        value: hasOutputTextField && typeof response.output_text === 'string'
-            ? sanitizeReasoningTaggedTextWithNative(response.output_text)
+        value: typeof outputTextRaw === 'string'
+            ? sanitizeReasoningTaggedTextWithNative(outputTextRaw)
             : undefined
     };
     if (usage !== undefined) {
@@ -256,5 +339,12 @@ export function buildChatResponseFromResponses(payload) {
         chat.request_id = requestId;
     }
     registerResponsesPayloadSnapshot(id, response);
+    if (requestId && requestId !== id) {
+        registerResponsesPayloadSnapshot(requestId, response);
+    }
+    const snapshot = cloneSnapshot(response);
+    if (snapshot) {
+        chat.__responses_payload_snapshot = snapshot;
+    }
     return chat;
 }

package/dist/conversion/shared/responses-tool-utils.js

@@ -1,4 +1,4 @@
-import { normalizeFunctionCallId, normalizeFunctionCallOutputId, normalizeResponsesCallId } from './bridge-id-utils.js';
+import { normalizeFunctionCallId, normalizeFunctionCallOutputId, normalizeResponsesCallId } from '../bridge-id-utils.js';
 import { sanitizeResponsesFunctionNameWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
 export function createToolCallIdTransformer(style) {
     if (style !== 'fc') {

package/dist/conversion/shared/text-markup-normalizer/normalize.d.ts

@@ -1,2 +1,2 @@
-import type { TextMarkupNormalizeOptions } from './extractors.js';
+import type { TextMarkupNormalizeOptions } from '../../types/text-markup-normalizer.js';
 export declare function normalizeAssistantTextToToolCalls(message: Record<string, any>, _options?: TextMarkupNormalizeOptions): Record<string, any>;

package/dist/conversion/shared/text-markup-normalizer.d.ts

@@ -1,4 +1,4 @@
-export type { JsonToolRepairConfig, TextMarkupNormalizeOptions, ToolCallLite } from './text-markup-normalizer/extractors.js';
-export { extractApplyPatchCallsFromText, extractBareExecCommandFromText, extractExecuteBlocksFromText, extractExploredListDirectoryCallsFromText, extractInvokeToolsFromText, extractJsonToolCallsFromText, extractParameterXmlToolsFromText, extractQwenToolCallTokensFromText, extractSimpleXmlToolsFromText, extractToolNamespaceXmlBlocksFromText, extractXMLToolCallsFromText } from './text-markup-normalizer/extractors.js';
+export type { JsonToolRepairConfig, TextMarkupNormalizeOptions, ToolCallLite } from '../types/text-markup-normalizer.js';
+export { extractApplyPatchCallsFromTextWithNative as extractApplyPatchCallsFromText, extractBareExecCommandFromTextWithNative as extractBareExecCommandFromText, extractExecuteBlocksFromTextWithNative as extractExecuteBlocksFromText, extractExploredListDirectoryCallsFromTextWithNative as extractExploredListDirectoryCallsFromText, extractInvokeToolsFromTextWithNative as extractInvokeToolsFromText, extractJsonToolCallsFromTextWithNative as extractJsonToolCallsFromText, extractParameterXmlToolsFromTextWithNative as extractParameterXmlToolsFromText, extractQwenToolCallTokensFromTextWithNative as extractQwenToolCallTokensFromText, extractSimpleXmlToolsFromTextWithNative as extractSimpleXmlToolsFromText, extractToolNamespaceXmlBlocksFromTextWithNative as extractToolNamespaceXmlBlocksFromText, extractXMLToolCallsFromTextWithNative as extractXMLToolCallsFromText } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export { normalizeAssistantTextToToolCalls } from './text-markup-normalizer/normalize.js';
 export { extractToolCallsFromReasoningTextWithNative, parseLenientJsonishWithNative, repairArgumentsToStringWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';

package/dist/conversion/shared/text-markup-normalizer.js

@@ -1,3 +1,3 @@
-export { extractApplyPatchCallsFromText, extractBareExecCommandFromText, extractExecuteBlocksFromText, extractExploredListDirectoryCallsFromText, extractInvokeToolsFromText, extractJsonToolCallsFromText, extractParameterXmlToolsFromText, extractQwenToolCallTokensFromText, extractSimpleXmlToolsFromText, extractToolNamespaceXmlBlocksFromText, extractXMLToolCallsFromText } from './text-markup-normalizer/extractors.js';
+export { extractApplyPatchCallsFromTextWithNative as extractApplyPatchCallsFromText, extractBareExecCommandFromTextWithNative as extractBareExecCommandFromText, extractExecuteBlocksFromTextWithNative as extractExecuteBlocksFromText, extractExploredListDirectoryCallsFromTextWithNative as extractExploredListDirectoryCallsFromText, extractInvokeToolsFromTextWithNative as extractInvokeToolsFromText, extractJsonToolCallsFromTextWithNative as extractJsonToolCallsFromText, extractParameterXmlToolsFromTextWithNative as extractParameterXmlToolsFromText, extractQwenToolCallTokensFromTextWithNative as extractQwenToolCallTokensFromText, extractSimpleXmlToolsFromTextWithNative as extractSimpleXmlToolsFromText, extractToolNamespaceXmlBlocksFromTextWithNative as extractToolNamespaceXmlBlocksFromText, extractXMLToolCallsFromTextWithNative as extractXMLToolCallsFromText } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export { normalizeAssistantTextToToolCalls } from './text-markup-normalizer/normalize.js';
 export { extractToolCallsFromReasoningTextWithNative, parseLenientJsonishWithNative, repairArgumentsToStringWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';

package/dist/conversion/shared/tool-filter-pipeline.js

@@ -1,6 +1,6 @@
 import { FilterEngine } from '../../filters/index.js';
 import { loadFieldMapConfig } from '../../filters/utils/fieldmap-loader.js';
-import { createSnapshotWriter } from './snapshot-utils.js';
+import { createSnapshotWriter } from '../snapshot-utils.js';
 import { normalizeChatResponseReasoningToolsWithNative as normalizeChatResponseReasoningTools } from '../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
 const REQUEST_FILTER_STAGES = [
     'request_pre',

package/dist/conversion/shared/tool-governor.js

@@ -6,7 +6,8 @@ import { augmentOpenAITools } from '../../guidance/index.js';
 import { validateToolCall } from '../../tools/tool-registry.js';
 import { captureApplyPatchRegression } from '../../tools/patch-regression-capturer.js';
 import { normalizeExecCommandArgs } from '../../tools/exec-command/normalize.js';
-import { readRuntimeMetadata } from './runtime-metadata.js';
+import { readRuntimeMetadata } from '../runtime-metadata.js';
+import { normalizeChatResponseReasoningToolsWithNative } from '../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
 function isObject(v) { return !!v && typeof v === 'object' && !Array.isArray(v); }
 // Note: tool schema strict augmentation removed per alignment
 function enforceChatBudget(chat, _modelId) { return chat; }
@@ -639,8 +640,7 @@ export function processChatResponseTools(resp) {
     if (!isObject(resp))
         return resp;
     try {
-        const { canonicalizeChatResponseTools } = require('./tool-canonicalizer.js');
-        const canon = canonicalizeChatResponseTools(resp);
+        const canon = normalizeChatResponseReasoningToolsWithNative(resp);
         const withPatch = normalizeApplyPatchToolCallsOnResponse(canon);
         return enhanceResponseToolArguments(withPatch);
     }

package/dist/conversion/shared/tool-mapping.d.ts

@@ -1,5 +1,5 @@
 import type { ChatToolDefinition } from '../hub/types/chat-envelope.js';
-import type { BridgeToolDefinition } from './bridge-message-types.js';
+import type { BridgeToolDefinition } from '../types/bridge-message-types.js';
 export interface ToolCallFunction {
     name: string;
     arguments: string;

package/dist/conversion/{shared/snapshot-utils.d.ts → snapshot-utils.d.ts}

@@ -1,3 +1,13 @@
+export interface SnapshotHookOptions {
+    endpoint: string;
+    stage: string;
+    requestId: string;
+    data: unknown;
+    verbosity?: 'minimal' | 'verbose';
+    channel?: string;
+    providerKey?: string;
+    groupRequestId?: string;
+}
 interface SnapshotPayload {
     stage: string;
     requestId: string;
@@ -8,6 +18,7 @@ interface SnapshotPayload {
     groupRequestId?: string;
 }
 export declare function shouldRecordSnapshots(): boolean;
+export declare function writeSnapshotViaHooks(options: SnapshotHookOptions): Promise<void>;
 export declare function recordSnapshot(options: SnapshotPayload): Promise<void>;
 export type SnapshotWriter = (stage: string, payload: unknown) => void;
 export declare function createSnapshotWriter(opts: {

package/dist/conversion/{shared/snapshot-utils.js → snapshot-utils.js}

@@ -1,27 +1,18 @@
-import { writeSnapshotViaHooks } from './snapshot-hooks.js';
-function resolveBoolFromEnv(value, fallback) {
-    if (!value) {
-        return fallback;
-    }
-    const normalized = value.trim().toLowerCase();
-    if (['1', 'true', 'yes', 'on'].includes(normalized)) {
-        return true;
-    }
-    if (['0', 'false', 'no', 'off'].includes(normalized)) {
-        return false;
-    }
-    return fallback;
-}
+import { shouldRecordSnapshotsWithNative, writeSnapshotViaHooksWithNative } from '../router/virtual-router/engine-selection/native-snapshot-hooks.js';
 export function shouldRecordSnapshots() {
-    const hubFlag = process.env.ROUTECODEX_HUB_SNAPSHOTS;
-    if (hubFlag && hubFlag.trim().length) {
-        return resolveBoolFromEnv(hubFlag, true);
-    }
-    const sharedFlag = process.env.ROUTECODEX_SNAPSHOT ?? process.env.ROUTECODEX_SNAPSHOTS;
-    if (sharedFlag && sharedFlag.trim().length) {
-        return resolveBoolFromEnv(sharedFlag, true);
-    }
-    return true;
+    return shouldRecordSnapshotsWithNative();
+}
+export async function writeSnapshotViaHooks(options) {
+    writeSnapshotViaHooksWithNative({
+        endpoint: options.endpoint,
+        stage: options.stage,
+        requestId: options.requestId,
+        data: options.data,
+        verbosity: options.verbosity,
+        channel: options.channel,
+        providerKey: options.providerKey,
+        groupRequestId: options.groupRequestId
+    });
 }
 export async function recordSnapshot(options) {
     if (!shouldRecordSnapshots())

package/dist/conversion/types/text-markup-normalizer.d.ts

@@ -0,0 +1,13 @@
+export type JsonToolArgumentAliasMap = Record<string, string[]>;
+export type JsonToolRepairConfig = {
+    toolNameAliases?: Record<string, string>;
+    argumentAliases?: Record<string, JsonToolArgumentAliasMap>;
+};
+export type TextMarkupNormalizeOptions = {
+    jsonToolRepair?: JsonToolRepairConfig;
+};
+export type ToolCallLite = {
+    id?: string;
+    name: string;
+    args: string;
+};

package/dist/conversion/types/text-markup-normalizer.js

@@ -0,0 +1 @@
+export {};

package/dist/filters/special/request-tools-normalize.js

@@ -26,7 +26,7 @@ export class RequestOpenAIToolsNormalizeFilter {
             }
             let normalizedList = [];
             try {
-                const mod = await import('../../conversion/shared/args-mapping.js');
+                const mod = await import('../../conversion/args-mapping.js');
                 const normalizeTools = mod?.normalizeTools;
                 if (typeof normalizeTools === 'function')
                     normalizedList = normalizeTools(tools);

package/dist/filters/special/response-tool-text-canonicalize.js

@@ -1,4 +1,4 @@
-import { canonicalizeChatResponseTools } from '../../conversion/shared/tool-canonicalizer.js';
+import { normalizeChatResponseReasoningToolsWithNative } from '../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
 /**
  * Canonicalize structured tool_calls (Chat path).
  *
@@ -10,7 +10,7 @@ export class ResponseToolTextCanonicalizeFilter {
     name = 'response_tool_text_canonicalize';
     stage = 'response_pre';
     apply(input) {
-        const out = canonicalizeChatResponseTools(input);
+        const out = normalizeChatResponseReasoningToolsWithNative(input);
         return { ok: true, data: out };
     }
 }

package/dist/quota/quota-manager.js

@@ -115,16 +115,6 @@ function collectUpstreamErrorSources(ev) {
 function isAntigravityProviderKey(providerKey) {
     return providerKey.toLowerCase().startsWith('antigravity.');
 }
-function resolveAntigravityRuntimeKey(providerKey, ev) {
-    const rtKey = safeTrim(ev?.runtime?.target?.runtimeKey);
-    if (rtKey)
-        return rtKey;
-    const parts = providerKey.split('.').filter(Boolean);
-    if (parts.length >= 2) {
-        return `${parts[0]}.${parts[1]}`;
-    }
-    return null;
-}
 function isGoogleAccountVerificationRequired(ev, sources) {
     if (!sources.length) {
         sources = collectUpstreamErrorSources(ev);
@@ -277,64 +267,46 @@ export class QuotaManager {
         const code = safeTrim(ev.code) || safeTrim(ev?.runtime?.errorCode);
         const details = ev.details && typeof ev.details === 'object' ? ev.details : undefined;
         const state = this.ensureProvider(providerKey);
-        // Antigravity account-scope auth verification required: blacklist the whole runtimeKey group.
+        // Antigravity account-scope auth verification required: isolate to current providerKey only.
         if (isAntigravityProviderKey(providerKey)) {
             const sources = collectUpstreamErrorSources(ev);
-            const runtimeKey = resolveAntigravityRuntimeKey(providerKey, ev);
-            if (runtimeKey && isGoogleAccountVerificationRequired(ev, sources)) {
+            if (isGoogleAccountVerificationRequired(ev, sources)) {
                 const url = extractFirstUrl(sources);
                 const banUntil = nowMs + ANTIGRAVITY_AUTH_VERIFY_BAN_MS;
-                for (const key of this.states.keys()) {
-                    if (!key.startsWith(`${runtimeKey}.`))
-                        continue;
-                    const s = this.ensureProvider(key);
-                    const next = {
-                        ...s,
-                        inPool: false,
-                        reason: 'authVerify',
-                        authIssue: {
-                            kind: 'google_account_verification',
-                            ...(url ? { url } : {}),
-                            message: 'account verification required'
-                        },
-                        blacklistUntil: Math.max(s.blacklistUntil ?? 0, banUntil) || banUntil,
-                        cooldownUntil: null,
-                        lastErrorAtMs: nowMs,
-                        lastErrorCode: code || 'AUTH_VERIFY',
-                        lastErrorSeries: 'EFATAL',
-                        consecutiveErrorCount: 0
-                    };
-                    this.states.set(key, tickQuotaStateTime(next, nowMs));
-                }
+                const next = {
+                    ...state,
+                    inPool: false,
+                    reason: 'authVerify',
+                    authIssue: {
+                        kind: 'google_account_verification',
+                        ...(url ? { url } : {}),
+                        message: 'account verification required'
+                    },
+                    blacklistUntil: Math.max(state.blacklistUntil ?? 0, banUntil) || banUntil,
+                    cooldownUntil: null,
+                    lastErrorAtMs: nowMs,
+                    lastErrorCode: code || 'AUTH_VERIFY',
+                    lastErrorSeries: 'EFATAL',
+                    consecutiveErrorCount: 0
+                };
+                this.states.set(providerKey, tickQuotaStateTime(next, nowMs));
                 this.markDirty();
                 return;
             }
-            // Thought signature missing: freeze Gemini series under runtimeKey to avoid request storms.
+            // Thought signature missing: cooldown current providerKey only.
             if (isThoughtSignatureMissing(ev, sources)) {
                 const freezeUntil = nowMs + ANTIGRAVITY_THOUGHT_SIGNATURE_MISSING_COOLDOWN_MS;
-                const prefix = runtimeKey ? `${runtimeKey}.` : `${providerKey.split('.').slice(0, 2).join('.')}.`;
-                for (const key of this.states.keys()) {
-                    if (!key.startsWith(prefix))
-                        continue;
-                    const parts = key.split('.');
-                    const modelId = parts.length >= 3 ? parts.slice(2).join('.') : '';
-                    const lowerModel = modelId.toLowerCase();
-                    const isGeminiSeries = lowerModel.includes('gemini') && (lowerModel.includes('pro') || lowerModel.includes('flash'));
-                    if (!isGeminiSeries)
-                        continue;
-                    const s = this.ensureProvider(key);
-                    const next = {
-                        ...s,
-                        inPool: false,
-                        reason: 'cooldown',
-                        cooldownUntil: Math.max(s.cooldownUntil ?? 0, freezeUntil) || freezeUntil,
-                        lastErrorAtMs: nowMs,
-                        lastErrorCode: code || 'SIGNATURE_MISSING',
-                        lastErrorSeries: 'EOTHER',
-                        consecutiveErrorCount: 0
-                    };
-                    this.states.set(key, tickQuotaStateTime(next, nowMs));
-                }
+                const next = {
+                    ...state,
+                    inPool: false,
+                    reason: 'cooldown',
+                    cooldownUntil: Math.max(state.cooldownUntil ?? 0, freezeUntil) || freezeUntil,
+                    lastErrorAtMs: nowMs,
+                    lastErrorCode: code || 'SIGNATURE_MISSING',
+                    lastErrorSeries: 'EOTHER',
+                    consecutiveErrorCount: 0
+                };
+                this.states.set(providerKey, tickQuotaStateTime(next, nowMs));
                 this.markDirty();
                 return;
             }

package/dist/quota/quota-state.js

@@ -1,6 +1,6 @@
-const COOLDOWN_SCHEDULE_429_MS = [5_000, 30_000, 60_000, 300_000, 1_800_000, 3_600_000, 10_000_000];
-const COOLDOWN_SCHEDULE_FATAL_MS = [5 * 60_000, 15 * 60_000, 30 * 60_000, 60 * 60_000, 3 * 60 * 60_000];
-const COOLDOWN_SCHEDULE_DEFAULT_MS = [5_000, 30_000, 60_000, 300_000, 1_800_000, 3_600_000, 10_000_000];
+const COOLDOWN_SCHEDULE_429_MS = [3_000, 10_000, 31_000, 61_000];
+const COOLDOWN_SCHEDULE_FATAL_MS = [3_000, 10_000, 31_000, 61_000];
+const COOLDOWN_SCHEDULE_DEFAULT_MS = [3_000, 10_000, 31_000, 61_000];
 const ERROR_CHAIN_WINDOW_MS = 10 * 60_000;
 const NETWORK_ERROR_CODES = [
     'ECONNRESET',
@@ -56,14 +56,21 @@ export function normalizeErrorSeries(event) {
 }
 function normalizeErrorKey(event) {
     const rawCode = String(event.code || '').trim().toUpperCase();
-    if (rawCode) {
+    const status = typeof event.httpStatus === 'number' ? event.httpStatus : null;
+    const isGenericCode = rawCode === '' ||
+        rawCode === 'ERR_PROVIDER_FAILURE' ||
+        rawCode === 'ERR_PIPELINE_FAILURE' ||
+        rawCode === 'ERR_COMPATIBILITY' ||
+        rawCode === 'EXTERNAL_ERROR' ||
+        rawCode === 'INTERNAL_ERROR' ||
+        rawCode === 'TOOL_ERROR';
+    if (!isGenericCode) {
         return rawCode;
     }
-    const status = typeof event.httpStatus === 'number' ? event.httpStatus : null;
     if (status && Number.isFinite(status)) {
         return `HTTP_${Math.floor(status)}`;
     }
-    return 'ERR_UNKNOWN';
+    return rawCode || 'ERR_UNKNOWN';
 }
 function computeCooldownMsBySeries(series, consecutive) {
     if (consecutive <= 0) {
@@ -125,12 +132,12 @@ export function applyErrorEvent(state, event, nowMs = event.timestampMs ?? Date.
         nowMs - lastAt >= 0 &&
         nowMs - lastAt <= ERROR_CHAIN_WINDOW_MS;
     const sameErrorKey = withinChainWindow && state.lastErrorCode === errorKey;
-    const rawNextCount = sameErrorKey ? state.consecutiveErrorCount + 1 : 1;
     const schedule = series === 'E429'
         ? COOLDOWN_SCHEDULE_429_MS
         : series === 'EFATAL'
             ? COOLDOWN_SCHEDULE_FATAL_MS
             : COOLDOWN_SCHEDULE_DEFAULT_MS;
+    const rawNextCount = sameErrorKey ? state.consecutiveErrorCount + 1 : 1;
     const nextCount = rawNextCount > schedule.length ? 1 : rawNextCount;
     const cooldownMs = computeCooldownMsBySeries(series, nextCount);
     const nextUntil = cooldownMs ? nowMs + cooldownMs : null;

package/dist/router/virtual-router/bootstrap/profile-builder.d.ts

@@ -4,4 +4,5 @@ export declare function buildProviderProfiles(targetKeys: Set<string>, runtimeEn
     targetRuntime: Record<string, ProviderRuntimeProfile>;
 };
 export declare function resolveContextTokens(runtime: ProviderRuntimeProfile, modelId: string): number;
+export declare function resolveOutputTokens(runtime: ProviderRuntimeProfile, modelId: string): number | undefined;
 export declare function normalizeHealth(input: unknown): ProviderHealthConfig | undefined;

package/dist/router/virtual-router/bootstrap/profile-builder.js

@@ -16,6 +16,7 @@ export function buildProviderProfiles(targetKeys, runtimeEntries) {
             ? runtime.modelStreaming?.[parsed.modelId]
             : runtime.streaming;
         const contextTokens = resolveContextTokens(runtime, parsed.modelId);
+        const outputTokens = resolveOutputTokens(runtime, parsed.modelId);
         profiles[targetKey] = {
             providerKey: targetKey,
             providerType: runtime.providerType,
@@ -28,6 +29,7 @@ export function buildProviderProfiles(targetKeys, runtimeEntries) {
             processMode: runtime.processMode || 'chat',
             responsesConfig: runtime.responsesConfig,
             streaming: streamingPref,
+            maxOutputTokens: outputTokens,
             maxContextTokens: contextTokens,
             ...(runtime.deepseek ? { deepseek: runtime.deepseek } : {}),
             ...(runtime.serverToolsDisabled ? { serverToolsDisabled: true } : {})
@@ -52,6 +54,17 @@ export function resolveContextTokens(runtime, modelId) {
     }
     return DEFAULT_MODEL_CONTEXT_TOKENS;
 }
+export function resolveOutputTokens(runtime, modelId) {
+    const specific = runtime.modelOutputTokens?.[modelId];
+    if (typeof specific === 'number' && Number.isFinite(specific) && specific > 0) {
+        return Math.floor(specific);
+    }
+    const fallback = runtime.defaultOutputTokens;
+    if (typeof fallback === 'number' && Number.isFinite(fallback) && fallback > 0) {
+        return Math.floor(fallback);
+    }
+    return undefined;
+}
 export function normalizeHealth(input) {
     if (!input || typeof input !== 'object')
         return undefined;

package/dist/router/virtual-router/bootstrap/provider-normalization.d.ts

@@ -18,6 +18,8 @@ export interface NormalizedProvider {
     responsesConfig?: ResponsesProviderConfig;
     streaming?: 'always' | 'auto' | 'never';
     modelStreaming?: Record<string, 'always' | 'auto' | 'never'>;
+    modelOutputTokens?: Record<string, number>;
+    defaultOutputTokens?: number;
     modelContextTokens?: Record<string, number>;
     defaultContextTokens?: number;
     deepseek?: DeepSeekCompatRuntimeOptions;

package/dist/router/virtual-router/bootstrap/provider-normalization.js

@@ -5,7 +5,7 @@
 import { VirtualRouterError, VirtualRouterErrorCode } from '../types.js';
 import { CLAUDE_CODE_DEFAULT_USER_AGENT, CLAUDE_CODE_DEFAULT_X_APP, CLAUDE_CODE_DEFAULT_ANTHROPIC_BETA, parseClaudeCodeAppVersionFromUserAgent } from './claude-code-helpers.js';
 import { normalizeResponsesConfig, resolveProviderStreamingPreference } from './responses-helpers.js';
-import { normalizeModelStreaming, normalizeModelContextTokens } from './streaming-helpers.js';
+import { normalizeModelStreaming, normalizeModelContextTokens, normalizeModelOutputTokens } from './streaming-helpers.js';
 /**
  * Normalize a raw provider configuration into a NormalizedProvider.
  */
@@ -33,6 +33,7 @@ export function normalizeProvider(providerId, raw) {
     const streaming = resolveProviderStreamingPreference(provider, responsesNode);
     const modelStreaming = normalizeModelStreaming(provider);
     const { modelContextTokens, defaultContextTokens } = normalizeModelContextTokens(provider);
+    const { modelOutputTokens, defaultOutputTokens } = normalizeModelOutputTokens(provider);
     const deepseek = normalizeDeepSeekOptions(provider);
     const serverToolsDisabled = provider.serverToolsDisabled === true ||
         (typeof provider.serverToolsDisabled === 'string' &&
@@ -51,6 +52,8 @@ export function normalizeProvider(providerId, raw) {
         responsesConfig,
         streaming,
         modelStreaming,
+        modelOutputTokens,
+        defaultOutputTokens,
         modelContextTokens,
         defaultContextTokens,
         ...(deepseek ? { deepseek } : {}),

package/dist/router/virtual-router/bootstrap/streaming-helpers.d.ts

@@ -10,3 +10,10 @@ export declare function normalizeModelContextTokens(provider: Record<string, unk
     modelContextTokens?: Record<string, number>;
     defaultContextTokens?: number;
 };
+/**
+ * Normalize model-level output token limits (maxTokens / max_output_tokens).
+ */
+export declare function normalizeModelOutputTokens(provider: Record<string, unknown>): {
+    modelOutputTokens?: Record<string, number>;
+    defaultOutputTokens?: number;
+};