@jsonstudio/llms 0.6.753 → 0.6.802

package/dist/conversion/compat/profiles/responses-output2choices-test.json

@@ -1,11 +1,12 @@
 {
-    "id": "responses:output2choices-test",
-    "protocol": "openai-responses",
-    "response": {
-        "mappings": [
-            {
-                "action": "convert_responses_output_to_choices"
-            }
-        ]
-    }
+  "id": "responses:output2choices-test",
+  "protocol": "openai-responses",
+  "response": {
+    "mappings": [
+      {
+        "action": "convert_responses_output_to_choices"
+      }
+    ]
+  }
 }
+

package/dist/conversion/hub/pipeline/context-limit.d.ts

@@ -0,0 +1,13 @@
+import type { ProcessedRequest, StandardizedRequest } from '../types/standardized.js';
+import type { TargetMetadata } from '../../../router/virtual-router/types.js';
+export declare function enforceTargetContextLimitOrThrow(options: {
+    requestId: string;
+    routeName?: string;
+    target: TargetMetadata;
+    request: StandardizedRequest | ProcessedRequest;
+}): {
+    estimatedInputTokens?: number;
+    maxContextTokens?: number;
+    allowedTokens?: number;
+    safetyRatio?: number;
+};

package/dist/conversion/hub/pipeline/context-limit.js

@@ -0,0 +1,55 @@
+import { computeRequestTokens } from '../../../router/virtual-router/token-estimator.js';
+function readSafetyRatioFromEnv() {
+    const raw = process?.env?.RCC_CONTEXT_TOKEN_SAFETY_RATIO ??
+        process?.env?.ROUTECODEX_CONTEXT_TOKEN_SAFETY_RATIO ??
+        '';
+    const value = Number(raw);
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    // Keep within sane bounds; default is 0 (exact limit).
+    return Math.max(0, Math.min(0.5, value));
+}
+export function enforceTargetContextLimitOrThrow(options) {
+    const maxContextTokensRaw = options.target?.maxContextTokens;
+    const maxContextTokens = typeof maxContextTokensRaw === 'number' && Number.isFinite(maxContextTokensRaw) && maxContextTokensRaw > 0
+        ? Math.floor(maxContextTokensRaw)
+        : undefined;
+    if (!maxContextTokens) {
+        return {};
+    }
+    const estimatedInputTokens = computeRequestTokens(options.request, '');
+    if (!(typeof estimatedInputTokens === 'number' && Number.isFinite(estimatedInputTokens) && estimatedInputTokens > 0)) {
+        return { maxContextTokens };
+    }
+    const safetyRatio = readSafetyRatioFromEnv();
+    const allowedTokens = Math.max(1, Math.floor(maxContextTokens * (1 - safetyRatio)));
+    if (estimatedInputTokens >= allowedTokens) {
+        const providerKey = options.target?.providerKey || 'unknown';
+        const modelId = options.target?.modelId || options.request?.model || 'unknown';
+        const routeName = options.routeName || 'unknown';
+        const message = `Context too long for ${providerKey}.${modelId}: ` +
+            `estimatedInputTokens=${estimatedInputTokens} exceeds allowed=${allowedTokens} ` +
+            `(maxContextTokens=${maxContextTokens}, safetyRatio=${safetyRatio}, route=${routeName})`;
+        const err = Object.assign(new Error(message), {
+            name: 'ContextLimitError',
+            code: 'CONTEXT_TOO_LONG',
+            status: 400,
+            requestId: options.requestId,
+            providerKey: options.target?.providerKey,
+            providerType: options.target?.providerType,
+            routeName: options.routeName,
+            details: {
+                estimatedInputTokens,
+                allowedTokens,
+                maxContextTokens,
+                safetyRatio,
+                providerKey: options.target?.providerKey,
+                modelId,
+                routeName
+            }
+        });
+        throw err;
+    }
+    return { estimatedInputTokens, maxContextTokens, allowedTokens, safetyRatio };
+}

package/dist/conversion/hub/pipeline/hub-pipeline.d.ts

@@ -64,7 +64,13 @@ export declare class HubPipeline {
     private config;
     private unsubscribeProviderErrors?;
     constructor(config: HubPipelineConfig);
+    updateRuntimeDeps(deps: {
+        healthStore?: HubPipelineConfig['healthStore'] | null;
+        routingStateStore?: HubPipelineConfig['routingStateStore'] | null;
+        quotaView?: HubPipelineConfig['quotaView'] | null;
+    }): void;
     updateVirtualRouterConfig(nextConfig: VirtualRouterConfig): void;
+    dispose(): void;
     private executeRequestStagePipeline;
     execute(request: HubPipelineRequest): Promise<HubPipelineResult>;
     private captureAnthropicAliasMap;

package/dist/conversion/hub/pipeline/hub-pipeline.js

@@ -51,6 +51,30 @@ export class HubPipeline {
             this.unsubscribeProviderErrors = undefined;
         }
     }
+    updateRuntimeDeps(deps) {
+        if (!deps || typeof deps !== 'object') {
+            return;
+        }
+        if ('healthStore' in deps) {
+            this.config.healthStore = deps.healthStore ?? undefined;
+        }
+        if ('routingStateStore' in deps) {
+            this.config.routingStateStore = (deps.routingStateStore ?? undefined);
+        }
+        if ('quotaView' in deps) {
+            this.config.quotaView = deps.quotaView ?? undefined;
+        }
+        try {
+            this.routerEngine.updateDeps({
+                healthStore: this.config.healthStore ?? null,
+                routingStateStore: (this.config.routingStateStore ?? null),
+                quotaView: this.config.quotaView ?? null
+            });
+        }
+        catch {
+            // best-effort: runtime deps updates must never break routing
+        }
+    }
     updateVirtualRouterConfig(nextConfig) {
         if (!nextConfig || typeof nextConfig !== 'object') {
             throw new Error('HubPipeline updateVirtualRouterConfig requires VirtualRouterConfig payload');
@@ -58,6 +82,17 @@ export class HubPipeline {
         this.config.virtualRouter = nextConfig;
         this.routerEngine.initialize(nextConfig);
     }
+    dispose() {
+        if (this.unsubscribeProviderErrors) {
+            try {
+                this.unsubscribeProviderErrors();
+            }
+            catch {
+                // ignore dispose failures
+            }
+            this.unsubscribeProviderErrors = undefined;
+        }
+    }
     async executeRequestStagePipeline(normalized, hooks) {
         const formatAdapter = hooks.createFormatAdapter();
         const semanticMapper = hooks.createSemanticMapper();

package/dist/conversion/shared/bridge-message-utils.d.ts

@@ -20,3 +20,4 @@ export interface BridgeInputToChatOptions {
     toolResultFallbackText?: string;
 }
 export declare function convertBridgeInputToChatMessages(options: BridgeInputToChatOptions): Array<Record<string, unknown>>;
+export declare function ensureMessagesArray(state: any): Array<Record<string, unknown>>;

package/dist/conversion/shared/bridge-message-utils.js

@@ -644,3 +644,10 @@ export function convertBridgeInputToChatMessages(options) {
     }
     return messages;
 }
+export function ensureMessagesArray(state) {
+    if (Array.isArray(state.messages))
+        return state.messages;
+    if (!state.messages)
+        state.messages = [];
+    return state.messages;
+}

package/dist/conversion/shared/bridge-policies.js

@@ -171,7 +171,7 @@ const OPENAI_CHAT_POLICY = {
     request: {
         inbound: [
             reasoningAction('openai_chat_reasoning'),
-            toolCallNormalizationAction('openai_chat_tool_call'),
+            toolCallNormalizationAction('openai_chat_tool_call'), { name: 'compat.fix-apply-patch' },
             { name: 'messages.ensure-system-instruction' },
             { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } },
             { name: 'metadata.provider-field', options: { field: 'metadata', target: 'providerMetadata' } },
@@ -180,7 +180,7 @@ const OPENAI_CHAT_POLICY = {
         outbound: [
             { name: 'messages.normalize-history' },
             { name: 'tools.capture-results' },
-            toolCallNormalizationAction('openai_chat_tool_call'),
+            toolCallNormalizationAction('openai_chat_tool_call'), { name: 'compat.fix-apply-patch' },
             { name: 'tools.ensure-placeholders' },
             { name: 'messages.ensure-output-fields', options: { toolFallback: 'Tool call completed (no output).' } },
             { name: 'messages.ensure-system-instruction' },
@@ -193,12 +193,12 @@ const OPENAI_CHAT_POLICY = {
     response: {
         inbound: [
             reasoningAction('openai_chat_reasoning'),
-            toolCallNormalizationAction('openai_chat_tool_call'),
+            toolCallNormalizationAction('openai_chat_tool_call'), { name: 'compat.fix-apply-patch' },
             { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } }
         ],
         outbound: [
             reasoningAction('openai_chat_reasoning'),
-            toolCallNormalizationAction('openai_chat_tool_call'),
+            toolCallNormalizationAction('openai_chat_tool_call'), { name: 'compat.fix-apply-patch' },
             { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } }
         ]
     }
@@ -242,7 +242,7 @@ const GEMINI_POLICY = {
     protocol: 'gemini-chat',
     request: {
         inbound: [
-            reasoningAction('gemini_reasoning'),
+            reasoningAction('gemini_reasoning'), { name: 'compat.fix-apply-patch' },
             { name: 'messages.ensure-system-instruction' },
             { name: 'metadata.extra-fields', options: { allowedKeys: GEMINI_ALLOWED_FIELDS } }
         ],
@@ -252,17 +252,17 @@ const GEMINI_POLICY = {
             { name: 'tools.ensure-placeholders' },
             { name: 'messages.ensure-output-fields', options: { toolFallback: 'Tool call completed (no output).' } },
             { name: 'messages.ensure-system-instruction' },
-            reasoningAction('gemini_reasoning'),
+            reasoningAction('gemini_reasoning'), { name: 'compat.fix-apply-patch' },
             { name: 'metadata.extra-fields', options: { allowedKeys: GEMINI_ALLOWED_FIELDS } }
         ]
     },
     response: {
         inbound: [
-            reasoningAction('gemini_reasoning'),
+            reasoningAction('gemini_reasoning'), { name: 'compat.fix-apply-patch' },
             { name: 'metadata.extra-fields', options: { allowedKeys: GEMINI_ALLOWED_FIELDS } }
         ],
         outbound: [
-            reasoningAction('gemini_reasoning'),
+            reasoningAction('gemini_reasoning'), { name: 'compat.fix-apply-patch' },
             { name: 'metadata.extra-fields', options: { allowedKeys: GEMINI_ALLOWED_FIELDS } }
         ]
     }

package/dist/conversion/shared/snapshot-hooks.js

@@ -110,6 +110,59 @@ function extractNestedGroupRequestId(value) {
     }
     return undefined;
 }
+function extractNestedEntryEndpoint(value) {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const obj = value;
+    const direct = readStringField(obj.entryEndpoint) ||
+        readStringField(obj.entry_endpoint) ||
+        readStringField(obj.endpoint);
+    if (direct) {
+        return direct;
+    }
+    const meta = obj.meta;
+    if (meta && typeof meta === 'object') {
+        const m = meta;
+        const fromMeta = readStringField(m.entryEndpoint) ||
+            readStringField(m.entry_endpoint) ||
+            readStringField(m.endpoint);
+        if (fromMeta) {
+            return fromMeta;
+        }
+        const ctx = m.context;
+        if (ctx && typeof ctx === 'object') {
+            const c = ctx;
+            const fromCtx = readStringField(c.entryEndpoint) ||
+                readStringField(c.entry_endpoint) ||
+                readStringField(c.endpoint);
+            if (fromCtx) {
+                return fromCtx;
+            }
+        }
+    }
+    const metadata = obj.metadata;
+    if (metadata && typeof metadata === 'object') {
+        const md = metadata;
+        const fromMetadata = readStringField(md.entryEndpoint) ||
+            readStringField(md.entry_endpoint) ||
+            readStringField(md.endpoint);
+        if (fromMetadata) {
+            return fromMetadata;
+        }
+    }
+    const runtime = obj.runtime;
+    if (runtime && typeof runtime === 'object') {
+        const r = runtime;
+        const fromRuntime = readStringField(r.entryEndpoint) ||
+            readStringField(r.entry_endpoint) ||
+            readStringField(r.endpoint);
+        if (fromRuntime) {
+            return fromRuntime;
+        }
+    }
+    return undefined;
+}
 function toErrorCode(error) {
     if (!error || typeof error !== 'object') {
         return undefined;
@@ -205,7 +258,7 @@ async function promotePendingDir(options) {
 }
 async function writeSnapshotFile(options) {
     const root = resolveSnapshotRoot();
-    const folder = resolveSnapshotFolder(options.endpoint);
+    const folder = resolveSnapshotFolder(extractNestedEntryEndpoint(options.data) || options.endpoint);
     const stageToken = sanitizeToken(options.stage, 'snapshot');
     const groupRequestToken = sanitizeToken(options.groupRequestId ||
         extractNestedGroupRequestId(options.data) ||

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

@@ -4,7 +4,8 @@
 // enforceChatBudget: 为避免在请求侧引入多余依赖，这里提供最小实现（保留形状，不裁剪）。
 import { augmentOpenAITools } from '../../guidance/index.js';
 import { validateToolCall } from '../../tools/tool-registry.js';
-import { repairFindMeta } from './tooling.js';
+import { captureApplyPatchRegression } from '../../tools/patch-regression-capturer.js';
+import { normalizeExecCommandArgs } from '../../tools/exec-command/normalize.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; }
@@ -245,6 +246,13 @@ export function normalizeApplyPatchToolCallsOnResponse(chat) {
                     else if (validation && !validation.ok) {
                         try {
                             const reason = validation.reason ?? 'unknown';
+                            captureApplyPatchRegression({
+                                errorType: reason,
+                                originalArgs: rawArgs,
+                                normalizedArgs: argsStr,
+                                validationError: reason,
+                                source: 'tool-governor.response'
+                            });
                             const snippet = typeof argsStr === 'string' && argsStr.trim().length
                                 ? argsStr.trim().slice(0, 200).replace(/\s+/g, ' ')
                                 : '';
@@ -312,6 +320,13 @@ function normalizeSpecialToolCallsOnRequest(request) {
                         else if (validation && !validation.ok) {
                             try {
                                 const reason = validation.reason ?? 'unknown';
+                                captureApplyPatchRegression({
+                                    errorType: reason,
+                                    originalArgs: rawArgs,
+                                    normalizedArgs: argsStr,
+                                    validationError: reason,
+                                    source: 'tool-governor.request'
+                                });
                                 const snippet = typeof argsStr === 'string' && argsStr.trim().length
                                     ? argsStr.trim().slice(0, 200).replace(/\s+/g, ' ')
                                     : '';
@@ -336,8 +351,9 @@ function normalizeSpecialToolCallsOnRequest(request) {
                         }
                         if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
                             const normalized = normalizeExecCommandArgs(parsed);
+                            const next = normalized.ok ? normalized.normalized : parsed;
                             try {
-                                fn.arguments = JSON.stringify(normalized ?? {});
+                                fn.arguments = JSON.stringify(next ?? {});
                             }
                             catch {
                                 fn.arguments = '{}';
@@ -356,27 +372,6 @@ function normalizeSpecialToolCallsOnRequest(request) {
         return request;
     }
 }
-function normalizeExecCommandArgs(args) {
-    try {
-        const out = { ...args };
-        const rawCmd = typeof out.cmd === 'string' && out.cmd.trim().length
-            ? String(out.cmd)
-            : typeof out.command === 'string' && out.command.trim().length
-                ? String(out.command)
-                : undefined;
-        if (rawCmd) {
-            const fixed = repairFindMeta(rawCmd);
-            out.cmd = fixed;
-            if (typeof out.command === 'string') {
-                out.command = fixed;
-            }
-        }
-        return out;
-    }
-    catch {
-        return args;
-    }
-}
 function enhanceResponseToolArguments(chat) {
     try {
         const enable = String(process?.env?.RCC_TOOL_ENHANCE ?? '1').trim() !== '0';

package/dist/filters/special/response-tool-arguments-stringify.js

@@ -1,28 +1,8 @@
 import { repairFindMeta } from '../../conversion/shared/tooling.js';
+import { normalizeExecCommandArgs } from '../../tools/exec-command/normalize.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
-function normalizeExecCommandArgs(args) {
-    try {
-        const out = { ...args };
-        const rawCmd = typeof out.cmd === 'string' && out.cmd.trim().length
-            ? String(out.cmd)
-            : typeof out.command === 'string' && out.command.trim().length
-                ? String(out.command)
-                : undefined;
-        if (rawCmd) {
-            const fixed = repairFindMeta(rawCmd);
-            out.cmd = fixed;
-            if (typeof out.command === 'string') {
-                out.command = fixed;
-            }
-        }
-        return out;
-    }
-    catch {
-        return args;
-    }
-}
 function packShellCommand(cmd) {
     // Normalize into ["bash","-lc","<single string>"] to support pipes, parens, -exec, etc.
     const normalizeArray = (argv) => {
@@ -104,8 +84,9 @@ export class ResponseToolArgumentsStringifyFilter {
                             }
                             else if ((name === 'exec_command' || name === 'shell_command' || name === 'bash') && isObject(parsed)) {
                                 const normalized = normalizeExecCommandArgs(parsed);
+                                const next = normalized.ok ? normalized.normalized : parsed;
                                 try {
-                                    fn.arguments = JSON.stringify(normalized ?? {});
+                                    fn.arguments = JSON.stringify(next ?? {});
                                 }
                                 catch {
                                     fn.arguments = '{}';

package/dist/router/virtual-router/engine-selection.js

@@ -220,7 +220,11 @@ function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features
         targets = targets.filter((key) => !excludedKeys.has(key));
     }
     if (targets.length > 0) {
-        targets = targets.filter((key) => !deps.isProviderCoolingDown(key));
+        const cooled = targets.filter((key) => !deps.isProviderCoolingDown(key));
+        // 单 provider 兜底：当一个 tier 只有一个候选 key 时，不因 cooldown 造成路由池为空。
+        if (cooled.length > 0 || targets.length !== 1) {
+            targets = cooled;
+        }
     }
     if (allowedProviders && allowedProviders.size > 0) {
         targets = targets.filter((key) => {
@@ -331,14 +335,22 @@ function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features
     const selectWithQuota = (candidates) => {
         if (!quotaView) {
             if (tier.mode === 'priority') {
-                return selectFirstAvailable(candidates);
+                const selected = selectFirstAvailable(candidates);
+                if (!selected && candidates.length === 1) {
+                    return candidates[0];
+                }
+                return selected;
             }
-            return deps.loadBalancer.select({
+            const selected = deps.loadBalancer.select({
                 routeName: `${routeName}:${tier.id}`,
                 candidates,
                 stickyKey: options.allowAliasRotation ? undefined : stickyKey,
                 availabilityCheck: (key) => deps.healthManager.isAvailable(key)
             }, tier.mode === 'round-robin' ? 'round-robin' : undefined);
+            if (!selected && candidates.length === 1) {
+                return candidates[0];
+            }
+            return selected;
         }
         const buckets = new Map();
         for (const key of candidates) {
@@ -389,6 +401,33 @@ function trySelectFromTier(routeName, tier, stickyKey, estimatedTokens, features
                 }
             }
         }
+        // default 路由永不因 quota gating 而“空池”：
+        // 当 quotaView 过滤后没有任何可用候选时，默认路由允许忽略 quotaView，
+        // 继续按健康/负载均衡选择一个 providerKey（但不覆盖 forced/required 约束）。
+        const quotaBypassAllowed = routeName === DEFAULT_ROUTE && (!requiredProviderKeys || requiredProviderKeys.size === 0);
+        if (quotaBypassAllowed) {
+            if (tier.mode === 'priority') {
+                const selected = selectFirstAvailable(candidates);
+                if (selected) {
+                    return selected;
+                }
+            }
+            else {
+                const selected = deps.loadBalancer.select({
+                    routeName: `${routeName}:${tier.id}:quota-bypass`,
+                    candidates,
+                    stickyKey: options.allowAliasRotation ? undefined : stickyKey,
+                    availabilityCheck: (key) => deps.healthManager.isAvailable(key)
+                }, tier.mode === 'round-robin' ? 'round-robin' : undefined);
+                if (selected) {
+                    return selected;
+                }
+            }
+        }
+        // 单 provider 兜底：当只剩一个候选 key 时，不因 quota/blacklist/cooldown 或健康状态过滤导致无 provider。
+        if (candidates.length === 1) {
+            return candidates[0];
+        }
         return null;
     };
     for (const candidatePool of prioritizedPools) {
@@ -416,10 +455,13 @@ export function selectFromStickyPool(stickyKeySet, metadata, features, state, de
     ]));
     const disabledModels = new Map(Array.from(state.disabledModels.entries()).map(([provider, models]) => [provider, new Set(models)]));
     let candidates = Array.from(stickyKeySet).filter((key) => !deps.isProviderCoolingDown(key));
+    if (!candidates.length && stickyKeySet.size === 1) {
+        candidates = Array.from(stickyKeySet);
+    }
     const quotaView = deps.quotaView;
     const now = quotaView ? Date.now() : 0;
     if (quotaView) {
-        candidates = candidates.filter((key) => {
+        const filtered = candidates.filter((key) => {
             const entry = quotaView(key);
             if (!entry) {
                 return true;
@@ -435,6 +477,9 @@ export function selectFromStickyPool(stickyKeySet, metadata, features, state, de
             }
             return true;
         });
+        if (filtered.length > 0 || candidates.length !== 1) {
+            candidates = filtered;
+        }
     }
     if (allowedProviders.size > 0) {
         candidates = candidates.filter((key) => {

package/dist/router/virtual-router/engine.d.ts

@@ -29,6 +29,11 @@ export declare class VirtualRouterEngine {
         routingStateStore?: RoutingInstructionStateStore;
         quotaView?: ProviderQuotaView;
     });
+    updateDeps(deps: {
+        healthStore?: VirtualRouterHealthStore | null;
+        routingStateStore?: RoutingInstructionStateStore | null;
+        quotaView?: ProviderQuotaView | null;
+    }): void;
     private parseDirectProviderModel;
     initialize(config: VirtualRouterConfig): void;
     route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {

package/dist/router/virtual-router/engine.js

@@ -44,6 +44,27 @@ export class VirtualRouterEngine {
             this.quotaView = deps.quotaView;
         }
     }
+    updateDeps(deps) {
+        if (!deps || typeof deps !== 'object') {
+            return;
+        }
+        if ('healthStore' in deps) {
+            this.healthStore = deps.healthStore ?? undefined;
+        }
+        if ('routingStateStore' in deps) {
+            this.routingStateStore =
+                deps.routingStateStore ??
+                    {
+                        loadSync: loadRoutingInstructionStateSync,
+                        saveAsync: saveRoutingInstructionStateAsync
+                    };
+            // Routing state store changes require clearing in-memory cache to avoid stale reads.
+            this.routingInstructionState.clear();
+        }
+        if ('quotaView' in deps) {
+            this.quotaView = deps.quotaView ?? undefined;
+        }
+    }
     parseDirectProviderModel(model) {
         const raw = typeof model === 'string' ? model.trim() : '';
         if (!raw) {

package/dist/tools/apply-patch/regression-capturer.d.ts

@@ -0,0 +1,12 @@
+interface RegressionSample {
+    id: string;
+    timestamp: string;
+    errorType: string;
+    originalArgs: string;
+    normalizedArgs?: string;
+    fixerResult?: string;
+    validationError?: string;
+    source?: string;
+}
+export declare function captureApplyPatchRegression(sample: Omit<RegressionSample, 'id' | 'timestamp'>): void;
+export {};