@jsonstudio/llms 0.6.375 → 0.6.467

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

@@ -3,6 +3,7 @@ import { resolveBridgePolicy, resolvePolicyActions } from './bridge-policies.js'
 import { normalizeChatMessageContent } from './chat-output-normalizer.js';
 import { mapBridgeToolsToChat, mapChatToolsToBridge } from './tool-mapping.js';
 import { jsonClone } from '../hub/types/json.js';
+import { ProviderProtocolError } from './errors.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -111,20 +112,39 @@ function extractToolResultSegment(entry) {
     }
     return String(entry);
 }
+function resolveProtocolErrorCode(context) {
+    const ctx = context.toLowerCase();
+    return ctx.includes('tool') ? 'TOOL_PROTOCOL_ERROR' : 'MALFORMED_REQUEST';
+}
 function requireTrimmedString(value, context) {
     if (typeof value !== 'string') {
-        throw new Error(`Anthropic bridge constraint violated: ${context} must be a string`);
+        throw new ProviderProtocolError(`Anthropic bridge constraint violated: ${context} must be a string`, {
+            code: resolveProtocolErrorCode(context),
+            protocol: 'anthropic-messages',
+            providerType: 'anthropic',
+            details: { context, actualType: typeof value }
+        });
     }
     const trimmed = value.trim();
     if (!trimmed.length) {
-        throw new Error(`Anthropic bridge constraint violated: ${context} must not be empty`);
+        throw new ProviderProtocolError(`Anthropic bridge constraint violated: ${context} must not be empty`, {
+            code: resolveProtocolErrorCode(context),
+            protocol: 'anthropic-messages',
+            providerType: 'anthropic',
+            details: { context }
+        });
     }
     return trimmed;
 }
 function requireSystemText(block, context) {
     const text = flattenAnthropicText(block).trim();
     if (!text) {
-        throw new Error(`Anthropic bridge constraint violated: ${context} must contain text`);
+        throw new ProviderProtocolError(`Anthropic bridge constraint violated: ${context} must contain text`, {
+            code: resolveProtocolErrorCode(context),
+            protocol: 'anthropic-messages',
+            providerType: 'anthropic',
+            details: { context }
+        });
     }
     return text;
 }
@@ -710,7 +730,12 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
                 pushSystemBlock(requireSystemText(val, 'top-level system'));
                 return;
             }
-            throw new Error('Anthropic bridge constraint violated: unsupported system payload type');
+            throw new ProviderProtocolError('Anthropic bridge constraint violated: unsupported system payload type', {
+                code: 'MALFORMED_REQUEST',
+                protocol: 'anthropic-messages',
+                providerType: 'anthropic',
+                details: { context: 'top-level system', actualType: typeof val }
+            });
         };
         ingestSystem(sys);
     }
@@ -730,7 +755,12 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
         const text = collectText(contentNode).trim();
         if (role === 'system') {
             if (!text) {
-                throw new Error('Anthropic bridge constraint violated: Chat system message must contain text');
+                throw new ProviderProtocolError('Anthropic bridge constraint violated: Chat system message must contain text', {
+                    code: 'MALFORMED_REQUEST',
+                    protocol: 'anthropic-messages',
+                    providerType: 'anthropic',
+                    details: { context: 'chat.system', original: contentNode }
+                });
             }
             pushSystemBlock(text);
             continue;
@@ -738,7 +768,12 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
         if (role === 'tool') {
             const toolCallId = requireTrimmedString(m.tool_call_id ?? m.call_id ?? m.tool_use_id ?? m.id, 'tool_result.tool_call_id');
             if (!knownToolCallIds.has(toolCallId)) {
-                throw new Error(`Anthropic bridge constraint violated: tool result ${toolCallId} has no matching tool call`);
+                throw new ProviderProtocolError(`Anthropic bridge constraint violated: tool result ${toolCallId} has no matching tool call`, {
+                    code: 'TOOL_PROTOCOL_ERROR',
+                    protocol: 'anthropic-messages',
+                    providerType: 'anthropic',
+                    details: { toolCallId }
+                });
             }
             const block = {
                 type: 'tool_result',

package/dist/conversion/shared/errors.d.ts

@@ -0,0 +1,20 @@
+export type ProviderProtocolErrorCode = 'TOOL_PROTOCOL_ERROR' | 'SSE_DECODE_ERROR' | 'MALFORMED_RESPONSE' | 'MALFORMED_REQUEST';
+export type ProviderErrorCategory = 'EXTERNAL_ERROR' | 'TOOL_ERROR' | 'INTERNAL_ERROR';
+export interface ProviderProtocolErrorOptions {
+    code: ProviderProtocolErrorCode;
+    protocol?: string;
+    providerType?: string;
+    /**
+     * 粗粒度错误类别；若未显式指定，将基于 code 自动推导。
+     */
+    category?: ProviderErrorCategory;
+    details?: Record<string, unknown>;
+}
+export declare class ProviderProtocolError extends Error {
+    readonly code: ProviderProtocolErrorCode;
+    readonly protocol?: string;
+    readonly providerType?: string;
+    readonly category: ProviderErrorCategory;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, options: ProviderProtocolErrorOptions);
+}

package/dist/conversion/shared/errors.js

@@ -0,0 +1,28 @@
+function inferCategoryFromCode(code) {
+    switch (code) {
+        case 'TOOL_PROTOCOL_ERROR':
+            return 'TOOL_ERROR';
+        case 'SSE_DECODE_ERROR':
+        case 'MALFORMED_RESPONSE':
+        case 'MALFORMED_REQUEST':
+        default:
+            // 默认视为外部协议/载荷问题；真正的内部错误由上层使用 INTERNAL_ERROR 显式标记。
+            return 'EXTERNAL_ERROR';
+    }
+}
+export class ProviderProtocolError extends Error {
+    code;
+    protocol;
+    providerType;
+    category;
+    details;
+    constructor(message, options) {
+        super(message);
+        this.name = 'ProviderProtocolError';
+        this.code = options.code;
+        this.protocol = options.protocol;
+        this.providerType = options.providerType;
+        this.category = options.category ?? inferCategoryFromCode(options.code);
+        this.details = options.details;
+    }
+}

package/dist/conversion/shared/responses-conversation-store.js

@@ -1,3 +1,4 @@
+import { ProviderProtocolError } from './errors.js';
 const TTL_MS = 1000 * 60 * 30; // 30min
 function cloneDeep(value) {
     try {
@@ -205,16 +206,42 @@ class ResponsesConversationStore {
     }
     resumeConversation(responseId, submitPayload, options) {
         if (typeof responseId !== 'string' || !responseId.trim()) {
-            throw new Error('Responses conversation requires valid response_id');
+            throw new ProviderProtocolError('Responses conversation requires valid response_id', {
+                code: 'MALFORMED_REQUEST',
+                protocol: 'openai-responses',
+                providerType: 'responses',
+                details: {
+                    context: 'responses-conversation-store.resumeConversation',
+                    reason: 'missing_or_empty_response_id'
+                }
+            });
         }
         this.prune();
         const entry = this.responseIndex.get(responseId);
         if (!entry) {
-            throw new Error('Responses conversation expired or not found');
+            throw new ProviderProtocolError('Responses conversation expired or not found', {
+                code: 'MALFORMED_REQUEST',
+                protocol: 'openai-responses',
+                providerType: 'responses',
+                details: {
+                    context: 'responses-conversation-store.resumeConversation',
+                    reason: 'expired_or_unknown_response_id',
+                    responseId
+                }
+            });
         }
         const toolOutputs = Array.isArray(submitPayload.tool_outputs) ? submitPayload.tool_outputs : [];
         if (!toolOutputs.length) {
-            throw new Error('tool_outputs array is required when submitting Responses tool results');
+            throw new ProviderProtocolError('tool_outputs array is required when submitting Responses tool results', {
+                code: 'MALFORMED_REQUEST',
+                protocol: 'openai-responses',
+                providerType: 'responses',
+                details: {
+                    context: 'responses-conversation-store.resumeConversation',
+                    reason: 'missing_tool_outputs',
+                    responseId
+                }
+            });
         }
         const mergedInput = coerceInputArray(entry.input);
         const normalizedOutputs = normalizeSubmittedToolOutputs(toolOutputs);

package/dist/conversion/shared/responses-output-builder.js

@@ -177,6 +177,47 @@ function normalizeUsage(usageRaw) {
     }
     return usageRaw;
 }
+function extractApplyPatchArguments(rawArgs) {
+    // Upstream Responses providers may wrap apply_patch arguments in a JSON object
+    // (e.g. { patch: '*** Begin Patch...', input: '...' }). For Codex, the tool
+    // expects a FREEFORM patch string obeying the unified diff grammar. Here we
+    // best-effort extract such a patch string when available.
+    const tryExtractFromObject = (obj) => {
+        if (!obj || typeof obj !== 'object' || Array.isArray(obj))
+            return null;
+        const record = obj;
+        const candidates = ['patch', 'input'];
+        for (const key of candidates) {
+            const value = record[key];
+            if (typeof value !== 'string')
+                continue;
+            const trimmed = value.trimStart();
+            if (trimmed.startsWith('*** Begin Patch')) {
+                return trimmed;
+            }
+        }
+        return null;
+    };
+    if (typeof rawArgs === 'string') {
+        const trimmed = rawArgs.trimStart();
+        if (trimmed.startsWith('*** Begin Patch')) {
+            return trimmed;
+        }
+        try {
+            const parsed = JSON.parse(rawArgs);
+            const fromObject = tryExtractFromObject(parsed);
+            if (fromObject) {
+                return fromObject;
+            }
+        }
+        catch {
+            // non-JSON string that is not a patch header; leave to caller
+        }
+        return null;
+    }
+    const fromObject = tryExtractFromObject(rawArgs);
+    return fromObject;
+}
 function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, baseCount, offset) {
     try {
         const fn = call?.function || {};
@@ -187,16 +228,37 @@ function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, b
         if (!sanitized || sanitized.toLowerCase() === 'tool')
             return null;
         const rawArgs = fn?.arguments ?? call.arguments ?? {};
-        const argsStr = typeof rawArgs === 'string'
-            ? rawArgs
-            : (() => {
+        let argsStr;
+        if (sanitized === 'apply_patch') {
+            const patch = extractApplyPatchArguments(rawArgs);
+            if (patch != null) {
+                argsStr = patch;
+            }
+            else if (typeof rawArgs === 'string') {
+                argsStr = rawArgs;
+            }
+            else {
                 try {
-                    return JSON.stringify(rawArgs ?? {});
+                    argsStr = JSON.stringify(rawArgs ?? {});
                 }
                 catch {
-                    return '{}';
+                    argsStr = '{}';
                 }
-            })();
+            }
+        }
+        else {
+            argsStr =
+                typeof rawArgs === 'string'
+                    ? rawArgs
+                    : (() => {
+                        try {
+                            return JSON.stringify(rawArgs ?? {});
+                        }
+                        catch {
+                            return '{}';
+                        }
+                    })();
+        }
         const originalCallId = typeof call.id === 'string' && call.id.trim().length
             ? String(call.id)
             : (typeof call.call_id === 'string' && call.call_id.trim().length ? String(call.call_id) : undefined);

package/dist/filters/special/request-toolcalls-stringify.d.ts

@@ -0,0 +1,13 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+/**
+ * Ensure assistant.tool_calls[].function.arguments is a JSON string containing valid JSON.
+ * - If arguments is not a string, JSON.stringify it.
+ * - If arguments is a string but not parseable as JSON, wrap it into a JSON object so the
+ *   provider always receives syntactically valid JSON (e.g. {"input": "<raw>"}).
+ * Also set assistant.content=null when tool_calls exist (request-side invariant).
+ */
+export declare class RequestToolCallsStringifyFilter implements Filter<JsonObject> {
+    readonly name = "request_toolcalls_stringify";
+    readonly stage: FilterContext['stage'];
+    apply(input: JsonObject): FilterResult<JsonObject>;
+}

package/dist/filters/special/request-toolcalls-stringify.js

@@ -1,5 +1,8 @@
 /**
- * Ensure assistant.tool_calls[].function.arguments is a JSON string.
+ * Ensure assistant.tool_calls[].function.arguments is a JSON string containing valid JSON.
+ * - If arguments is not a string, JSON.stringify it.
+ * - If arguments is a string but not parseable as JSON, wrap it into a JSON object so the
+ *   provider always receives syntactically valid JSON (e.g. {"input": "<raw>"}).
  * Also set assistant.content=null when tool_calls exist (request-side invariant).
  */
 export class RequestToolCallsStringifyFilter {
@@ -18,14 +21,111 @@ export class RequestToolCallsStringifyFilter {
                             if (!tc || typeof tc !== 'object')
                                 continue;
                             const fn = tc.function || {};
-                            if (fn && typeof fn === 'object' && fn.arguments !== undefined && typeof fn.arguments !== 'string') {
+                            if (!fn || typeof fn !== 'object')
+                                continue;
+                            const currentArgs = fn.arguments;
+                            const fnName = typeof fn.name === 'string' ? fn.name.trim() : '';
+                            // Case 1: non-string arguments → stringify directly
+                            if (currentArgs !== undefined && typeof currentArgs !== 'string') {
                                 try {
-                                    fn.arguments = JSON.stringify(fn.arguments ?? {});
+                                    fn.arguments = JSON.stringify(currentArgs ?? {});
                                 }
                                 catch {
                                     fn.arguments = '{}';
                                 }
                                 tc.function = fn;
+                                continue;
+                            }
+                            // Case 2: string arguments → ensure it is valid JSON
+                            if (typeof currentArgs === 'string') {
+                                const trimmed = currentArgs.trim();
+                                if (trimmed.length === 0) {
+                                    fn.arguments = '{}';
+                                    tc.function = fn;
+                                    continue;
+                                }
+                                let parsedOk = false;
+                                let parsedValue = undefined;
+                                try {
+                                    parsedValue = JSON.parse(trimmed);
+                                    parsedOk = true;
+                                }
+                                catch {
+                                    parsedOk = false;
+                                }
+                                if (!parsedOk) {
+                                    // Wrap raw string into a JSON object to keep payload syntactically valid.
+                                    // For shell, align with GLM/统一工具治理约定，优先映射到 { command }，
+                                    // 其余模型仍使用 { input } 形式。
+                                    try {
+                                        if (fnName === 'shell') {
+                                            fn.arguments = JSON.stringify({ command: currentArgs });
+                                        }
+                                        else if (fnName === 'apply_patch') {
+                                            fn.arguments = JSON.stringify({ patch: currentArgs });
+                                        }
+                                        else {
+                                            fn.arguments = JSON.stringify({ input: currentArgs });
+                                        }
+                                    }
+                                    catch {
+                                        fn.arguments = '{}';
+                                    }
+                                    tc.function = fn;
+                                    continue;
+                                }
+                                // 已经是合法 JSON 的场景下，仅对特定工具做形状修复。
+                                if (parsedOk && fnName === 'apply_patch') {
+                                    try {
+                                        let obj = parsedValue;
+                                        // 1) 若整体是字符串，则视为补丁文本
+                                        if (typeof obj === 'string') {
+                                            obj = { patch: obj };
+                                        }
+                                        if (obj && typeof obj === 'object') {
+                                            const container = obj;
+                                            const rawPatch = container.patch;
+                                            const rawInput = container.input;
+                                            // 2) 若 patch 是形如 JSON 的字符串，尝试解包 {"input": "..."} 或 {"patch": "..."}
+                                            if (typeof rawPatch === 'string') {
+                                                const ptrim = rawPatch.trim();
+                                                if (ptrim.startsWith('{') && ptrim.endsWith('}')) {
+                                                    try {
+                                                        const inner = JSON.parse(ptrim);
+                                                        if (typeof inner.patch === 'string') {
+                                                            container.patch = inner.patch;
+                                                        }
+                                                        else if (typeof inner.input === 'string') {
+                                                            container.patch = inner.input;
+                                                        }
+                                                        else {
+                                                            container.patch = ptrim;
+                                                        }
+                                                    }
+                                                    catch {
+                                                        container.patch = rawPatch;
+                                                    }
+                                                }
+                                            }
+                                            else if (rawPatch === undefined && typeof rawInput === 'string') {
+                                                // 3) 若只有 input 字段，则复制一份到 patch，避免双层包装
+                                                container.patch = rawInput;
+                                            }
+                                            fn.arguments = JSON.stringify(container);
+                                            tc.function = fn;
+                                            continue;
+                                        }
+                                    }
+                                    catch {
+                                        // 回退到原始字符串形状
+                                        fn.arguments = trimmed;
+                                        tc.function = fn;
+                                        continue;
+                                    }
+                                }
+                                // 其它合法 JSON 场景保持原样
+                                fn.arguments = trimmed;
+                                tc.function = fn;
                             }
                         }
                     }

package/dist/filters/special/response-tool-text-canonicalize.d.ts

@@ -0,0 +1,16 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+/**
+ * Canonicalize assistant textual tool markup into tool_calls (Chat path).
+ *
+ * 行为分两步：
+ * 1. 使用 text-markup-normalizer 将纯文本中的工具标记（含 apply_patch）提升为 tool_calls；
+ * 2. 再通过 canonicalizeChatResponseTools 统一 tool_calls 形态（content=null、arguments 为字符串等）。
+ *
+ * 这样可以保证：无论上游 provider 是哪种协议，只要在文本中输出符合规范的 apply_patch / shell 等片段，
+ * 在响应侧都会被折叠为标准的 tool_calls，供后续工具治理与客户端透明消费。
+ */
+export declare class ResponseToolTextCanonicalizeFilter implements Filter<JsonObject> {
+    readonly name = "response_tool_text_canonicalize";
+    readonly stage: FilterContext['stage'];
+    apply(input: JsonObject): FilterResult<JsonObject>;
+}

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

@@ -1,16 +1,40 @@
 /**
  * Canonicalize assistant textual tool markup into tool_calls (Chat path).
- * Wrapper around existing canonicalizer to fit the Filter pipeline.
+ *
+ * 行为分两步：
+ * 1. 使用 text-markup-normalizer 将纯文本中的工具标记（含 apply_patch）提升为 tool_calls；
+ * 2. 再通过 canonicalizeChatResponseTools 统一 tool_calls 形态（content=null、arguments 为字符串等）。
+ *
+ * 这样可以保证：无论上游 provider 是哪种协议，只要在文本中输出符合规范的 apply_patch / shell 等片段，
+ * 在响应侧都会被折叠为标准的 tool_calls，供后续工具治理与客户端透明消费。
  */
 export class ResponseToolTextCanonicalizeFilter {
     name = 'response_tool_text_canonicalize';
     stage = 'response_pre';
     apply(input) {
         try {
-            // Defer to existing canonicalizer for behavior parity
             // eslint-disable-next-line @typescript-eslint/no-var-requires
             const { canonicalizeChatResponseTools } = require('../../conversion/shared/tool-canonicalizer.js');
-            const out = canonicalizeChatResponseTools(input);
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { normalizeAssistantTextToToolCalls } = require('../../conversion/shared/text-markup-normalizer.js');
+            // 先在文本层面抽取工具调用（apply_patch / shell / MCP 等）
+            let working = input && typeof input === 'object' ? JSON.parse(JSON.stringify(input)) : input;
+            try {
+                const choices = Array.isArray(working?.choices) ? working.choices : [];
+                for (const ch of choices) {
+                    if (!ch || typeof ch !== 'object')
+                        continue;
+                    const msg = ch.message;
+                    if (msg && typeof msg === 'object') {
+                        ch.message = normalizeAssistantTextToToolCalls(msg);
+                    }
+                }
+                working.choices = choices;
+            }
+            catch {
+                // best-effort：文本解析失败时保留原始 payload
+            }
+            const out = canonicalizeChatResponseTools(working);
             return { ok: true, data: out };
         }
         catch {

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

@@ -17,8 +17,6 @@ export class RoutingClassifier {
         const thinkingContinuation = lastToolCategory === 'read';
         const searchContinuation = lastToolCategory === 'search';
         const toolsContinuation = lastToolCategory === 'other';
-        // 用户输入优先级最高(仅次于 vision),确保每次新的用户输入都走 thinking 路由进行工具检查
-        // thinking_continuation 用于区分"工具轮次中的 read 类调用"与"用户新输入"
         const evaluationMap = {
             vision: {
                 triggered: features.hasImageAttachment,
@@ -40,6 +38,10 @@ export class RoutingClassifier {
                 triggered: thinkingContinuation,
                 reason: 'thinking:last-tool-read'
             },
+            search: {
+                triggered: searchContinuation,
+                reason: 'search:last-tool-search'
+            },
             tools: {
                 triggered: toolsContinuation || features.hasTools || features.hasToolCallResponses,
                 reason: toolsContinuation ? 'tools:last-tool-other' : 'tools:tool-request-detected'

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

@@ -13,6 +13,7 @@ export declare class VirtualRouterEngine {
     private healthConfig;
     private readonly statsCenter;
     private webSearchForce;
+    private routingInstructionState;
     initialize(config: VirtualRouterConfig): void;
     route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {
         target: TargetMetadata;
@@ -43,6 +44,33 @@ export declare class VirtualRouterEngine {
     private buildContextCandidatePools;
     private describeAttempt;
     private resolveStickyKey;
+    private resolveSessionScope;
+    private getRoutingInstructionState;
+    private buildMetadataInstructions;
+    private parseMetadataDisableDescriptor;
+    private resolveRoutingMode;
+    private resolveInstructionTarget;
+    private filterCandidatesByRoutingState;
+    private selectFromCandidates;
+    private extractProviderId;
+    /**
+     * 在已有候选路由集合上，筛选出真正挂载了 sticky 池内 providerKey 的路由，
+     * 并按 ROUTE_PRIORITY 进行排序；同时显式排除 tools 路由，保证一旦进入
+     * sticky 模式，就不会再命中独立的 tools 池（例如 glm/qwen 工具模型）。
+     * 若候选集合中完全没有挂载 sticky key 的路由，则尝试在 default 路由上兜底。
+     */
+    private buildStickyRouteCandidatesFromFiltered;
+    /**
+     * 在 sticky 模式下，仅在 sticky 池内选择 Provider：
+     * - stickyKeySet 表示已经解析并通过健康检查的 providerKey 集合；
+     * - 不再依赖 routing[*].targets 中是否挂载这些 key，避免「未初始化路由池」导致 sticky 池为空；
+     * - 仍然尊重 allowed/disabledProviders、disabledKeys、disabledModels 以及上下文长度。
+     */
+    private selectFromStickyPool;
+    private extractKeyAlias;
+    private normalizeAliasDescriptor;
+    private extractKeyIndex;
+    private getProviderModelId;
     private mapProviderError;
     private deriveReason;
     private buildRouteCandidates;
@@ -56,6 +84,8 @@ export declare class VirtualRouterEngine {
     private sortRoutePools;
     private flattenPoolTargets;
     private buildHitReason;
+    private isRoutingStateEmpty;
+    private persistRoutingInstructionState;
     private decorateWithDetail;
     private formatVirtualRouterHit;
     private resolveRouteColor;