@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/conversion/shared/responses-response-utils.js

@@ -1,10 +1,9 @@
-import { sanitizeResponsesFunctionName } from './responses-tool-utils.js';
-import { normalizeFunctionCallId } from './bridge-id-utils.js';
 import { extractOutputSegments } from './output-content-normalizer.js';
-import { sanitizeReasoningTaggedText } from './reasoning-utils.js';
-import { createBridgeActionState, runBridgeActionPipeline } from './bridge-actions.js';
-import { resolveBridgePolicy, resolvePolicyActions } from './bridge-policies.js';
+import { createBridgeActionState, runBridgeActionPipeline } from '../bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from '../bridge-policies.js';
 import { registerResponsesPayloadSnapshot, registerResponsesPassthrough } from './responses-reasoning-registry.js';
+import { normalizeFunctionCallIdWithNative, sanitizeReasoningTaggedTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { sanitizeResponsesFunctionNameWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
 function selectCallId(entry) {
     const candidates = [
         entry?.call_id,
@@ -23,7 +22,7 @@ function normalizeToolCall(entry, fallbackPrefix) {
     if (!entry || typeof entry !== 'object')
         return null;
     const fn = entry.function || {};
-    const rawName = sanitizeResponsesFunctionName(fn.name ?? entry.name);
+    const rawName = sanitizeResponsesFunctionNameWithNative(fn.name ?? entry.name);
     if (!rawName)
         return null;
     const argsRaw = fn.arguments ?? entry.arguments ?? {};
@@ -40,7 +39,7 @@ function normalizeToolCall(entry, fallbackPrefix) {
     const callIdRaw = selectCallId(entry);
     const callId = typeof callIdRaw === 'string' && callIdRaw.length
         ? callIdRaw
-        : normalizeFunctionCallId({
+        : normalizeFunctionCallIdWithNative({
             callId: callIdRaw,
             fallback: `${fallbackPrefix}_${Math.random().toString(36).slice(2, 10)}`
         });
@@ -154,6 +153,60 @@ function collectRawReasoningSegments(response) {
     }
     return segments;
 }
+function collectReasoningSummarySegments(response) {
+    const segments = [];
+    const outputItems = Array.isArray(response.output) ? response.output : [];
+    for (const item of outputItems) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const type = typeof item.type === 'string' ? String(item.type).toLowerCase() : '';
+        if (type !== 'reasoning')
+            continue;
+        const summary = Array.isArray(item.summary) ? item.summary : [];
+        for (const entry of summary) {
+            if (typeof entry === 'string') {
+                segments.push(entry);
+                continue;
+            }
+            if (entry && typeof entry === 'object' && typeof entry.text === 'string') {
+                segments.push(entry.text);
+            }
+        }
+    }
+    return segments;
+}
+function collectReasoningEncryptedContent(response) {
+    const outputItems = Array.isArray(response.output) ? response.output : [];
+    for (const item of outputItems) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const type = typeof item.type === 'string' ? String(item.type).toLowerCase() : '';
+        if (type !== 'reasoning')
+            continue;
+        const encrypted = item.encrypted_content;
+        if (typeof encrypted === 'string' && encrypted.trim().length) {
+            return encrypted;
+        }
+    }
+    return undefined;
+}
+function buildReasoningPayload(options) {
+    const { summarySegments, contentSegments, encryptedContent } = options;
+    const summary = summarySegments.length
+        ? summarySegments.map((text) => ({ type: 'summary_text', text }))
+        : undefined;
+    const content = contentSegments.length
+        ? contentSegments.map((text) => ({ type: 'reasoning_text', text }))
+        : undefined;
+    if (!summary && !content && encryptedContent === undefined) {
+        return undefined;
+    }
+    return {
+        summary,
+        content,
+        encrypted_content: encryptedContent
+    };
+}
 function registerPassthroughSnapshot(payload) {
     const ids = new Set();
     const requestId = typeof payload?.request_id === 'string' ? payload.request_id.trim() : '';
@@ -166,6 +219,23 @@ function registerPassthroughSnapshot(payload) {
         registerResponsesPassthrough(candidate, payload);
     }
 }
+function cloneSnapshot(value) {
+    try {
+        const structuredCloneImpl = globalThis.structuredClone;
+        if (typeof structuredCloneImpl === 'function') {
+            return structuredCloneImpl(value);
+        }
+    }
+    catch {
+        /* ignore structuredClone failures */
+    }
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return { ...value };
+    }
+}
 export function buildChatResponseFromResponses(payload) {
     if (!payload || typeof payload !== 'object')
         return payload;
@@ -186,8 +256,13 @@ export function buildChatResponseFromResponses(payload) {
     const toolCalls = collectToolCallsFromResponses(response);
     const { textParts, reasoningParts } = extractOutputSegments(response);
     const rawReasoningSegments = collectRawReasoningSegments(response);
-    const explicitOutput = typeof response.output_text === 'string' && response.output_text.trim().length
-        ? sanitizeReasoningTaggedText(response.output_text)
+    const summaryReasoningSegments = collectReasoningSummarySegments(response);
+    const encryptedReasoning = collectReasoningEncryptedContent(response);
+    const outputTextRaw = typeof response.output_text === 'string' && response.output_text.trim().length
+        ? response.output_text
+        : undefined;
+    const explicitOutput = typeof outputTextRaw === 'string'
+        ? sanitizeReasoningTaggedTextWithNative(outputTextRaw)
         : undefined;
     const messageContentText = explicitOutput || textParts.join('\n').trim();
     const messageContent = messageContentText || '';
@@ -219,7 +294,9 @@ export function buildChatResponseFromResponses(payload) {
     if (toolCalls.length) {
         message.tool_calls = toolCalls;
     }
-    const reasoningSegments = rawReasoningSegments.length ? rawReasoningSegments : reasoningParts;
+    const reasoningSegments = rawReasoningSegments.length
+        ? rawReasoningSegments
+        : (reasoningParts.length ? reasoningParts : summaryReasoningSegments);
     if (reasoningSegments.length) {
         message.reasoning_content = reasoningSegments.join('\n');
     }
@@ -238,13 +315,18 @@ export function buildChatResponseFromResponses(payload) {
         ]
     };
     const hasOutputTextField = Object.prototype.hasOwnProperty.call(response, 'output_text');
-    if (rawReasoningSegments.length) {
-        chat.__responses_reasoning = rawReasoningSegments;
+    const reasoningPayload = buildReasoningPayload({
+        summarySegments: summaryReasoningSegments,
+        contentSegments: rawReasoningSegments.length ? rawReasoningSegments : reasoningParts,
+        encryptedContent: encryptedReasoning
+    });
+    if (reasoningPayload) {
+        chat.__responses_reasoning = reasoningPayload;
     }
     chat.__responses_output_text_meta = {
         hasField: hasOutputTextField,
-        value: hasOutputTextField && typeof response.output_text === 'string'
-            ? sanitizeReasoningTaggedText(response.output_text)
+        value: typeof outputTextRaw === 'string'
+            ? sanitizeReasoningTaggedTextWithNative(outputTextRaw)
             : undefined
     };
     if (usage !== undefined) {
@@ -257,5 +339,12 @@ export function buildChatResponseFromResponses(payload) {
         chat.request_id = requestId;
     }
     registerResponsesPayloadSnapshot(id, response);
+    if (requestId && requestId !== id) {
+        registerResponsesPayloadSnapshot(requestId, response);
+    }
+    const snapshot = cloneSnapshot(response);
+    if (snapshot) {
+        chat.__responses_payload_snapshot = snapshot;
+    }
     return chat;
 }

package/dist/conversion/shared/responses-tool-utils.d.ts

@@ -7,6 +7,7 @@ export interface CallIdTransformer {
 }
 export declare function createToolCallIdTransformer(style: ToolCallIdStyle): CallIdTransformer | null;
 export declare function enforceToolCallIdStyle(input: BridgeInputItem[], transformer: CallIdTransformer): void;
+export declare function normalizeResponsesToolCallIds(payload: Record<string, unknown> | null | undefined): void;
 export declare function resolveToolCallIdStyle(metadata: Record<string, unknown> | undefined): ToolCallIdStyle;
 export declare function stripInternalToolingMetadata(metadata: unknown): void;
 export declare function sanitizeResponsesFunctionName(rawName: unknown): string | undefined;

package/dist/conversion/shared/responses-tool-utils.js

@@ -1,4 +1,5 @@
-import { normalizeFunctionCallId, normalizeFunctionCallOutputId, normalizeResponsesCallId } from './bridge-id-utils.js';
+import { normalizeFunctionCallId, normalizeFunctionCallOutputId, normalizeResponsesCallId } from '../bridge-id-utils.js';
+import { sanitizeResponsesFunctionNameWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
 export function createToolCallIdTransformer(style) {
     if (style !== 'fc') {
         return null;
@@ -65,6 +66,94 @@ export function enforceToolCallIdStyle(input, transformer) {
         }
     }
 }
+function isStableToolCallId(raw) {
+    return /^((fc|call)_[A-Za-z0-9_-]+)$/i.test(raw);
+}
+export function normalizeResponsesToolCallIds(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return;
+    }
+    let counter = 0;
+    const aliasMap = new Map();
+    const nextFallback = (prefix) => `${prefix}_${++counter}`;
+    const normalizeCallId = (raw, fallbackPrefix) => {
+        const trimmed = typeof raw === 'string' ? raw.trim() : '';
+        if (trimmed) {
+            const cached = aliasMap.get(trimmed);
+            if (cached)
+                return cached;
+        }
+        const normalized = trimmed && isStableToolCallId(trimmed)
+            ? trimmed
+            : normalizeFunctionCallId({
+                callId: trimmed || undefined,
+                fallback: nextFallback(fallbackPrefix)
+            });
+        if (trimmed) {
+            aliasMap.set(trimmed, normalized);
+        }
+        return normalized;
+    };
+    const output = Array.isArray(payload.output) ? payload.output : [];
+    for (const item of output) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const type = typeof item.type === 'string' ? String(item.type).toLowerCase() : '';
+        if (type === 'function_call') {
+            const normalizedCallId = normalizeCallId(item.call_id ?? item.tool_call_id ?? item.id, 'fc_call');
+            item.call_id = normalizedCallId;
+            if (item.tool_call_id !== undefined) {
+                item.tool_call_id = normalizedCallId;
+            }
+            const rawOutputId = typeof item.id === 'string' ? item.id : undefined;
+            item.id = normalizeFunctionCallOutputId({
+                callId: normalizedCallId,
+                fallback: rawOutputId ?? nextFallback('fc')
+            });
+            continue;
+        }
+        if (type === 'function_call_output' || type === 'tool_result' || type === 'tool_message') {
+            const normalizedCallId = normalizeCallId(item.call_id ?? item.tool_call_id ?? item.id, 'fc_call');
+            item.call_id = normalizedCallId;
+            if (item.tool_call_id !== undefined) {
+                item.tool_call_id = normalizedCallId;
+            }
+            const rawOutputId = typeof item.id === 'string' ? item.id : undefined;
+            item.id = normalizeFunctionCallOutputId({
+                callId: normalizedCallId,
+                fallback: rawOutputId ?? nextFallback('fc')
+            });
+            continue;
+        }
+        if (Array.isArray(item.tool_calls)) {
+            for (const call of item.tool_calls) {
+                if (!call || typeof call !== 'object')
+                    continue;
+                const normalizedCallId = normalizeCallId(call.id ?? call.tool_call_id ?? call.call_id, 'fc_call');
+                call.id = normalizedCallId;
+                if (call.tool_call_id !== undefined) {
+                    call.tool_call_id = normalizedCallId;
+                }
+                if (call.call_id !== undefined) {
+                    call.call_id = normalizedCallId;
+                }
+            }
+        }
+    }
+    const submitCalls = payload?.required_action?.submit_tool_outputs?.tool_calls;
+    if (Array.isArray(submitCalls)) {
+        for (const call of submitCalls) {
+            if (!call || typeof call !== 'object')
+                continue;
+            const normalizedCallId = normalizeCallId(call.tool_call_id ?? call.id ?? call.call_id, 'fc_call');
+            call.tool_call_id = normalizedCallId;
+            call.id = normalizedCallId;
+            if (call.call_id !== undefined) {
+                call.call_id = normalizedCallId;
+            }
+        }
+    }
+}
 export function resolveToolCallIdStyle(metadata) {
     // Standard OpenAI `/v1/responses` requires function_call item ids to start with `fc_`.
     // Default to `fc` unless explicitly overridden (e.g. LM Studio compat).
@@ -116,18 +205,5 @@ function prunePrivateExtraFields(target) {
 }
 const RAW_SYSTEM_SENTINEL = '__rcc_raw_system';
 export function sanitizeResponsesFunctionName(rawName) {
-    if (typeof rawName !== 'string') {
-        return undefined;
-    }
-    const trimmed = rawName.trim();
-    if (!trimmed) {
-        return undefined;
-    }
-    const dotIndex = trimmed.indexOf('.');
-    const base = dotIndex >= 0 ? trimmed.slice(dotIndex + 1) : trimmed;
-    const sanitized = base.replace(/[^A-Za-z0-9_-]/g, '_');
-    if (sanitized.length > 0) {
-        return sanitized;
-    }
-    return 'tool_call';
+    return sanitizeResponsesFunctionNameWithNative(rawName);
 }

package/dist/conversion/shared/streaming-text-extractor.js

@@ -2,6 +2,7 @@
 // Detects <function=execute> blocks and structured apply_patch payloads
 // and converts them into OpenAI tool_calls incrementally.
 import { isStructuredApplyPatchPayload } from '../../tools/apply-patch-structured.js';
+import { repairArgumentsToStringWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -32,13 +33,7 @@ export class StreamingTextToolExtractor {
         return `${p}_${Date.now()}_${(++this.idCounter).toString(36)}`;
     }
     toToolCall(name, argsObj) {
-        let argStr = '{}';
-        try {
-            argStr = JSON.stringify(argsObj ?? {});
-        }
-        catch {
-            argStr = '{}';
-        }
+        const argStr = repairArgumentsToStringWithNative(argsObj);
         return { id: this.genId(), type: 'function', function: { name, arguments: argStr } };
     }
     tryExtractStructuredBlocks() {

package/dist/conversion/shared/text-markup-normalizer/normalize.d.ts

@@ -1,2 +1,2 @@
-import type { TextMarkupNormalizeOptions } from './extractors.js';
-export declare function normalizeAssistantTextToToolCalls(message: Record<string, any>, options?: TextMarkupNormalizeOptions): Record<string, any>;
+import type { TextMarkupNormalizeOptions } from '../../types/text-markup-normalizer.js';
+export declare function normalizeAssistantTextToToolCalls(message: Record<string, any>, _options?: TextMarkupNormalizeOptions): Record<string, any>;

package/dist/conversion/shared/text-markup-normalizer/normalize.js

@@ -1,4 +1,4 @@
-import { extractApplyPatchCallsFromText, extractBareExecCommandFromText, extractExecuteBlocksFromText, extractExploredListDirectoryCallsFromText, extractInvokeToolsFromText, extractJsonToolCallsFromText, extractParameterXmlToolsFromText, extractQwenToolCallTokensFromText, extractSimpleXmlToolsFromText, extractToolNamespaceXmlBlocksFromText, extractXMLToolCallsFromText } from './extractors.js';
+import { extractToolCallsFromReasoningTextWithNative } from '../../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 function enabled() {
     try {
         return String(process?.env?.RCC_TEXT_MARKUP_COMPAT ?? '1').trim() !== '0';
@@ -7,7 +7,7 @@ function enabled() {
         return true;
     }
 }
-export function normalizeAssistantTextToToolCalls(message, options) {
+export function normalizeAssistantTextToToolCalls(message, _options) {
     if (!enabled())
         return message;
     try {
@@ -44,22 +44,48 @@ export function normalizeAssistantTextToToolCalls(message, options) {
         if (!candidates.length)
             return message;
         let calls = null;
+        const mapNativeToolCalls = (raw) => {
+            const mapped = [];
+            raw.forEach((entry, index) => {
+                if (!entry || typeof entry !== 'object')
+                    return;
+                const functionNode = entry.function && typeof entry.function === 'object' && !Array.isArray(entry.function)
+                    ? entry.function
+                    : undefined;
+                const name = (typeof functionNode?.name === 'string' && functionNode.name.trim()) ||
+                    (typeof entry.name === 'string' && entry.name.trim()) ||
+                    undefined;
+                if (!name)
+                    return;
+                const argsCandidate = functionNode?.arguments ?? entry.arguments ?? entry.args ?? '{}';
+                let args = '{}';
+                if (typeof argsCandidate === 'string') {
+                    args = argsCandidate;
+                }
+                else {
+                    try {
+                        args = JSON.stringify(argsCandidate ?? {});
+                    }
+                    catch {
+                        args = '{}';
+                    }
+                }
+                const id = (typeof entry.id === 'string' && entry.id.trim()) ||
+                    (typeof entry.call_id === 'string' && entry.call_id.trim()) ||
+                    `call_${index + 1}`;
+                mapped.push({ id, name, args });
+            });
+            return mapped;
+        };
         for (const text of candidates) {
-            // Order: xml-like <tool_call> -> apply_patch -> execute blocks -> simple XML tools -> bare command salvage
-            calls =
-                extractQwenToolCallTokensFromText(text) ||
-                    extractJsonToolCallsFromText(text, options) ||
-                    extractToolNamespaceXmlBlocksFromText(text) ||
-                    extractParameterXmlToolsFromText(text) ||
-                    extractInvokeToolsFromText(text) ||
-                    extractXMLToolCallsFromText(text) ||
-                    extractApplyPatchCallsFromText(text) ||
-                    extractExecuteBlocksFromText(text) ||
-                    extractSimpleXmlToolsFromText(text) ||
-                    extractExploredListDirectoryCallsFromText(text) ||
-                    extractBareExecCommandFromText(text);
-            if (calls && calls.length)
-                break;
+            const nativeParsed = extractToolCallsFromReasoningTextWithNative(text);
+            if (nativeParsed.toolCalls.length) {
+                const nativeCalls = mapNativeToolCalls(nativeParsed.toolCalls);
+                if (nativeCalls.length) {
+                    calls = nativeCalls;
+                    break;
+                }
+            }
         }
         if (calls && calls.length) {
             const toolCalls = calls.map((c) => ({ id: c.id, type: 'function', function: { name: c.name, arguments: c.args } }));

package/dist/conversion/shared/text-markup-normalizer.d.ts

@@ -1,3 +1,4 @@
-export type { JsonToolRepairConfig, TextMarkupNormalizeOptions, ToolCallLite } from './text-markup-normalizer/extractors.js';
-export { extractApplyPatchCallsFromText, extractBareExecCommandFromText, extractExecuteBlocksFromText, extractExploredListDirectoryCallsFromText, extractInvokeToolsFromText, extractJsonToolCallsFromText, extractParameterXmlToolsFromText, extractQwenToolCallTokensFromText, extractSimpleXmlToolsFromText, extractToolNamespaceXmlBlocksFromText, extractXMLToolCallsFromText } from './text-markup-normalizer/extractors.js';
+export type { JsonToolRepairConfig, TextMarkupNormalizeOptions, ToolCallLite } from '../types/text-markup-normalizer.js';
+export { extractApplyPatchCallsFromTextWithNative as extractApplyPatchCallsFromText, extractBareExecCommandFromTextWithNative as extractBareExecCommandFromText, extractExecuteBlocksFromTextWithNative as extractExecuteBlocksFromText, extractExploredListDirectoryCallsFromTextWithNative as extractExploredListDirectoryCallsFromText, extractInvokeToolsFromTextWithNative as extractInvokeToolsFromText, extractJsonToolCallsFromTextWithNative as extractJsonToolCallsFromText, extractParameterXmlToolsFromTextWithNative as extractParameterXmlToolsFromText, extractQwenToolCallTokensFromTextWithNative as extractQwenToolCallTokensFromText, extractSimpleXmlToolsFromTextWithNative as extractSimpleXmlToolsFromText, extractToolNamespaceXmlBlocksFromTextWithNative as extractToolNamespaceXmlBlocksFromText, extractXMLToolCallsFromTextWithNative as extractXMLToolCallsFromText } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export { normalizeAssistantTextToToolCalls } from './text-markup-normalizer/normalize.js';
+export { extractToolCallsFromReasoningTextWithNative, parseLenientJsonishWithNative, repairArgumentsToStringWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';

package/dist/conversion/shared/text-markup-normalizer.js

@@ -1,2 +1,3 @@
-export { extractApplyPatchCallsFromText, extractBareExecCommandFromText, extractExecuteBlocksFromText, extractExploredListDirectoryCallsFromText, extractInvokeToolsFromText, extractJsonToolCallsFromText, extractParameterXmlToolsFromText, extractQwenToolCallTokensFromText, extractSimpleXmlToolsFromText, extractToolNamespaceXmlBlocksFromText, extractXMLToolCallsFromText } from './text-markup-normalizer/extractors.js';
+export { extractApplyPatchCallsFromTextWithNative as extractApplyPatchCallsFromText, extractBareExecCommandFromTextWithNative as extractBareExecCommandFromText, extractExecuteBlocksFromTextWithNative as extractExecuteBlocksFromText, extractExploredListDirectoryCallsFromTextWithNative as extractExploredListDirectoryCallsFromText, extractInvokeToolsFromTextWithNative as extractInvokeToolsFromText, extractJsonToolCallsFromTextWithNative as extractJsonToolCallsFromText, extractParameterXmlToolsFromTextWithNative as extractParameterXmlToolsFromText, extractQwenToolCallTokensFromTextWithNative as extractQwenToolCallTokensFromText, extractSimpleXmlToolsFromTextWithNative as extractSimpleXmlToolsFromText, extractToolNamespaceXmlBlocksFromTextWithNative as extractToolNamespaceXmlBlocksFromText, extractXMLToolCallsFromTextWithNative as extractXMLToolCallsFromText } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export { normalizeAssistantTextToToolCalls } from './text-markup-normalizer/normalize.js';
+export { extractToolCallsFromReasoningTextWithNative, parseLenientJsonishWithNative, repairArgumentsToStringWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';

package/dist/conversion/shared/thought-signature-validator.js

@@ -4,6 +4,7 @@
  * 提供严格的 thoughtSignature 验证功能，用于 Claude/Gemini thinking 块的签名验证。
  * 参考 gcli2api 的实现，确保与上游 API 的兼容性。
  */
+import { sanitizeReasoningTaggedTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 const DEFAULT_OPTIONS = {
     // Antigravity-Manager alignment: treat short signatures as noise.
     minLength: 50,
@@ -27,7 +28,7 @@ export function hasValidThoughtSignature(block, options) {
         return true; // 非 thinking 块默认有效
     }
     const opts = { ...DEFAULT_OPTIONS, ...options };
-    const thinking = String(obj.thinking || obj.text || '');
+    const thinking = sanitizeReasoningTaggedTextWithNative(String(obj.thinking || obj.text || ''));
     const signature = coerceThoughtSignature(obj.thoughtSignature || obj.signature);
     // 空 thinking + 任意签名 = 有效 (trailing signature case)
     if (!thinking.trim() && signature !== undefined && opts.allowEmptyThinkingWithSignature) {
@@ -56,7 +57,7 @@ export function sanitizeThinkingBlock(block) {
     }
     const sanitized = {
         type: blockType,
-        thinking: String(obj.thinking || obj.text || '')
+        thinking: sanitizeReasoningTaggedTextWithNative(String(obj.thinking || obj.text || ''))
     };
     const signature = coerceThoughtSignature(obj.thoughtSignature || obj.signature);
     if (signature) {

package/dist/conversion/shared/tool-argument-repairer.js

@@ -7,10 +7,10 @@
  * This module provides a deterministic, best-effort repair surface that returns a JSON string
  * or `{}` and never throws.
  */
-import { repairArgumentsToString } from './jsonish.js';
+import { repairArgumentsToStringWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export class ToolArgumentRepairer {
     repairToString(args) {
-        return repairArgumentsToString(args);
+        return repairArgumentsToStringWithNative(args);
     }
     validateAndRepair(toolName, args) {
         const repaired = this.repairToString(args);

package/dist/conversion/shared/tool-call-id-manager.js

@@ -4,6 +4,7 @@
  * 提供统一的工具调用 ID 生成、规范化和风格管理功能。
  * 支持 'fc' (function call) 和 'preserve' 两种风格。
  */
+import { normalizeFunctionCallIdWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 const DEFAULT_OPTIONS = {
     style: 'fc',
     prefix: 'fc_',
@@ -43,13 +44,10 @@ export class ToolCallIdManager {
             return this.generateId();
         }
         if (this.options.style === 'fc') {
-            // fc 风格：提取或生成 fc_ 风格 ID
-            const fcMatch = trimmed.match(/fc_([a-z0-9]+)/i);
-            if (fcMatch) {
-                return `fc_${fcMatch[1]}`;
-            }
-            // 如果不是 fc_ 风格，生成新的 fc_ ID
-            return this.generateId();
+            return normalizeFunctionCallIdWithNative({
+                callId: trimmed,
+                fallback: this.generateId()
+            });
         }
         // preserve 风格：保留原始 ID
         return trimmed;

package/dist/conversion/shared/tool-call-utils.js

@@ -1,56 +1,14 @@
+import { deriveToolCallKeyWithNative, mergeToolCallsWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 /**
  * Derive a deterministic key for a tool call by combining the normalized
  * function name and serialized arguments. Used to deduplicate inferred calls.
  */
 export function deriveToolCallKey(call) {
-    if (!call || typeof call !== 'object') {
-        return null;
-    }
-    const fn = call.function;
-    const name = typeof fn?.name === 'string' ? fn.name.trim() : '';
-    const argsRaw = fn?.arguments;
-    let args = '';
-    if (typeof argsRaw === 'string') {
-        args = argsRaw.trim();
-    }
-    else if (argsRaw !== undefined) {
-        try {
-            args = JSON.stringify(argsRaw);
-        }
-        catch {
-            args = '';
-        }
-    }
-    if (!name && !args) {
-        return null;
-    }
-    return `${name}::${args}`;
+    return deriveToolCallKeyWithNative(call);
 }
 /**
  * Merge tool call entries with deduplication (by derived key). Returns the new array.
  */
 export function mergeToolCalls(existing, additions) {
-    const base = Array.isArray(existing) ? [...existing] : [];
-    const next = Array.isArray(additions) ? additions : [];
-    if (!next.length) {
-        return base;
-    }
-    const seen = new Set();
-    for (const call of base) {
-        const key = deriveToolCallKey(call);
-        if (key) {
-            seen.add(key);
-        }
-    }
-    for (const call of next) {
-        const key = deriveToolCallKey(call);
-        if (key && seen.has(key)) {
-            continue;
-        }
-        base.push(call);
-        if (key) {
-            seen.add(key);
-        }
-    }
-    return base;
+    return mergeToolCallsWithNative(existing, additions);
 }