@jsonstudio/llms 0.6.473 → 0.6.568

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

@@ -1,3 +1,4 @@
+import { appendApplyPatchReminder, buildShellDescription, hasApplyPatchToolDeclared, isShellToolName, normalizeToolName } from '../../tools/tool-description-utils.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -31,6 +32,7 @@ export class RequestOpenAIToolsNormalizeFilter {
             const toonEnv = String(process?.env?.RCC_TOON_ENABLE || process?.env?.ROUTECODEX_TOON_ENABLE || '').toLowerCase();
             const toonEnabled = toonEnv ? !(toonEnv === '0' || toonEnv === 'false' || toonEnv === 'off') : true; // default ON
             const tools = Array.isArray(out.tools) ? out.tools : [];
+            const hasApplyPatchTool = hasApplyPatchToolDeclared(tools);
             if (!tools.length) {
                 // No tools present: drop tool_choice to avoid provider-side validation errors
                 try {
@@ -75,19 +77,25 @@ export class RequestOpenAIToolsNormalizeFilter {
                     catch { /* ignore */ }
                     // Switch schema for specific built-in tools at unified shaping point
                     try {
-                        const name = String(dst.function.name || '').toLowerCase();
-                        if (name === 'shell') {
+                        const rawToolName = String(dst.function.name || '');
+                        const isShell = isShellToolName(rawToolName);
+                        const isApplyPatch = normalizeToolName(rawToolName) === 'apply_patch';
+                        if (isShell) {
                             const wantToon = toonEnabled && !looksHeredoc;
                             if (wantToon) {
                                 dst.function.parameters = {
                                     type: 'object',
                                     properties: {
-                                        toon: { type: 'string', description: 'TOON-encoded arguments (multi-line key: value). Example: command: bash -lc "echo ok"\\nworkdir: .' }
+                                        toon: {
+                                            type: 'string',
+                                            description: 'TOON-encoded arguments (multi-line key: value). Example: command: bash -lc "echo ok"\\nworkdir: .'
+                                        }
                                     },
                                     required: ['toon'],
                                     additionalProperties: false
                                 };
-                                dst.function.description = 'Use TOON: put arguments into arguments.toon as multi-line key: value (e.g., command / workdir).';
+                                const toonDescription = 'Use TOON: put arguments into arguments.toon as multi-line key: value (e.g., command / workdir).';
+                                dst.function.description = appendApplyPatchReminder(toonDescription, hasApplyPatchTool);
                             }
                             else {
                                 dst.function.parameters = {
@@ -99,27 +107,10 @@ export class RequestOpenAIToolsNormalizeFilter {
                                     required: ['command'],
                                     additionalProperties: false
                                 };
+                                const label = rawToolName && rawToolName.trim().length > 0 ? rawToolName.trim() : 'shell';
+                                dst.function.description = buildShellDescription(label, hasApplyPatchTool);
                             }
                         }
-                        else if (name === 'apply_patch') {
-                            dst.function.parameters = {
-                                type: 'object',
-                                properties: {
-                                    input: {
-                                        type: 'string',
-                                        description: 'Unified diff patch body between *** Begin Patch/*** End Patch.'
-                                    },
-                                    patch: {
-                                        type: 'string',
-                                        description: 'Alias of input for backwards compatibility.'
-                                    }
-                                },
-                                required: ['input'],
-                                additionalProperties: false
-                            };
-                            dst.function.description =
-                                'Use apply_patch to edit files. Provide the diff via the input field (*** Begin Patch ... *** End Patch).';
-                        }
                     }
                     catch { /* ignore */ }
                     finalTools.push(dst);

package/dist/filters/special/response-apply-patch-toon-decode.d.ts

@@ -0,0 +1,23 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+/**
+ * Response-side apply_patch arguments 规范化（TOON + 结构化 JSON → 统一 diff 文本）。
+ *
+ * 目标：
+ * - 对上游模型：仍然可以使用结构化 JSON（changes 数组）或 toon 字段输出补丁；
+ * - 对下游客户端（Codex CLI 等）：始终看到 { input, patch } 形式的统一 diff 文本，
+ *   与本地 apply_patch 工具的旧语义完全一致（对客户端透明）。
+ *
+ * 支持两种入参形态（arguments 反序列化后）：
+ * 1) { toon: "<*** Begin Patch ... *** End Patch>" }
+ * 2) StructuredApplyPatchPayload（含 changes 数组等字段）
+ *
+ * 输出：
+ * - arguments 统一替换为 JSON 字符串：{ input: patchText, patch: patchText }。
+ *
+ * Stage: response_pre（在 arguments stringify 之前运行）。
+ */
+export declare class ResponseApplyPatchToonDecodeFilter implements Filter<JsonObject> {
+    readonly name = "response_apply_patch_toon_decode";
+    readonly stage: FilterContext['stage'];
+    apply(input: JsonObject): FilterResult<JsonObject>;
+}

package/dist/filters/special/response-apply-patch-toon-decode.js

@@ -0,0 +1,109 @@
+import { buildStructuredPatch, isStructuredApplyPatchPayload, StructuredApplyPatchError } from '../../tools/apply-patch-structured.js';
+function envEnabled() {
+    const v = String(process?.env?.RCC_TOON_ENABLE ||
+        process?.env?.ROUTECODEX_TOON_ENABLE ||
+        '').toLowerCase();
+    if (!v)
+        return true;
+    return !(v === '0' || v === 'false' || v === 'off');
+}
+function isObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+/**
+ * Response-side apply_patch arguments 规范化（TOON + 结构化 JSON → 统一 diff 文本）。
+ *
+ * 目标：
+ * - 对上游模型：仍然可以使用结构化 JSON（changes 数组）或 toon 字段输出补丁；
+ * - 对下游客户端（Codex CLI 等）：始终看到 { input, patch } 形式的统一 diff 文本，
+ *   与本地 apply_patch 工具的旧语义完全一致（对客户端透明）。
+ *
+ * 支持两种入参形态（arguments 反序列化后）：
+ * 1) { toon: "<*** Begin Patch ... *** End Patch>" }
+ * 2) StructuredApplyPatchPayload（含 changes 数组等字段）
+ *
+ * 输出：
+ * - arguments 统一替换为 JSON 字符串：{ input: patchText, patch: patchText }。
+ *
+ * Stage: response_pre（在 arguments stringify 之前运行）。
+ */
+export class ResponseApplyPatchToonDecodeFilter {
+    name = 'response_apply_patch_toon_decode';
+    stage = 'response_pre';
+    apply(input) {
+        if (!envEnabled())
+            return { ok: true, data: input };
+        try {
+            const out = JSON.parse(JSON.stringify(input || {}));
+            const choices = Array.isArray(out.choices) ? out.choices : [];
+            for (const ch of choices) {
+                const msg = ch && ch.message ? ch.message : undefined;
+                const tcs = msg && Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+                for (const tc of tcs) {
+                    try {
+                        const fn = tc && tc.function ? tc.function : undefined;
+                        if (!fn || typeof fn !== 'object')
+                            continue;
+                        const nameRaw = fn.name;
+                        if (typeof nameRaw !== 'string' || nameRaw.trim().toLowerCase() !== 'apply_patch') {
+                            continue;
+                        }
+                        const argStr = fn.arguments;
+                        if (typeof argStr !== 'string' || !argStr.trim())
+                            continue;
+                        let parsed;
+                        try {
+                            parsed = JSON.parse(argStr);
+                        }
+                        catch {
+                            // 如果 arguments 不是 JSON 字符串，则保持原样交给下游处理
+                            continue;
+                        }
+                        if (!isObject(parsed))
+                            continue;
+                        // 优先处理 toon: "<patch text>" 形态（兼容旧 TOON 协议）
+                        const toon = parsed.toon;
+                        let patchText;
+                        if (typeof toon === 'string' && toon.trim()) {
+                            if (toon.includes('*** Begin Patch') && toon.includes('*** End Patch')) {
+                                patchText = toon;
+                            }
+                        }
+                        // 否则尝试结构化 JSON（changes 数组 → 统一 diff）
+                        if (!patchText && isStructuredApplyPatchPayload(parsed)) {
+                            try {
+                                patchText = buildStructuredPatch(parsed);
+                            }
+                            catch (error) {
+                                if (error instanceof StructuredApplyPatchError) {
+                                    // 结构化 payload 无法构建补丁时，保留原始 arguments，
+                                    // 由下游工具或客户端根据自身策略报错；这里不吞掉错误。
+                                    continue;
+                                }
+                                continue;
+                            }
+                        }
+                        if (!patchText) {
+                            continue;
+                        }
+                        const normalized = { input: patchText, patch: patchText };
+                        try {
+                            fn.arguments = JSON.stringify(normalized);
+                        }
+                        catch {
+                            // stringify 失败时保留原始 arguments
+                        }
+                    }
+                    catch {
+                        // 针对单个 tool_call 的 best-effort，不影响其他工具
+                    }
+                }
+            }
+            out.choices = choices;
+            return { ok: true, data: out };
+        }
+        catch {
+            return { ok: true, data: input };
+        }
+    }
+}

package/dist/filters/special/response-tool-arguments-toon-decode.d.ts

@@ -0,0 +1,10 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+/**
+ * Decode arguments.toon to standard JSON ({command, workdir?}) and map tool name 'shell_toon' → 'shell'.
+ * Stage: response_pre (before arguments stringify and invariants).
+ */
+export declare class ResponseToolArgumentsToonDecodeFilter implements Filter<JsonObject> {
+    readonly name = "response_tool_arguments_toon_decode";
+    readonly stage: FilterContext['stage'];
+    apply(input: JsonObject, ctx: FilterContext): FilterResult<JsonObject>;
+}

package/dist/filters/special/response-tool-arguments-toon-decode.js

@@ -10,18 +10,37 @@ function decodeToonPairs(toon) {
     try {
         const out = {};
         const lines = String(toon).split(/\r?\n/);
+        let currentKey = null;
+        let currentVal = '';
+        const flush = () => {
+            if (currentKey) {
+                out[currentKey] = currentVal;
+            }
+            currentKey = null;
+            currentVal = '';
+        };
         for (const raw of lines) {
             const line = raw.trim();
             if (!line)
                 continue;
             const m = line.match(/^([A-Za-z0-9_\-]+)\s*:\s*(.*)$/);
-            if (!m)
-                return null; // fail fast for non key: value
-            const key = m[1];
-            const val = m[2];
-            out[key] = val;
+            if (m) {
+                // 新的 key: value 行，先提交上一段，再开始累积新 key 的值
+                flush();
+                currentKey = m[1];
+                currentVal = m[2] ?? '';
+            }
+            else {
+                // 非 key: value 行视为上一 key 的续行（例如多行脚本）
+                if (!currentKey) {
+                    // 如果一开始就遇到无法识别的行，认为整个 TOON 不是我们支持的形态
+                    return null;
+                }
+                currentVal += (currentVal ? '\n' : '') + raw;
+            }
         }
-        return out;
+        flush();
+        return Object.keys(out).length ? out : null;
     }
     catch {
         return null;
@@ -34,11 +53,12 @@ function decodeToonPairs(toon) {
 export class ResponseToolArgumentsToonDecodeFilter {
     name = 'response_tool_arguments_toon_decode';
     stage = 'response_pre';
-    apply(input) {
+    apply(input, ctx) {
         if (!envEnabled())
             return { ok: true, data: input };
         try {
             const out = JSON.parse(JSON.stringify(input || {}));
+            const warnings = [];
             const choices = Array.isArray(out.choices) ? out.choices : [];
             for (const ch of choices) {
                 const msg = ch && ch.message ? ch.message : undefined;
@@ -64,14 +84,36 @@ export class ResponseToolArgumentsToonDecodeFilter {
                         if (typeof toon !== 'string' || !toon.trim())
                             continue;
                         const kv = decodeToonPairs(toon);
-                        if (!kv)
+                        if (!kv) {
+                            const preview = toon.split(/\r?\n/).slice(0, 5).join('\n');
+                            const warnMsg = `response_tool_arguments_toon_decode: failed to decode TOON arguments for tool "${fn.name ?? 'unknown'}"`;
+                            warnings.push(warnMsg);
+                            if (ctx?.debug?.emit) {
+                                ctx.debug.emit('tool_toon_decode_error', {
+                                    requestId: ctx.requestId,
+                                    model: ctx.model,
+                                    endpoint: ctx.endpoint,
+                                    stage: ctx.stage,
+                                    provider: ctx.provider,
+                                    toolName: fn.name ?? 'unknown',
+                                    message: warnMsg,
+                                    toonPreview: preview
+                                });
+                            }
                             continue; // keep original if decode fails
-                        const command = kv['command'];
-                        const workdir = kv['workdir'];
+                        }
+                        const command = typeof kv['command'] === 'string' && kv['command'].trim()
+                            ? kv['command']
+                            : (typeof kv['cmd'] === 'string' && kv['cmd'].trim() ? kv['cmd'] : undefined);
+                        const workdir = typeof kv['workdir'] === 'string' && kv['workdir'].trim()
+                            ? kv['workdir']
+                            : (typeof kv['cwd'] === 'string' && kv['cwd'].trim() ? kv['cwd'] : undefined);
                         if (typeof command === 'string' && command.trim()) {
-                            const merged = { command };
-                            if (typeof workdir === 'string' && workdir.trim())
+                            const merged = { cmd: command };
+                            if (typeof workdir === 'string' && workdir.trim()) {
                                 merged.workdir = workdir;
+                            }
+                            merged.command = command;
                             try {
                                 fn.arguments = JSON.stringify(merged);
                             }
@@ -85,7 +127,7 @@ export class ResponseToolArgumentsToonDecodeFilter {
                 }
             }
             out.choices = choices;
-            return { ok: true, data: out };
+            return warnings.length ? { ok: true, data: out, warnings } : { ok: true, data: out };
         }
         catch {
             return { ok: true, data: input };

package/dist/guidance/index.js

@@ -62,27 +62,48 @@ function augmentApplyPatch(fn) {
     const marker = '[Codex ApplyPatch Guidance]';
     const guidance = [
         marker,
-        'Edit files by applying a unified diff patch. Return ONLY the patch text with *** Begin Patch/*** End Patch blocks.',
-        'Paths resolve relative to the active workspace root. Use forward-slash paths (e.g., packages/foo/file.ts) and switch to absolute paths only if you truly need to edit outside the workspace.',
-        '路径一律相对于当前工作区根目录解析；请写 packages/foo/... 这样的相对路径，跨工作区时再使用绝对路径。',
-        'Example:',
-        '*** Begin Patch',
-        '*** Update File: path/to/file.ts',
-        '@@',
-        '- old line',
-        '+ new line',
-        '*** End Patch'
+        'Provide structured edits instead of raw diff text. Always send JSON arguments with a `changes` array.',
+        'Each change describes one operation, e.g. `{ "file": "src/foo.ts", "kind": "insert_after", "anchor": "const foo = 1;", "lines": ["const bar = 2;"] }`.',
+        'Supported kinds: insert_after, insert_before, replace, delete, create_file, delete_file.',
+        'Paths must stay relative to the workspace root (no leading "/" or drive letters).',
+        'Insert operations require `anchor` text; replace/delete require exact `target` snippets; `lines` omit "+/-" prefixes.'
     ].join('\n');
     const params = ensureObjectSchema(fn.parameters);
     const props = params.properties;
-    if (!isObject(props.patch)) {
-        props.patch = { type: 'string', description: 'Unified diff patch text' };
-    }
-    if (!Array.isArray(params.required)) {
-        params.required = [];
-    }
-    if (!params.required.includes('patch')) {
-        params.required.push('patch');
+    props.file = { type: 'string', description: 'Optional default file path (relative) for changes' };
+    props.instructions = { type: 'string', description: 'Optional human-readable summary' };
+    props.changes = {
+        type: 'array',
+        minItems: 1,
+        items: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['kind'],
+            properties: {
+                file: { type: 'string', description: 'Relative path for this change (overrides top-level file)' },
+                kind: {
+                    type: 'string',
+                    description: 'insert_after | insert_before | replace | delete | create_file | delete_file'
+                },
+                anchor: { type: 'string', description: 'Required for insert_before / insert_after' },
+                target: { type: 'string', description: 'Snippet to replace/delete' },
+                lines: {
+                    description: 'New content for insert/replace/create operations',
+                    oneOf: [
+                        { type: 'string' },
+                        { type: 'array', items: { type: 'string' } }
+                    ]
+                },
+                use_anchor_indent: {
+                    type: 'boolean',
+                    description: 'Reapply the indentation of the anchor snippet to inserted lines'
+                }
+            }
+        }
+    };
+    params.required = Array.isArray(params.required) ? params.required : [];
+    if (!params.required.includes('changes')) {
+        params.required.push('changes');
     }
     params.additionalProperties = false;
     fn.parameters = params;
@@ -171,21 +192,44 @@ export function augmentAnthropicTools(tools) {
             const n = name.trim();
             try {
                 if (n === 'apply_patch') {
-                    if (!isObject(schema.properties?.patch)) {
-                        schema.properties.patch = { type: 'string', description: 'Unified diff patch text' };
+                    if (!isObject(schema.properties?.changes)) {
+                        schema.properties.file = { type: 'string', description: 'Optional default file path' };
+                        schema.properties.instructions = { type: 'string', description: 'Optional summary' };
+                        schema.properties.changes = {
+                            type: 'array',
+                            minItems: 1,
+                            items: {
+                                type: 'object',
+                                additionalProperties: false,
+                                required: ['kind'],
+                                properties: {
+                                    file: { type: 'string' },
+                                    kind: { type: 'string' },
+                                    anchor: { type: 'string' },
+                                    target: { type: 'string' },
+                                    lines: {
+                                        oneOf: [
+                                            { type: 'string' },
+                                            { type: 'array', items: { type: 'string' } }
+                                        ]
+                                    },
+                                    use_anchor_indent: { type: 'boolean' }
+                                }
+                            }
+                        };
                     }
                     if (!Array.isArray(schema.required))
                         schema.required = [];
-                    if (!schema.required.includes('patch'))
-                        schema.required.push('patch');
+                    if (!schema.required.includes('changes'))
+                        schema.required.push('changes');
                     schema.additionalProperties = false;
                     copy.input_schema = schema;
                     const marker = '[Codex ApplyPatch Guidance]';
                     const guidance = [
                         marker,
-                        'Use unified diff patch with *** Begin Patch/End Patch. Return only the patch text.',
-                        'All file paths must stay relative to the workspace root; never emit leading \'/\' or drive letters.',
-                        '所有文件路径都必须相对当前工作区根目录，禁止输出以 / 或盘符开头的绝对路径。'
+                        'Provide structured changes (insert_after / insert_before / replace / delete / create_file / delete_file) instead of raw patch text.',
+                        'Each change must include the target file (relative path) plus anchor/target snippets and the replacement lines.',
+                        '所有路径必须相对工作区根目录，禁止输出以 / 或盘符开头的绝对路径。'
                     ].join('\n');
                     copy.description = appendOnce(desc, guidance, marker);
                 }
@@ -220,8 +264,7 @@ export function buildSystemToolGuidance() {
     lines.push(bullet('function.arguments must be a single JSON string. / arguments 必须是单个 JSON 字符串。'));
     lines.push(bullet('shell: Place ALL intent into the command argv array only; do not invent extra keys. / shell 所有意图写入 command 数组，不要添加额外键名。'));
     lines.push(bullet('File writes are FORBIDDEN via shell (no redirection, no here-doc, no sed -i, no ed -s, no tee). Use apply_patch ONLY. / 通过 shell 写文件一律禁止（不得使用重定向、heredoc、sed -i、ed -s、tee）；必须使用 apply_patch。'));
-    lines.push(bullet('apply_patch: Provide a unified diff patch with *** Begin Patch/*** End Patch only, and keep file paths relative to the workspace (no leading / or drive letters). / 仅输出统一 diff 补丁，且文件路径必须是相对路径（禁止以 / 或盘符开头）。'));
-    lines.push(bullet('apply_patch example / 示例：\n*** Begin Patch\n*** Update File: path/to/file.ts\n@@\n- old line\n+ new line\n*** End Patch'));
+    lines.push(bullet('apply_patch: Provide structured JSON arguments with a `changes` array (insert_after / insert_before / replace / delete / create_file / delete_file); omit "+/-" prefixes in `lines`; file paths必须是相对路径。 / apply_patch 仅接受结构化 JSON。'));
     lines.push(bullet('update_plan: Keep exactly one step in_progress; others pending/completed. / 仅一个 in_progress 步骤。'));
     lines.push(bullet('view_image: Path must be an image file (.png .jpg .jpeg .gif .webp .bmp .svg). / 仅图片路径。'));
     lines.push(bullet('Do NOT use view_image for text files (.md/.ts/.js/.json). Use shell: {"command":["cat","<path>"]}. / 文本文件请用 shell: cat。'));

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

@@ -552,9 +552,10 @@ function validateWebSearchRouting(webSearch, routingSource) {
     if (!webSearch) {
         return;
     }
-    const routePools = routingSource['web_search'] ?? routingSource['search'];
+    // webSearch 与 search 路由独立配置：只允许从 routing.web_search 中解析搜索后端。
+    const routePools = routingSource['web_search'];
     if (!Array.isArray(routePools) || !routePools.length) {
-        throw new VirtualRouterError('Virtual Router webSearch.engines configured but routing.web_search (or search) route is missing or empty', VirtualRouterErrorCode.CONFIG_ERROR);
+        throw new VirtualRouterError('Virtual Router webSearch.engines configured but routing.web_search route is missing or empty', VirtualRouterErrorCode.CONFIG_ERROR);
     }
     const targets = new Set();
     for (const pool of routePools) {
@@ -636,7 +637,8 @@ function normalizeWebSearch(input, routingSource) {
         force = true;
     }
     else {
-        const webSearchPools = routingSource['web_search'] ?? routingSource['search'] ?? [];
+        // 仅从 routing.web_search 推导 force 标记，避免与 routing.search 的行为混淆。
+        const webSearchPools = routingSource['web_search'] ?? [];
         if (Array.isArray(webSearchPools) && webSearchPools.some((pool) => pool.force)) {
             force = true;
         }
@@ -777,8 +779,9 @@ function extractProviderAuthEntries(providerId, raw) {
     else if (typeof apiKeyField === 'string' && apiKeyField.trim()) {
         pushEntry(undefined, buildAuthCandidate(baseTypeSource, { value: apiKeyField.trim() }));
     }
+    const hasExplicitEntries = entries.length > 0;
     // 自动多 token 扫描：仅在未显式声明多 key、且为受支持的 OAuth 提供方时触发
-    if (baseType === 'oauth') {
+    if (baseType === 'oauth' && !hasExplicitEntries) {
         const scanCandidates = new Set();
         const pushCandidate = (value) => {
             if (typeof value === 'string' && value.trim()) {
@@ -826,7 +829,8 @@ function extractProviderAuthEntries(providerId, raw) {
             authorizationUrl: readOptionalString(auth?.authorizationUrl ?? auth?.authorization_url ?? auth?.authUrl),
             userInfoUrl: readOptionalString(auth?.userInfoUrl ?? auth?.user_info_url),
             refreshUrl: readOptionalString(auth?.refreshUrl ?? auth?.refresh_url),
-            scopes: normalizeScopeList(auth?.scopes ?? auth?.scope)
+            scopes: normalizeScopeList(auth?.scopes ?? auth?.scope),
+            cookieFile: readOptionalString(auth?.cookieFile)
         };
         const fallbackHasData = Boolean(fallbackExtras.value ||
             fallbackExtras.secretRef ||
@@ -835,6 +839,7 @@ function extractProviderAuthEntries(providerId, raw) {
             fallbackExtras.deviceCodeUrl ||
             fallbackExtras.clientId ||
             fallbackExtras.clientSecret ||
+            fallbackExtras.cookieFile ||
             (fallbackExtras.scopes &&
                 Array.isArray(fallbackExtras.scopes) &&
                 fallbackExtras.scopes.length));

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

@@ -11,12 +11,14 @@ export class RoutingClassifier {
     }
     classify(features) {
         const lastToolCategory = features.lastAssistantToolCategory;
+        const userInterruptsToolContinuation = features.latestMessageFromUser === true && !features.hasTools && !features.hasToolCallResponses;
+        const allowContinuation = !userInterruptsToolContinuation;
         const reachedLongContext = features.estimatedTokens >= (this.config.longContextThresholdTokens ?? DEFAULT_LONG_CONTEXT_THRESHOLD);
         const latestMessageFromUser = features.latestMessageFromUser === true;
-        const codingContinuation = lastToolCategory === 'write';
-        const thinkingContinuation = lastToolCategory === 'read';
-        const searchContinuation = lastToolCategory === 'search';
-        const toolsContinuation = lastToolCategory === 'other';
+        const codingContinuation = allowContinuation && lastToolCategory === 'write';
+        const thinkingContinuation = allowContinuation && lastToolCategory === 'read';
+        const searchContinuation = allowContinuation && lastToolCategory === 'search';
+        const toolsContinuation = allowContinuation && lastToolCategory === 'other';
         const evaluationMap = {
             vision: {
                 triggered: features.hasImageAttachment,
@@ -39,10 +41,13 @@ export class RoutingClassifier {
                 reason: 'thinking:last-tool-read'
             },
             search: {
+                // search 路由：仅在上一轮 assistant 使用 search 类工具时继续命中，
+                // 不因本轮是否声明 web_search 工具而改变路由。
                 triggered: searchContinuation,
                 reason: 'search:last-tool-search'
             },
             tools: {
+                // tools 路由：通用工具分支，包括首次声明的 web/search 工具。
                 triggered: toolsContinuation || features.hasTools || features.hasToolCallResponses,
                 reason: toolsContinuation ? 'tools:last-tool-other' : 'tools:tool-request-detected'
             },

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

@@ -0,0 +1,22 @@
+import { ProviderHealthManager } from './health-manager.js';
+import { ProviderRegistry } from './provider-registry.js';
+import type { ProviderErrorEvent, ProviderFailureEvent, ProviderHealthConfig } from './types.js';
+type DebugLike = {
+    log?: (...args: unknown[]) => void;
+} | Console | undefined;
+export declare function resetRateLimitBackoffForProvider(providerKey: string): void;
+export declare function handleProviderFailureImpl(event: ProviderFailureEvent, healthManager: ProviderHealthManager, healthConfig: Required<ProviderHealthConfig>, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void): void;
+export declare function mapProviderErrorImpl(event: ProviderErrorEvent, healthConfig: Required<ProviderHealthConfig>): ProviderFailureEvent | null;
+export declare function applySeriesCooldownImpl(event: ProviderErrorEvent, providerRegistry: ProviderRegistry, healthManager: ProviderHealthManager, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void, debug?: DebugLike): void;
+/**
+ * 处理来自 Host 侧的配额恢复事件：
+ * - 清除指定 providerKey 在健康管理器中的熔断/冷却状态；
+ * - 清理对应的速率退避计数；
+ * - 调用调用方提供的 clearProviderCooldown 回调移除显式 cooldown TTL。
+ *
+ * 返回值表示是否已处理（true=已处理且后续应跳过常规错误映射逻辑）。
+ */
+export declare function applyQuotaRecoveryImpl(event: ProviderErrorEvent, healthManager: ProviderHealthManager, clearProviderCooldown: (providerKey: string) => void, debug?: DebugLike): boolean;
+export declare function applyQuotaDepletedImpl(event: ProviderErrorEvent, healthManager: ProviderHealthManager, markProviderCooldown: (providerKey: string, cooldownMs: number | undefined) => void, debug?: DebugLike): boolean;
+export declare function deriveReason(code: string, stage: string, statusCode?: number): string;
+export {};