@jsonstudio/llms 0.6.2172 → 0.6.2979

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

@@ -1,4 +1,5 @@
 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/runtime-metadata.js

@@ -1,23 +1,31 @@
 import { isJsonObject, jsonClone } from '../hub/types/json.js';
+import { cloneRuntimeMetadataWithNative, ensureRuntimeMetadataCarrierWithNative, readRuntimeMetadataWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export function readRuntimeMetadata(carrier) {
     if (!carrier || typeof carrier !== 'object') {
         return undefined;
     }
-    const candidate = carrier.__rt;
+    const candidate = readRuntimeMetadataWithNative(carrier);
     return candidate && isJsonObject(candidate) ? candidate : undefined;
 }
 export function ensureRuntimeMetadata(carrier) {
     if (!carrier || typeof carrier !== 'object') {
         throw new Error('ensureRuntimeMetadata requires object carrier');
     }
-    const existing = readRuntimeMetadata(carrier);
-    if (existing) {
+    const nextCarrier = ensureRuntimeMetadataCarrierWithNative(carrier);
+    for (const key of Object.keys(carrier)) {
+        if (!Object.prototype.hasOwnProperty.call(nextCarrier, key)) {
+            delete carrier[key];
+        }
+    }
+    Object.assign(carrier, nextCarrier);
+    const existing = carrier.__rt;
+    if (existing && isJsonObject(existing)) {
         return existing;
     }
     carrier.__rt = {};
     return carrier.__rt;
 }
 export function cloneRuntimeMetadata(carrier) {
-    const rt = readRuntimeMetadata(carrier);
-    return rt ? jsonClone(rt) : undefined;
+    const rt = cloneRuntimeMetadataWithNative(carrier);
+    return rt && isJsonObject(rt) ? jsonClone(rt) : undefined;
 }

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>;
+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 { 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 { 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);
 }

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

@@ -1,42 +1,38 @@
-// Minimal canonicalizer to ensure tool_calls invariants without altering semantics
+import { normalizeChatResponseReasoningToolsWithNative } from '../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
 import { repairToolArguments } from './tool-argument-repairer.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
 export function canonicalizeChatResponseTools(payload) {
-    try {
-        const out = isObject(payload) ? JSON.parse(JSON.stringify(payload)) : payload;
-        const choices = Array.isArray(out?.choices) ? out.choices : [];
-        for (const ch of choices) {
-            const msg = ch && ch.message ? ch.message : undefined;
-            const tcs = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
-            if (!tcs || !tcs.length)
-                continue;
-            // ensure arguments is string and content is null when tool_calls present
-            try {
-                if (String(ch.finish_reason || '').toLowerCase() !== 'tool_calls') {
-                    ch.finish_reason = 'tool_calls';
-                }
+    const cloned = isObject(payload) ? JSON.parse(JSON.stringify(payload)) : payload;
+    const nativeOut = normalizeChatResponseReasoningToolsWithNative(cloned);
+    const out = isObject(nativeOut) ? nativeOut : cloned;
+    const choices = Array.isArray(out?.choices) ? out.choices : [];
+    for (const ch of choices) {
+        const msg = ch && ch.message ? ch.message : undefined;
+        const tcs = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
+        if (!tcs || !tcs.length)
+            continue;
+        try {
+            if (String(ch.finish_reason || '').toLowerCase() !== 'tool_calls') {
+                ch.finish_reason = 'tool_calls';
             }
-            catch { /* ignore */ }
+        }
+        catch { /* ignore */ }
+        try {
+            if (msg && typeof msg === 'object')
+                msg.content = null;
+        }
+        catch { /* ignore */ }
+        for (const tc of tcs) {
             try {
-                if (msg && typeof msg === 'object')
-                    msg.content = null;
+                const fn = tc && tc.function ? tc.function : undefined;
+                if (fn)
+                    fn.arguments = repairToolArguments(fn.arguments);
             }
             catch { /* ignore */ }
-            for (const tc of tcs) {
-                try {
-                    const fn = tc && tc.function ? tc.function : undefined;
-                    if (fn)
-                        fn.arguments = repairToolArguments(fn.arguments);
-                }
-                catch { /* ignore */ }
-            }
         }
-        return out;
-    }
-    catch {
-        return payload;
     }
+    return out;
 }
 export default canonicalizeChatResponseTools;

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

@@ -1,7 +1,7 @@
 import { FilterEngine } from '../../filters/index.js';
 import { loadFieldMapConfig } from '../../filters/utils/fieldmap-loader.js';
-import { normalizeChatResponseReasoningTools } from './reasoning-tool-normalizer.js';
 import { createSnapshotWriter } from './snapshot-utils.js';
+import { normalizeChatResponseReasoningToolsWithNative as normalizeChatResponseReasoningTools } from '../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
 const REQUEST_FILTER_STAGES = [
     'request_pre',
     'request_map',
@@ -100,104 +100,11 @@ export async function runChatRequestToolFilters(chatRequest, options = {}) {
     recordStage('req_process_tool_filters_output', staged);
     return staged;
 }
-function applyLocalToolGovernance(chatRequest, rawPayload) {
+function applyLocalToolGovernance(chatRequest, _rawPayload) {
     if (!chatRequest || typeof chatRequest !== 'object') {
         return chatRequest;
     }
-    const messages = Array.isArray(chatRequest.messages) ? chatRequest.messages : undefined;
-    const tools = Array.isArray(chatRequest.tools) ? chatRequest.tools : undefined;
-    if (!tools || !tools.length) {
-        return chatRequest;
-    }
-    const hasImageHint = detectImageHint(messages, rawPayload);
-    if (hasImageHint) {
-        // 有图片线索时不干预工具列表，保持由上游（Codex 等）决定 view_image 的暴露与使用。
-        return chatRequest;
-    }
-    const filteredTools = tools.filter((tool) => {
-        if (!tool || typeof tool !== 'object')
-            return false;
-        const fn = tool.function;
-        if (!fn || typeof fn !== 'object')
-            return true;
-        const name = fn.name;
-        if (typeof name !== 'string')
-            return true;
-        return name.trim() !== 'view_image';
-    });
-    if (filteredTools.length === tools.length) {
-        return chatRequest;
-    }
-    return {
-        ...chatRequest,
-        tools: filteredTools
-    };
-}
-function detectImageHint(messages, rawPayload) {
-    const patterns = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg'];
-    const hasImageExt = (value) => {
-        if (typeof value !== 'string' || !value)
-            return false;
-        const lower = value.toLowerCase();
-        return patterns.some(ext => lower.includes(ext));
-    };
-    const hasImageInMessage = (msg) => {
-        if (!msg || typeof msg !== 'object')
-            return false;
-        const m = msg;
-        const content = m.content;
-        if (typeof content === 'string') {
-            if (hasImageExt(content))
-                return true;
-        }
-        else if (Array.isArray(content)) {
-            for (const part of content) {
-                if (!part || typeof part !== 'object')
-                    continue;
-                const p = part;
-                const t = String(p.type || '').toLowerCase();
-                if (t.includes('image')) {
-                    return true;
-                }
-                if (hasImageExt(p.text))
-                    return true;
-                const imageUrl = typeof p.image_url === 'string'
-                    ? p.image_url
-                    : p.image_url && typeof p.image_url.url === 'string'
-                        ? p.image_url.url
-                        : typeof p.url === 'string'
-                            ? p.url
-                            : undefined;
-                if (hasImageExt(imageUrl))
-                    return true;
-                if (hasImageExt(p.path))
-                    return true;
-            }
-        }
-        return false;
-    };
-    // 仅考虑“当前这一轮”的用户输入是否包含图片链接或图片负载，避免因为历史上下文中曾经出现过图片而在后续轮次持续暴露 view_image。
-    if (Array.isArray(messages)) {
-        for (let i = messages.length - 1; i >= 0; i -= 1) {
-            const msg = messages[i];
-            if (!msg || typeof msg !== 'object')
-                continue;
-            const role = String(msg.role || '').toLowerCase();
-            if (role !== 'user')
-                continue;
-            if (hasImageInMessage(msg)) {
-                return true;
-            }
-            break;
-        }
-    }
-    if (rawPayload && typeof rawPayload === 'object') {
-        const text = rawPayload.content;
-        if (hasImageExt(text)) {
-            return true;
-        }
-    }
-    return false;
+    return chatRequest;
 }
 export async function runChatResponseToolFilters(chatJson, options = {}) {
     const resCtxBase = {
@@ -220,9 +127,7 @@ export async function runChatResponseToolFilters(chatJson, options = {}) {
     recordStage('resp_process_tool_filters_input', chatJson);
     try {
         if (chatJson && typeof chatJson === 'object') {
-            normalizeChatResponseReasoningTools(chatJson, {
-                idPrefixBase: 'reasoning_choice'
-            });
+            chatJson = normalizeChatResponseReasoningTools(chatJson, 'reasoning_choice');
         }
     }
     catch {

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

@@ -8,6 +8,12 @@ export interface ToolGovernanceOptions {
         baseDir?: string;
     };
 }
+/**
+ * Process OpenAI Chat request (messages/tools) with unified 标准 governance.
+ * - Augment tools (strict schemas)
+ * - Inject/Refine system tool guidance (idempotent)
+ * - Canonicalize structured tool_calls; set content=null when applicable
+ */
 export declare function processChatRequestTools(request: Unknown, opts?: ToolGovernanceOptions): Unknown;
 export declare function normalizeApplyPatchToolCallsOnResponse(chat: Unknown): Unknown;
 export declare function normalizeApplyPatchToolCallsOnRequest(request: Unknown): Unknown;