@jsonstudio/llms 0.6.230 → 0.6.467

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

@@ -111,6 +111,7 @@ function applyLocalToolGovernance(chatRequest, rawPayload) {
     }
     const hasImageHint = detectImageHint(messages, rawPayload);
     if (hasImageHint) {
+        // 有图片线索时不干预工具列表，保持由上游（Codex 等）决定 view_image 的暴露与使用。
         return chatRequest;
     }
     const filteredTools = tools.filter((tool) => {

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/bootstrap.js

@@ -27,7 +27,7 @@ export function bootstrapVirtualRouterConfig(input) {
     if (!Object.keys(routingSource).length) {
         throw new VirtualRouterError('Virtual Router routing table cannot be empty', VirtualRouterErrorCode.CONFIG_ERROR);
     }
-    const webSearch = normalizeWebSearch(section.webSearch);
+    const webSearch = normalizeWebSearch(section.webSearch, routingSource);
     validateWebSearchRouting(webSearch, routingSource);
     const { runtimeEntries, aliasIndex } = buildProviderRuntimeEntries(providersSource);
     const { routing, targetKeys } = expandRoutingTable(routingSource, aliasIndex);
@@ -121,7 +121,8 @@ function buildProviderRuntimeEntries(providers) {
                 streaming: normalizedProvider.streaming,
                 modelStreaming: normalizedProvider.modelStreaming,
                 modelContextTokens: normalizedProvider.modelContextTokens,
-                defaultContextTokens: normalizedProvider.defaultContextTokens
+                defaultContextTokens: normalizedProvider.defaultContextTokens,
+                ...(normalizedProvider.serverToolsDisabled ? { serverToolsDisabled: true } : {})
             };
         }
     }
@@ -158,7 +159,8 @@ function expandRoutingTable(routingSource, aliasIndex) {
                     id: pool.id,
                     priority: pool.priority,
                     backup: pool.backup,
-                    targets: expandedTargets
+                    targets: expandedTargets,
+                    ...(pool.force ? { force: true } : {})
                 });
             }
         }
@@ -194,7 +196,8 @@ function buildProviderProfiles(targetKeys, runtimeEntries) {
             processMode: runtime.processMode || 'chat',
             responsesConfig: runtime.responsesConfig,
             streaming: streamingPref,
-            maxContextTokens: contextTokens
+            maxContextTokens: contextTokens,
+            ...(runtime.serverToolsDisabled ? { serverToolsDisabled: true } : {})
         };
         targetRuntime[targetKey] = {
             ...runtime,
@@ -274,12 +277,15 @@ function normalizeRoutePoolEntry(routeName, entry, index, total) {
         (typeof record.type === 'string' && record.type.toLowerCase() === 'backup');
     const priority = normalizePriorityValue(record.priority, total - index);
     const targets = normalizeRouteTargets(record);
+    const force = record.force === true ||
+        (typeof record.force === 'string' && record.force.trim().toLowerCase() === 'true');
     return targets.length
         ? {
             id,
             priority,
             backup,
-            targets
+            targets,
+            ...(force ? { force: true } : {})
         }
         : null;
 }
@@ -386,6 +392,12 @@ function normalizeProvider(providerId, raw) {
     const streaming = resolveProviderStreamingPreference(provider, responsesNode);
     const modelStreaming = normalizeModelStreaming(provider);
     const { modelContextTokens, defaultContextTokens } = normalizeModelContextTokens(provider);
+    const serverToolsDisabled = provider.serverToolsDisabled === true ||
+        (typeof provider.serverToolsDisabled === 'string' &&
+            provider.serverToolsDisabled.trim().toLowerCase() === 'true') ||
+        (provider.serverTools &&
+            typeof provider.serverTools === 'object' &&
+            provider.serverTools.enabled === false);
     return {
         providerId,
         providerType,
@@ -398,7 +410,8 @@ function normalizeProvider(providerId, raw) {
         streaming,
         modelStreaming,
         modelContextTokens,
-        defaultContextTokens
+        defaultContextTokens,
+        ...(serverToolsDisabled ? { serverToolsDisabled: true } : {})
     };
 }
 function normalizeModelStreaming(provider) {
@@ -539,9 +552,9 @@ function validateWebSearchRouting(webSearch, routingSource) {
     if (!webSearch) {
         return;
     }
-    const routePools = routingSource['web_search'];
+    const routePools = routingSource['web_search'] ?? routingSource['search'];
     if (!Array.isArray(routePools) || !routePools.length) {
-        throw new VirtualRouterError('Virtual Router webSearch.engines configured but routing.web_search route is missing or empty', VirtualRouterErrorCode.CONFIG_ERROR);
+        throw new VirtualRouterError('Virtual Router webSearch.engines configured but routing.web_search (or search) route is missing or empty', VirtualRouterErrorCode.CONFIG_ERROR);
     }
     const targets = new Set();
     for (const pool of routePools) {
@@ -556,11 +569,11 @@ function validateWebSearchRouting(webSearch, routingSource) {
     }
     for (const engine of webSearch.engines) {
         if (!targets.has(engine.providerKey)) {
-            throw new VirtualRouterError(`Virtual Router webSearch engine "${engine.id}" references providerKey "${engine.providerKey}" which is not present in routing.web_search`, VirtualRouterErrorCode.CONFIG_ERROR);
+            throw new VirtualRouterError(`Virtual Router webSearch engine "${engine.id}" references providerKey "${engine.providerKey}" which is not present in routing.web_search/search`, VirtualRouterErrorCode.CONFIG_ERROR);
         }
     }
 }
-function normalizeWebSearch(input) {
+function normalizeWebSearch(input, routingSource) {
     if (!input || typeof input !== 'object') {
         return undefined;
     }
@@ -588,6 +601,12 @@ function normalizeWebSearch(input) {
             : undefined;
         const isDefault = node.default === true ||
             (typeof node.default === 'string' && node.default.trim().toLowerCase() === 'true');
+        const serverToolsDisabled = node.serverToolsDisabled === true ||
+            (typeof node.serverToolsDisabled === 'string' &&
+                node.serverToolsDisabled.trim().toLowerCase() === 'true') ||
+            (node.serverTools &&
+                typeof node.serverTools === 'object' &&
+                node.serverTools.enabled === false);
         // Deduplicate by id; first wins, subsequent are ignored.
         if (engines.some((engine) => engine.id === id)) {
             continue;
@@ -596,13 +615,15 @@ function normalizeWebSearch(input) {
             id,
             providerKey,
             description,
-            default: isDefault
+            default: isDefault,
+            ...(serverToolsDisabled ? { serverToolsDisabled: true } : {})
         });
     }
     if (!engines.length) {
         return undefined;
     }
     let injectPolicy;
+    let force;
     const rawPolicy = record.injectPolicy ?? record?.inject_policy;
     if (typeof rawPolicy === 'string') {
         const normalized = rawPolicy.trim().toLowerCase();
@@ -610,9 +631,20 @@ function normalizeWebSearch(input) {
             injectPolicy = normalized;
         }
     }
+    if (record.force === true ||
+        (typeof record.force === 'string' && record.force.trim().toLowerCase() === 'true')) {
+        force = true;
+    }
+    else {
+        const webSearchPools = routingSource['web_search'] ?? routingSource['search'] ?? [];
+        if (Array.isArray(webSearchPools) && webSearchPools.some((pool) => pool.force)) {
+            force = true;
+        }
+    }
     return {
         engines,
-        injectPolicy: injectPolicy ?? 'selective'
+        injectPolicy: injectPolicy ?? 'selective',
+        ...(force ? { force } : {})
     };
 }
 function extractProviderAuthEntries(providerId, raw) {

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

@@ -17,34 +17,30 @@ export class RoutingClassifier {
         const thinkingContinuation = lastToolCategory === 'read';
         const searchContinuation = lastToolCategory === 'search';
         const toolsContinuation = lastToolCategory === 'other';
-        if (latestMessageFromUser) {
-            const reasoning = 'thinking:user-input';
-            const evaluations = {
-                thinking: { triggered: true, reason: reasoning }
-            };
-            const candidates = this.ensureDefaultCandidate(['thinking']);
-            return this.buildResult('thinking', reasoning, evaluations, candidates);
-        }
         const evaluationMap = {
             vision: {
-                triggered: features.hasVisionTool && features.hasImageAttachment,
-                reason: 'vision:requires-tool+image'
+                triggered: features.hasImageAttachment,
+                reason: 'vision:image-detected'
+            },
+            thinking: {
+                triggered: latestMessageFromUser,
+                reason: 'thinking:user-input'
             },
             longcontext: {
                 triggered: reachedLongContext,
                 reason: 'longcontext:token-threshold'
             },
-            websearch: {
-                triggered: features.hasWebTool || searchContinuation,
-                reason: searchContinuation ? 'websearch:last-tool-search' : 'websearch:web-tools-detected'
-            },
             coding: {
                 triggered: codingContinuation,
                 reason: 'coding:last-tool-write'
             },
-            thinking: {
-                triggered: thinkingContinuation || latestMessageFromUser,
-                reason: thinkingContinuation ? 'thinking:last-tool-read' : 'thinking:user-input'
+            thinking_continuation: {
+                triggered: thinkingContinuation,
+                reason: 'thinking:last-tool-read'
+            },
+            search: {
+                triggered: searchContinuation,
+                reason: 'search:last-tool-search'
             },
             tools: {
                 triggered: toolsContinuation || features.hasTools || features.hasToolCallResponses,

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

@@ -12,6 +12,8 @@ export declare class VirtualRouterEngine {
     private readonly debug;
     private healthConfig;
     private readonly statsCenter;
+    private webSearchForce;
+    private routingInstructionState;
     initialize(config: VirtualRouterConfig): void;
     route(request: StandardizedRequest | ProcessedRequest, metadata: RouterMetadataInput): {
         target: TargetMetadata;
@@ -28,6 +30,11 @@ export declare class VirtualRouterEngine {
         }>;
         health: import("./types.js").ProviderHealthState[];
     };
+    /**
+     * 将分类器产生的逻辑路由名直接归一化为配置中的路由键。
+     * 不再维护 "websearch" 之类的别名，调用方应显式使用 "web_search" 或 "search" 等实际路由名。
+     */
+    private normalizeRouteAlias;
     private validateConfig;
     private selectProvider;
     private trySelectFromTier;
@@ -37,16 +44,48 @@ 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;
+    private reorderForInlineVision;
+    private routeSupportsInlineVision;
     private sortByPriority;
     private routeWeight;
+    private routeHasForceFlag;
     private routeHasTargets;
     private hasPrimaryPool;
     private sortRoutePools;
     private flattenPoolTargets;
     private buildHitReason;
+    private isRoutingStateEmpty;
+    private persistRoutingInstructionState;
     private decorateWithDetail;
     private formatVirtualRouterHit;
     private resolveRouteColor;