@jsonstudio/llms 0.6.633 → 0.6.749

package/dist/conversion/responses/responses-openai-bridge.js

@@ -154,6 +154,46 @@ function normalizeBridgeHistory(seed) {
         originalSystemMessages: systemMessages
     };
 }
+function stripRoutingTagsFromText(text) {
+    if (typeof text !== 'string') {
+        return typeof text === 'string' ? text : String(text ?? '');
+    }
+    // 移除形如 <** ... **> 的路由指令标记（例如 stopMessage/!provider 等），
+    // 避免泄露到上游 provider 或持久化的 Responses 历史中。
+    return text.replace(/<\*\*[^*]+\*\*>/g, '').trim();
+}
+function sanitizeBridgeHistory(history) {
+    if (!history || typeof history !== 'object') {
+        return history;
+    }
+    if (Array.isArray(history.input)) {
+        for (const entry of history.input) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const blocks = entry.content;
+            if (!Array.isArray(blocks))
+                continue;
+            for (const block of blocks) {
+                if (!block || typeof block !== 'object')
+                    continue;
+                const record = block;
+                if (typeof record.text === 'string') {
+                    record.text = stripRoutingTagsFromText(record.text);
+                }
+            }
+        }
+    }
+    if (typeof history.combinedSystemInstruction === 'string') {
+        history.combinedSystemInstruction = stripRoutingTagsFromText(history.combinedSystemInstruction);
+    }
+    if (typeof history.latestUserInstruction === 'string') {
+        history.latestUserInstruction = stripRoutingTagsFromText(history.latestUserInstruction);
+    }
+    if (Array.isArray(history.originalSystemMessages)) {
+        history.originalSystemMessages = history.originalSystemMessages.map((msg) => stripRoutingTagsFromText(msg));
+    }
+    return history;
+}
 function mergeResponsesTools(originalTools, fromChat) {
     const result = [];
     const byKey = new Map();
@@ -296,16 +336,16 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
             combinedSystemInstruction: ctx.systemInstruction
         }
         : undefined;
-    const historySeed = normalizeBridgeHistory(extras?.bridgeHistory) ??
-        normalizeBridgeHistory(fallbackHistory) ??
-        normalizeBridgeHistory(bridgeMetadata?.bridgeHistory) ??
-        normalizeBridgeHistory(envelopeMetadata?.bridgeHistory) ??
-        fallbackHistory;
+    const historySeed = sanitizeBridgeHistory(normalizeBridgeHistory(extras?.bridgeHistory)) ??
+        sanitizeBridgeHistory(normalizeBridgeHistory(fallbackHistory)) ??
+        sanitizeBridgeHistory(normalizeBridgeHistory(bridgeMetadata?.bridgeHistory)) ??
+        sanitizeBridgeHistory(normalizeBridgeHistory(envelopeMetadata?.bridgeHistory)) ??
+        sanitizeBridgeHistory(fallbackHistory);
     const history = historySeed ??
-        convertMessagesToBridgeInput({
+        sanitizeBridgeHistory(convertMessagesToBridgeInput({
             messages,
             tools: Array.isArray(out.tools) ? out.tools : undefined
-        });
+        }));
     const callIdTransformer = createToolCallIdTransformer(toolCallIdStyle);
     if (callIdTransformer) {
         enforceToolCallIdStyle(history.input, callIdTransformer);

package/dist/conversion/shared/compaction-detect.d.ts

@@ -0,0 +1,2 @@
+import type { JsonObject } from '../hub/types/json.js';
+export declare function isCompactionRequest(payload: JsonObject): boolean;

package/dist/conversion/shared/compaction-detect.js

@@ -0,0 +1,53 @@
+function hasCompactionMarker(value) {
+    const lower = value.toLowerCase();
+    return (lower.includes('context checkpoint compaction') ||
+        lower.includes('checkpoint compaction') ||
+        lower.includes('handoff summary for another llm'));
+}
+function containsMarker(value) {
+    if (typeof value === 'string') {
+        return hasCompactionMarker(value);
+    }
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    if (Array.isArray(value)) {
+        return value.some((entry) => containsMarker(entry));
+    }
+    const record = value;
+    if (typeof record.text === 'string' && hasCompactionMarker(record.text)) {
+        return true;
+    }
+    if (typeof record.content === 'string' && hasCompactionMarker(record.content)) {
+        return true;
+    }
+    if (Array.isArray(record.content) && record.content.some((entry) => containsMarker(entry))) {
+        return true;
+    }
+    if (Array.isArray(record.parts) && record.parts.some((entry) => containsMarker(entry))) {
+        return true;
+    }
+    return false;
+}
+export function isCompactionRequest(payload) {
+    if (containsMarker(payload)) {
+        return true;
+    }
+    const messages = payload.messages;
+    if (Array.isArray(messages) && messages.some((msg) => containsMarker(msg))) {
+        return true;
+    }
+    const input = payload.input;
+    if (containsMarker(input)) {
+        return true;
+    }
+    const system = payload.system;
+    if (containsMarker(system)) {
+        return true;
+    }
+    const instructions = payload.instructions;
+    if (containsMarker(instructions)) {
+        return true;
+    }
+    return false;
+}

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

@@ -1,4 +1,4 @@
-export type ProviderProtocolErrorCode = 'TOOL_PROTOCOL_ERROR' | 'SSE_DECODE_ERROR' | 'MALFORMED_RESPONSE' | 'MALFORMED_REQUEST';
+export type ProviderProtocolErrorCode = 'TOOL_PROTOCOL_ERROR' | 'SSE_DECODE_ERROR' | 'MALFORMED_RESPONSE' | 'MALFORMED_REQUEST' | 'SERVERTOOL_FOLLOWUP_FAILED';
 export type ProviderErrorCategory = 'EXTERNAL_ERROR' | 'TOOL_ERROR' | 'INTERNAL_ERROR';
 export interface ProviderProtocolErrorOptions {
     code: ProviderProtocolErrorCode;

package/dist/conversion/shared/reasoning-tool-normalizer.js

@@ -96,6 +96,13 @@ export function normalizeMessageReasoningTools(message, options) {
     const { cleanedText, toolCalls } = extractToolCallsFromReasoningText(sanitized, { idPrefix });
     const trimmed = (cleanedText || '').trim();
     writeReasoningContent(message, trimmed);
+    // Chat 统一行为：如果 message 本身没有正文内容，但存在非空 reasoning_content，
+    // 则将思考内容提升到正文，前后包裹 [思考] 标记，避免客户端只看到“空回答”。
+    const rawContent = message.content;
+    if ((typeof rawContent !== 'string' || rawContent.trim().length === 0) &&
+        trimmed.length > 0) {
+        message.content = `[思考]\n${trimmed}\n[/思考]`;
+    }
     if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
         return { toolCallsAdded: 0, cleanedReasoning: trimmed };
     }

package/dist/conversion/shared/snapshot-hooks.d.ts

@@ -5,5 +5,7 @@ export interface SnapshotHookOptions {
     data: unknown;
     verbosity?: 'minimal' | 'verbose';
     channel?: string;
+    providerKey?: string;
+    groupRequestId?: string;
 }
 export declare function writeSnapshotViaHooks(options: SnapshotHookOptions): Promise<void>;

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

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 const DEFAULT_SNAPSHOT_ROOT = path.join(os.homedir(), '.routecodex', 'codex-samples');
+const PENDING_PROVIDER_DIR = '__pending__';
 function resolveSnapshotRoot() {
     const envOverride = process.env.RCC_SNAPSHOT_DIR ||
         process.env.ROUTECODEX_SNAPSHOT_DIR;
@@ -37,19 +38,194 @@ function channelSuffix(channel) {
     const token = sanitizeToken(channel, '');
     return token ? `_${token}` : '';
 }
+function readStringField(value) {
+    return typeof value === 'string' && value.trim().length ? value.trim() : undefined;
+}
+function extractNestedProviderKey(value) {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const obj = value;
+    const direct = readStringField(obj.providerKey) ||
+        readStringField(obj.providerId) ||
+        readStringField(obj.profileId);
+    if (direct) {
+        return direct;
+    }
+    const target = obj.target;
+    if (target && typeof target === 'object') {
+        const tk = readStringField(target.providerKey);
+        if (tk) {
+            return tk;
+        }
+    }
+    const meta = obj.meta;
+    if (meta && typeof meta === 'object') {
+        const m = meta;
+        const fromMeta = readStringField(m.providerKey) ||
+            readStringField(m.providerId);
+        if (fromMeta) {
+            return fromMeta;
+        }
+        const ctx = m.context;
+        if (ctx && typeof ctx === 'object') {
+            const c = ctx;
+            const fromCtx = readStringField(c.providerKey) ||
+                readStringField(c.providerId) ||
+                readStringField(c.profileId);
+            if (fromCtx) {
+                return fromCtx;
+            }
+        }
+    }
+    return undefined;
+}
+function extractNestedGroupRequestId(value) {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const obj = value;
+    const direct = readStringField(obj.clientRequestId) ||
+        readStringField(obj.groupRequestId);
+    if (direct) {
+        return direct;
+    }
+    const meta = obj.meta;
+    if (meta && typeof meta === 'object') {
+        const m = meta;
+        const fromMeta = readStringField(m.clientRequestId) ||
+            readStringField(m.groupRequestId);
+        if (fromMeta) {
+            return fromMeta;
+        }
+        const ctx = m.context;
+        if (ctx && typeof ctx === 'object') {
+            const c = ctx;
+            const fromCtx = readStringField(c.clientRequestId) ||
+                readStringField(c.groupRequestId);
+            if (fromCtx) {
+                return fromCtx;
+            }
+        }
+    }
+    return undefined;
+}
+function toErrorCode(error) {
+    if (!error || typeof error !== 'object') {
+        return undefined;
+    }
+    const code = error.code;
+    return typeof code === 'string' && code.trim() ? code : undefined;
+}
+async function writeUniqueFile(dir, baseName, contents) {
+    const parsed = path.parse(baseName);
+    const ext = parsed.ext || '.json';
+    const stem = parsed.name || 'snapshot';
+    for (let i = 0; i < 64; i += 1) {
+        const name = i === 0 ? `${stem}${ext}` : `${stem}_${i}${ext}`;
+        try {
+            await fs.writeFile(path.join(dir, name), contents, { encoding: 'utf-8', flag: 'wx' });
+            return;
+        }
+        catch (error) {
+            if (toErrorCode(error) === 'EEXIST') {
+                continue;
+            }
+            throw error;
+        }
+    }
+    const fallback = `${stem}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}${ext}`;
+    await fs.writeFile(path.join(dir, fallback), contents, 'utf-8');
+}
+const requestProviderIndex = globalThis
+    .__routecodexSnapshotProviderIndex ||
+    new Map();
+globalThis
+    .__routecodexSnapshotProviderIndex = requestProviderIndex;
+async function mergeDirs(src, dest) {
+    await fs.mkdir(dest, { recursive: true });
+    let entries = [];
+    try {
+        entries = await fs.readdir(src);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        const from = path.join(src, name);
+        const to = path.join(dest, name);
+        try {
+            await fs.rename(from, to);
+        }
+        catch (error) {
+            if (toErrorCode(error) === 'EEXIST') {
+                // avoid overwriting; keep both
+                const parsed = path.parse(name);
+                const ext = parsed.ext || '';
+                const stem = parsed.name || 'snapshot';
+                const suffix = `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+                try {
+                    await fs.rename(from, path.join(dest, `${stem}_${suffix}${ext}`));
+                }
+                catch {
+                    // ignore move failure
+                }
+                continue;
+            }
+            // ignore other move failures
+        }
+    }
+    try {
+        await fs.rmdir(src);
+    }
+    catch {
+        // ignore
+    }
+}
+async function promotePendingDir(options) {
+    if (!options.groupRequestToken || options.providerToken === PENDING_PROVIDER_DIR) {
+        return;
+    }
+    const pending = path.join(options.root, options.folder, PENDING_PROVIDER_DIR, options.groupRequestToken);
+    const dest = path.join(options.root, options.folder, options.providerToken, options.groupRequestToken);
+    try {
+        await fs.access(pending);
+    }
+    catch {
+        return;
+    }
+    await fs.mkdir(path.dirname(dest), { recursive: true });
+    try {
+        await fs.rename(pending, dest);
+    }
+    catch {
+        // if rename fails (already exists / cross-device), merge
+        await mergeDirs(pending, dest);
+    }
+}
 async function writeSnapshotFile(options) {
     const root = resolveSnapshotRoot();
     const folder = resolveSnapshotFolder(options.endpoint);
-    const dir = path.join(root, folder);
     const stageToken = sanitizeToken(options.stage, 'snapshot');
-    const requestToken = sanitizeToken(options.requestId, `req_${Date.now()}`);
-    const filePath = path.join(dir, `${requestToken}_${stageToken}${channelSuffix(options.channel)}.json`);
+    const groupRequestToken = sanitizeToken(options.groupRequestId ||
+        extractNestedGroupRequestId(options.data) ||
+        options.requestId, `req_${Date.now()}`);
+    const providerFromOptions = readStringField(options.providerKey);
+    const providerFromData = extractNestedProviderKey(options.data);
+    const knownProvider = requestProviderIndex.get(groupRequestToken);
+    const providerToken = sanitizeToken(providerFromOptions || providerFromData || knownProvider || PENDING_PROVIDER_DIR, PENDING_PROVIDER_DIR);
+    if (!knownProvider && providerToken !== PENDING_PROVIDER_DIR) {
+        requestProviderIndex.set(groupRequestToken, providerToken);
+        await promotePendingDir({ root, folder, groupRequestToken, providerToken });
+    }
+    const dir = path.join(root, folder, providerToken, groupRequestToken);
     await fs.mkdir(dir, { recursive: true });
     const spacing = options.verbosity === 'minimal' ? undefined : 2;
     const payload = spacing !== undefined
         ? JSON.stringify(options.data, null, spacing)
         : JSON.stringify(options.data);
-    await fs.writeFile(filePath, payload, 'utf-8');
+    const fileName = `${stageToken}${channelSuffix(options.channel)}.json`;
+    await writeUniqueFile(dir, fileName, payload);
 }
 export async function writeSnapshotViaHooks(options) {
     try {

package/dist/conversion/shared/snapshot-utils.d.ts

@@ -4,6 +4,8 @@ interface SnapshotPayload {
     endpoint?: string;
     data: unknown;
     folderHint?: string;
+    providerKey?: string;
+    groupRequestId?: string;
 }
 export declare function shouldRecordSnapshots(): boolean;
 export declare function recordSnapshot(options: SnapshotPayload): Promise<void>;
@@ -12,5 +14,7 @@ export declare function createSnapshotWriter(opts: {
     requestId: string;
     endpoint?: string;
     folderHint?: string;
+    providerKey?: string;
+    groupRequestId?: string;
 }): SnapshotWriter | undefined;
 export {};

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

@@ -31,6 +31,8 @@ export async function recordSnapshot(options) {
         endpoint,
         stage: options.stage,
         requestId: options.requestId,
+        providerKey: options.providerKey,
+        groupRequestId: options.groupRequestId,
         data: options.data,
         verbosity: 'verbose'
     }).catch(() => {
@@ -48,6 +50,8 @@ export function createSnapshotWriter(opts) {
             requestId: opts.requestId,
             endpoint,
             folderHint: opts.folderHint,
+            providerKey: opts.providerKey,
+            groupRequestId: opts.groupRequestId,
             data: payload
         });
     };

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

@@ -234,19 +234,13 @@ export async function runChatResponseToolFilters(chatJson, options = {}) {
         registeredStages.add(filter.stage);
         engine.registerFilter(filter);
     };
-    const { ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter } = await import('../../filters/index.js');
+    const { ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter, ResponseToolArgumentsBlacklistFilter, ResponseToolArgumentsSchemaConvergeFilter } = await import('../../filters/index.js');
     register(new ResponseToolTextCanonicalizeFilter());
     try {
-        const { ResponseToolArgumentsToonDecodeFilter, ResponseApplyPatchToonDecodeFilter, ResponseToolArgumentsBlacklistFilter, ResponseToolArgumentsSchemaConvergeFilter } = await import('../../filters/index.js');
-        register(new ResponseToolArgumentsToonDecodeFilter());
-        register(new ResponseApplyPatchToonDecodeFilter());
-        try {
-            register(new ResponseToolArgumentsSchemaConvergeFilter());
-        }
-        catch { /* optional */ }
-        register(new ResponseToolArgumentsBlacklistFilter());
+        register(new ResponseToolArgumentsSchemaConvergeFilter());
     }
     catch { /* optional */ }
+    register(new ResponseToolArgumentsBlacklistFilter());
     register(new ResponseToolArgumentsStringifyFilter());
     register(new ResponseFinishInvariantsFilter());
     try {

package/dist/conversion/shared/tool-governor.d.ts

@@ -9,6 +9,8 @@ export interface ToolGovernanceOptions {
     };
 }
 export declare function processChatRequestTools(request: Unknown, opts?: ToolGovernanceOptions): Unknown;
+export declare function normalizeApplyPatchToolCallsOnResponse(chat: Unknown): Unknown;
+export declare function normalizeApplyPatchToolCallsOnRequest(request: Unknown): Unknown;
 export declare function processChatResponseTools(resp: Unknown): Unknown;
 export interface GovernContext extends ToolGovernanceOptions {
     phase: 'request' | 'response';

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

@@ -4,6 +4,7 @@
 // enforceChatBudget: 为避免在请求侧引入多余依赖，这里提供最小实现（保留形状，不裁剪）。
 import { augmentOpenAITools } from '../../guidance/index.js';
 import { validateToolCall } from '../../tools/tool-registry.js';
+import { repairFindMeta } from './tooling.js';
 function isObject(v) { return !!v && typeof v === 'object' && !Array.isArray(v); }
 // Note: tool schema strict augmentation removed per alignment
 function enforceChatBudget(chat, _modelId) { return chat; }
@@ -25,8 +26,8 @@ function tryWriteSnapshot(options, stage, data) {
         const ep = String(snap.endpoint || 'chat').toLowerCase();
         const group = ep.includes('responses') ? 'openai-responses' : ep.includes('messages') ? 'anthropic-messages' : 'openai-chat';
         const rid = String(snap.requestId || `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`);
-        const dir = path.join(base, group);
-        const file = path.join(dir, `${rid}_govern-${stage}.json`);
+        const dir = path.join(base, group, '__pending__', rid);
+        const file = path.join(dir, `govern-${stage}.json`);
         if (fs.existsSync(file))
             return; // 不重复
         fs.mkdirSync(dir, { recursive: true });
@@ -209,7 +210,7 @@ export function processChatRequestTools(request, opts) {
         // 4) Enforce payload budget (context bytes) with minimal loss policy
         const modelId = typeof canonical?.model === 'string' ? String(canonical.model) : 'unknown';
         const budgeted = enforceChatBudget(canonical, modelId);
-        return normalizeApplyPatchToolCallsOnRequest(budgeted);
+        return normalizeSpecialToolCallsOnRequest(budgeted);
     }
     catch {
         return out;
@@ -220,7 +221,7 @@ export function processChatRequestTools(request, opts) {
  * - Canonicalize textual tool markup to tool_calls; ensure finish_reason and content=null policy
  */
 import { repairArgumentsToString, parseLenient } from './jsonish.js';
-function normalizeApplyPatchToolCallsOnResponse(chat) {
+export function normalizeApplyPatchToolCallsOnResponse(chat) {
     try {
         const out = JSON.parse(JSON.stringify(chat));
         const choices = Array.isArray(out?.choices) ? out.choices : [];
@@ -241,6 +242,19 @@ function normalizeApplyPatchToolCallsOnResponse(chat) {
                     if (validation && validation.ok && typeof validation.normalizedArgs === 'string') {
                         fn.arguments = validation.normalizedArgs;
                     }
+                    else if (validation && !validation.ok) {
+                        try {
+                            const reason = validation.reason ?? 'unknown';
+                            const snippet = typeof argsStr === 'string' && argsStr.trim().length
+                                ? argsStr.trim().slice(0, 200).replace(/\s+/g, ' ')
+                                : '';
+                            // eslint-disable-next-line no-console
+                            console.error(`\x1b[31m[apply_patch][precheck][response] validation_failed reason=${reason}${snippet ? ` args=${snippet}` : ''}\x1b[0m`);
+                        }
+                        catch {
+                            // logging best-effort
+                        }
+                    }
                 }
                 catch {
                     // best-effort per tool_call
@@ -253,14 +267,32 @@ function normalizeApplyPatchToolCallsOnResponse(chat) {
         return chat;
     }
 }
-function normalizeApplyPatchToolCallsOnRequest(request) {
+export function normalizeApplyPatchToolCallsOnRequest(request) {
+    return normalizeSpecialToolCallsOnRequest(request);
+}
+function normalizeSpecialToolCallsOnRequest(request) {
     try {
         const out = JSON.parse(JSON.stringify(request));
         const messages = Array.isArray(out?.messages) ? out.messages : [];
-        for (const msg of messages) {
+        // 仅针对「当轮」工具调用做校验与形态修复：选择最后一条 assistant 消息
+        let lastAssistantIndex = -1;
+        for (let i = messages.length - 1; i >= 0; i -= 1) {
+            const candidate = messages[i];
+            if (!candidate || typeof candidate !== 'object')
+                continue;
+            if (candidate.role === 'assistant') {
+                lastAssistantIndex = i;
+                break;
+            }
+        }
+        if (lastAssistantIndex === -1) {
+            return out;
+        }
+        for (let i = 0; i < messages.length; i += 1) {
+            const msg = messages[i];
             if (!msg || typeof msg !== 'object')
                 continue;
-            if (msg.role !== 'assistant')
+            if (i !== lastAssistantIndex)
                 continue;
             const tcs = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
             if (!tcs.length)
@@ -269,13 +301,48 @@ function normalizeApplyPatchToolCallsOnRequest(request) {
                 try {
                     const fn = tc && tc.function ? tc.function : undefined;
                     const name = typeof fn?.name === 'string' ? String(fn.name).trim().toLowerCase() : '';
-                    if (name !== 'apply_patch')
-                        continue;
                     const rawArgs = fn?.arguments;
-                    const argsStr = repairArgumentsToString(rawArgs);
-                    const validation = validateToolCall('apply_patch', argsStr);
-                    if (validation && validation.ok && typeof validation.normalizedArgs === 'string') {
-                        fn.arguments = validation.normalizedArgs;
+                    // apply_patch 兼容：统一生成 { patch, input }
+                    if (name === 'apply_patch') {
+                        const argsStr = repairArgumentsToString(rawArgs);
+                        const validation = validateToolCall('apply_patch', argsStr);
+                        if (validation && validation.ok && typeof validation.normalizedArgs === 'string') {
+                            fn.arguments = validation.normalizedArgs;
+                        }
+                        else if (validation && !validation.ok) {
+                            try {
+                                const reason = validation.reason ?? 'unknown';
+                                const snippet = typeof argsStr === 'string' && argsStr.trim().length
+                                    ? argsStr.trim().slice(0, 200).replace(/\s+/g, ' ')
+                                    : '';
+                                // eslint-disable-next-line no-console
+                                console.error(`\x1b[31m[apply_patch][precheck][request] validation_failed reason=${reason}${snippet ? ` args=${snippet}` : ''}\x1b[0m`);
+                            }
+                            catch {
+                                // logging best-effort
+                            }
+                        }
+                        continue;
+                    }
+                    // exec_command 兼容：TOON / map / string 一律收敛为 { cmd, command, workdir, ... }
+                    if (name === 'exec_command') {
+                        const argsStr = repairArgumentsToString(rawArgs);
+                        let parsed;
+                        try {
+                            parsed = JSON.parse(argsStr);
+                        }
+                        catch {
+                            parsed = parseLenient(argsStr);
+                        }
+                        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                            const normalized = normalizeExecCommandArgs(parsed);
+                            try {
+                                fn.arguments = JSON.stringify(normalized ?? {});
+                            }
+                            catch {
+                                fn.arguments = '{}';
+                            }
+                        }
                     }
                 }
                 catch {
@@ -289,6 +356,27 @@ function normalizeApplyPatchToolCallsOnRequest(request) {
         return request;
     }
 }
+function normalizeExecCommandArgs(args) {
+    try {
+        const out = { ...args };
+        const rawCmd = typeof out.cmd === 'string' && out.cmd.trim().length
+            ? String(out.cmd)
+            : typeof out.command === 'string' && out.command.trim().length
+                ? String(out.command)
+                : undefined;
+        if (rawCmd) {
+            const fixed = repairFindMeta(rawCmd);
+            out.cmd = fixed;
+            if (typeof out.command === 'string') {
+                out.command = fixed;
+            }
+        }
+        return out;
+    }
+    catch {
+        return args;
+    }
+}
 function enhanceResponseToolArguments(chat) {
     try {
         const enable = String(process?.env?.RCC_TOOL_ENHANCE ?? '1').trim() !== '0';

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

@@ -80,8 +80,48 @@ function extractFromTextual(content, ctx) {
         }
         return events;
     }
-    // 3) rcc.tool.v1 JSON envelope (removed)
-    // 4) Generic <tool_call> textual block with <arg_key>/<arg_value>
+    // 3) <invoke name="tool"> wrapper with <parameter name="key">value</parameter>
+    try {
+        const invokeRe = /<invoke\s+name="([^">]+)"[^>]*>([\s\S]*?)<\/invoke>/gi;
+        let mInvoke;
+        const invokeEvents = [];
+        let idx = 0;
+        while ((mInvoke = invokeRe.exec(content)) !== null) {
+            const toolName = (mInvoke[1] || '').trim();
+            const inner = mInvoke[2] || '';
+            if (!toolName || !inner)
+                continue;
+            const paramRe = /<parameter\s+name="([^">]+)"[^>]*>([\s\S]*?)<\/parameter>/gi;
+            const argsObj = {};
+            let mParam;
+            while ((mParam = paramRe.exec(inner)) !== null) {
+                const key = String((mParam[1] || '').trim());
+                const raw = (mParam[2] || '').trim();
+                if (!key)
+                    continue;
+                let value = raw;
+                try {
+                    value = JSON.parse(raw);
+                }
+                catch { /* keep string */ }
+                argsObj[key] = value;
+            }
+            const id = genId(ctx, idx);
+            invokeEvents.push({ tool_calls: [{ index: idx, id, type: 'function', function: { name: toolName } }] });
+            const argStr = toJsonString(argsObj);
+            const parts = chunkString(argStr, Math.max(32, Math.min(1024, ctx?.chunkSize || 256)));
+            for (const d of parts) {
+                invokeEvents.push({ tool_calls: [{ index: idx, id, type: 'function', function: { arguments: d } }] });
+            }
+            idx += 1;
+        }
+        if (invokeEvents.length) {
+            return invokeEvents;
+        }
+    }
+    catch { /* ignore textual invoke parse errors */ }
+    // 4) rcc.tool.v1 JSON envelope (removed)
+    // 5) Generic <tool_call> textual block with <arg_key>/<arg_value>
     try {
         // Explicit wrapper form
         const blockRe = /<tool_call[^>]*>[\s\S]*?<\/tool_call>/gi;

package/dist/filters/index.d.ts

@@ -12,8 +12,6 @@ export * from './special/response-tool-text-canonicalize.js';
 export * from './special/response-tool-arguments-stringify.js';
 export * from './special/response-finish-invariants.js';
 export * from './special/request-tools-normalize.js';
-export * from './special/response-tool-arguments-toon-decode.js';
-export * from './special/response-apply-patch-toon-decode.js';
 export * from './special/response-tool-arguments-blacklist.js';
 export * from './special/response-tool-arguments-schema-converge.js';
 export * from './special/response-tool-arguments-whitelist.js';