@jsonstudio/rcc 0.89.552 → 0.89.611

package/node_modules/@jsonstudio/llms/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/node_modules/@jsonstudio/llms/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/node_modules/@jsonstudio/llms/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/node_modules/@jsonstudio/llms/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/node_modules/@jsonstudio/llms/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/node_modules/@jsonstudio/llms/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/node_modules/@jsonstudio/llms/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;