@jsonstudio/llms 0.6.3275 → 0.6.3379

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

@@ -1,386 +1,23 @@
-// Unified tool harvesting (对齐, single entry)
-// - First-time harvesting only (no late-stage repair)
-// - Handles textual markers (<function=execute>, structured apply_patch payloads)
-// - Handles structural shapes (function_call legacy, tool_calls)
-// - Normalizes arguments (single JSON string), sets finish_reason when applicable
-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);
-}
-// Adjacent dedupe state (per request)
-const dedupeState = new Map();
-function hashString(s) {
-    try {
-        return require('crypto').createHash('sha1').update(s).digest('hex');
-    }
-    catch {
-        return String(s.length);
-    }
-}
-function toJsonString(v) {
-    return repairArgumentsToStringWithNative(v);
-}
-function genId(ctx, i = 0) {
-    const p = ctx?.idPrefix || 'call';
-    return `${p}_${Date.now()}_${(Math.random().toString(36).slice(2, 8))}_${i}`;
-}
-function chunkString(input, size) {
-    try {
-        const s = String(input ?? '');
-        if (!s)
-            return [];
-        const out = [];
-        for (let i = 0; i < s.length; i += size)
-            out.push(s.slice(i, i + size));
-        return out;
-    }
-    catch {
-        return [String(input ?? '')];
-    }
-}
-function extractFromTextual(content, ctx) {
-    const events = [];
-    if (typeof content !== 'string' || !content)
-        return events;
-    // 1) structured apply_patch payload
-    const structuredPayloads = extractStructuredApplyPatchPayloads(content);
-    if (structuredPayloads.length) {
-        let idx = 0;
-        for (const payload of structuredPayloads) {
-            const id = genId(ctx, idx);
-            const argStr = toJsonString(payload);
-            events.push({ tool_calls: [{ index: idx, id, type: 'function', function: { name: 'apply_patch' } }] });
-            const parts = chunkString(argStr, Math.max(32, Math.min(1024, ctx?.chunkSize || 256)));
-            for (const d of parts) {
-                events.push({ tool_calls: [{ index: idx, id, type: 'function', function: { arguments: d } }] });
-            }
-            idx += 1;
-        }
-        return events;
-    }
-    // 2) <function=execute>
-    const execRe = /<function=execute>[\s\S]*?<parameter=command>([\s\S]*?)<\/parameter>[\s\S]*?<\/function=execute>/i;
-    const mExec = execRe.exec(content);
-    if (mExec && mExec[1]) {
-        const cmdRaw = mExec[1].trim();
-        const argv = splitCommand(cmdRaw);
-        const id = genId(ctx, 0);
-        const argStr = toJsonString({ command: argv });
-        events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { name: 'shell' } }] });
-        const parts = chunkString(argStr, Math.max(32, Math.min(1024, ctx?.chunkSize || 256)));
-        for (const d of parts) {
-            events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { arguments: d } }] });
-        }
-        return events;
-    }
-    // 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;
-        const blocks = content.match(blockRe) || [];
-        let matched = false;
-        for (const b of blocks) {
-            const nameTag = /<tool_name>([\s\S]*?)<\/tool_name>/i.exec(b);
-            let nm = nameTag && nameTag[1] ? String(nameTag[1]).trim() : '';
-            if (!nm) {
-                if (/<arg_key>\s*command\s*<\/arg_key>/i.test(b))
-                    nm = 'shell';
-                else if (/\bapply_patch\b/i.test(b))
-                    nm = 'apply_patch';
-                else if (/\bupdate_plan\b/i.test(b))
-                    nm = 'update_plan';
-                else if (/\bview_image\b/i.test(b))
-                    nm = 'view_image';
-            }
-            const pairRe = /<arg_key>([\s\S]*?)<\/arg_key>\s*<arg_value>([\s\S]*?)<\/arg_value>/gi;
-            const argsObj = {};
-            let m;
-            while ((m = pairRe.exec(b)) !== null) {
-                const k = String((m[1] || '').trim());
-                const vRaw = (m[2] || '').trim();
-                let v = vRaw;
-                try {
-                    v = JSON.parse(vRaw);
-                }
-                catch { /* keep as string */ }
-                if (nm === 'shell' && k === 'command') {
-                    if (!Array.isArray(v))
-                        v = splitCommand(String(vRaw));
-                }
-                argsObj[k] = v;
-            }
-            if (nm) {
-                const id = genId(ctx, 0);
-                events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { name: nm } }] });
-                const argStr = toJsonString(argsObj);
-                const parts = chunkString(argStr, Math.max(32, Math.min(1024, ctx?.chunkSize || 256)));
-                for (const d of parts) {
-                    events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { arguments: d } }] });
-                }
-                matched = true;
-            }
-        }
-        if (matched)
-            return events;
-        // Inline fallback: e.g., 'shell\n<arg_key>command</arg_key>...'
-        const inlineRe = /(shell|apply_patch|update_plan|view_image)[\s\S]*?<arg_key>([\s\S]*?)<\/arg_key>\s*<arg_value>([\s\S]*?)<\/arg_value>/i;
-        const mi = inlineRe.exec(content);
-        if (mi) {
-            const nm = String(mi[1]).trim();
-            const k = String(mi[2]).trim();
-            const vRaw = String(mi[3]).trim();
-            let v = vRaw;
-            try {
-                v = JSON.parse(vRaw);
-            }
-            catch { /* keep as string */ }
-            const args = {};
-            if (nm === 'shell' && k === 'command') {
-                if (!Array.isArray(v))
-                    v = splitCommand(String(vRaw));
-            }
-            args[k] = v;
-            const id = genId(ctx, 0);
-            events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { name: nm } }] });
-            const argStr = toJsonString(args);
-            for (const d of chunkString(argStr, Math.max(32, Math.min(1024, ctx?.chunkSize || 256)))) {
-                events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { arguments: d } }] });
-            }
-            return events;
-        }
-    }
-    catch { /* ignore textual tool_call parse errors */ }
-    return events;
-}
-function extractStructuredApplyPatchPayloads(text) {
-    const payloads = [];
-    try {
-        const fenceRe = /```(?:json|apply_patch|toon)?\s*([\s\S]*?)\s*```/gi;
-        let fm;
-        while ((fm = fenceRe.exec(text)) !== null) {
-            const body = fm[1] || '';
-            try {
-                const parsed = JSON.parse(body);
-                if (isStructuredApplyPatchPayload(parsed)) {
-                    payloads.push(parsed);
-                }
-            }
-            catch { /* ignore invalid JSON */ }
-        }
-        if (!payloads.length && typeof text === 'string' && text.includes('"changes"')) {
-            try {
-                const parsed = JSON.parse(text);
-                if (isStructuredApplyPatchPayload(parsed)) {
-                    payloads.push(parsed);
-                }
-            }
-            catch { /* ignore */ }
-        }
-    }
-    catch { /* ignore */ }
-    return payloads;
-}
-function splitCommand(s) {
-    try {
-        const out = [];
-        let cur = '';
-        let quote = null;
-        for (let i = 0; i < s.length; i++) {
-            const ch = s[i];
-            if (quote) {
-                if (ch === quote) {
-                    quote = null;
-                }
-                else {
-                    cur += ch;
-                }
-            }
-            else {
-                if (ch === '"' || ch === '\'') {
-                    quote = ch;
-                }
-                else if (/\s/.test(ch)) {
-                    if (cur) {
-                        out.push(cur);
-                        cur = '';
-                    }
-                }
-                else {
-                    cur += ch;
-                }
-            }
-        }
-        if (cur)
-            out.push(cur);
-        return out;
-    }
-    catch {
-        return [s];
+import { harvestToolsWithNative } from '../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
+function assertToolHarvesterNativeAvailable() {
+    if (typeof harvestToolsWithNative !== 'function') {
+        throw new Error('[tool-harvester] native bindings are required');
     }
 }
 export function harvestTools(signal, ctx) {
-    const result = { deltaEvents: [] };
-    const chunkSize = Math.max(32, Math.min(1024, ctx?.chunkSize || 256));
-    try {
-        if (signal.type === 'delta') {
-            // OpenAI streaming chunk delta
-            const delta = signal.payload;
-            const events = [];
-            const content = delta?.choices?.[0]?.delta?.content;
-            if (typeof content === 'string' && content.trim()) {
-                events.push(...extractFromTextual(content, ctx));
-            }
-            // legacy function_call → tool_calls
-            const fc = delta?.choices?.[0]?.delta?.function_call;
-            if (isObject(fc)) {
-                const name = typeof fc.name === 'string' ? fc.name : undefined;
-                const argStr = toJsonString(fc.arguments);
-                const id = genId(ctx, 0);
-                if (name) {
-                    events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { name } }] });
-                    for (const d of chunkString(argStr, chunkSize)) {
-                        events.push({ tool_calls: [{ index: 0, id, type: 'function', function: { arguments: d } }] });
-                    }
-                }
-            }
-            // direct delta.tool_calls
-            const tcd = delta?.choices?.[0]?.delta?.tool_calls;
-            if (Array.isArray(tcd)) {
-                let idx = 0;
-                for (const tc of tcd) {
-                    const id = typeof tc?.id === 'string' ? tc.id : genId(ctx, idx);
-                    const name = typeof tc?.function?.name === 'string' ? tc.function.name : undefined;
-                    const args = (tc?.function?.arguments !== undefined) ? toJsonString(tc.function.arguments) : undefined;
-                    // Adjacent dedupe per requestId
-                    const key = ctx?.requestId || 'default';
-                    const state = dedupeState.get(key) || {};
-                    const argsHash = typeof args === 'string' ? hashString(args) : undefined;
-                    const isDup = (state.name === name && state.argsHash && argsHash && state.argsHash === argsHash);
-                    if (!isDup) {
-                        if (name) {
-                            events.push({ tool_calls: [{ index: idx, id, type: 'function', function: { name } }] });
-                        }
-                        if (typeof args === 'string') {
-                            for (const d of chunkString(args, chunkSize)) {
-                                events.push({ tool_calls: [{ index: idx, id, type: 'function', function: { arguments: d } }] });
-                            }
-                        }
-                        dedupeState.set(key, { name, argsHash });
-                    }
-                    idx += 1;
-                }
-            }
-            result.deltaEvents = events;
-            return result;
-        }
-        // final/compat: normalize choices[0].message.tool_calls (no synthesis)
-        const src = signal.payload;
-        const choice = Array.isArray(src?.choices) ? src.choices[0] : null;
-        const msg = choice?.message || {};
-        const toolCalls = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
-        if (toolCalls.length > 0) {
-            // Ensure arguments are stringified
-            for (const tc of toolCalls) {
-                const fn = tc.function || {};
-                if (fn && fn.arguments && typeof fn.arguments !== 'string') {
-                    fn.arguments = toJsonString(fn.arguments);
-                }
-            }
-            // finish_reason
-            if (choice && choice.finish_reason !== 'tool_calls') {
-                choice.finish_reason = 'tool_calls';
-            }
-            // content policy: set to empty string or null unchanged
-            result.normalized = src;
-            return result;
-        }
-        // If no structured tool_calls, attempt textual harvesting from message.content
-        try {
-            const content = msg?.content;
-            if (typeof content === 'string' && content.trim()) {
-                const evs = extractFromTextual(content, ctx);
-                if (Array.isArray(evs) && evs.length > 0) {
-                    // Aggregate deltaEvents into final tool_calls (group by id)
-                    const map = {};
-                    for (const e of evs) {
-                        const tcs = Array.isArray(e.tool_calls) ? e.tool_calls : [];
-                        for (const t of tcs) {
-                            const id = String(t.id || genId(ctx, 0));
-                            if (!map[id])
-                                map[id] = { name: undefined, args: [], type: 'function' };
-                            const nm = t.function?.name;
-                            const arg = t.function?.arguments;
-                            if (typeof nm === 'string' && !map[id].name)
-                                map[id].name = nm;
-                            if (typeof arg === 'string')
-                                map[id].args.push(arg);
-                        }
-                    }
-                    const merged = [];
-                    for (const [id, item] of Object.entries(map)) {
-                        const argStr = item.args.join('');
-                        merged.push({ id, type: 'function', function: { name: item.name, arguments: argStr } });
-                    }
-                    if (merged.length > 0) {
-                        msg.tool_calls = merged;
-                        // Clear textual content to avoid duplicate display
-                        msg.content = '';
-                        if (choice && choice.finish_reason !== 'tool_calls') {
-                            choice.finish_reason = 'tool_calls';
-                        }
-                        result.normalized = src;
-                        return result;
-                    }
-                }
-            }
-        }
-        catch { /* ignore textual harvest on final */ }
-        result.normalized = src;
-        return result;
-    }
-    catch {
-        return result;
-    }
+    assertToolHarvesterNativeAvailable();
+    const result = harvestToolsWithNative({
+        signal: signal,
+        context: ctx
+    });
+    const normalized = result?.normalized;
+    if (normalized && signal?.payload && typeof signal.payload === 'object') {
+        const target = signal.payload;
+        const next = normalized;
+        for (const key of Object.keys(target)) {
+            delete target[key];
+        }
+        Object.assign(target, next);
+    }
+    return result;
 }

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

@@ -9,11 +9,10 @@ export interface ToolCallItem {
     type: 'function';
     function: ToolCallFunction;
 }
-export declare function stringifyArgs(args: unknown): string;
 export interface BridgeToolMapOptions {
-    sanitizeName?: (raw: unknown) => string | undefined;
+    sanitizeName?: (name: string) => string | undefined;
 }
-export declare function ensureApplyPatchSchema(seed?: Record<string, unknown>): Record<string, unknown>;
+export declare function stringifyArgs(args: unknown): string;
 export declare function bridgeToolToChatDefinition(rawTool: BridgeToolDefinition | Record<string, unknown> | null | undefined, options?: BridgeToolMapOptions): ChatToolDefinition | null;
 export declare function mapBridgeToolsToChat(rawTools: unknown, options?: BridgeToolMapOptions): ChatToolDefinition[] | undefined;
 export declare function chatToolToBridgeDefinition(rawTool: ChatToolDefinition | Record<string, unknown> | null | undefined, options?: BridgeToolMapOptions): BridgeToolDefinition | null;

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

@@ -1,5 +1,4 @@
-import { sanitizeResponsesFunctionNameWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
-import { mapChatToolsToBridgeWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { bridgeToolToChatDefinitionWithNative, chatToolToBridgeDefinitionWithNative, mapBridgeToolsToChatWithNative, mapChatToolsToBridgeWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export function stringifyArgs(args) {
     if (typeof args === 'string')
         return args;
@@ -10,212 +9,57 @@ export function stringifyArgs(args) {
         return String(args);
     }
 }
-function isPlainObject(value) {
-    return !!value && typeof value === 'object' && !Array.isArray(value);
-}
-function clonePlainObject(value) {
-    try {
-        return JSON.parse(JSON.stringify(value));
-    }
-    catch {
-        return { ...value };
-    }
-}
-function asSchema(value) {
-    if (isPlainObject(value)) {
-        return clonePlainObject(value);
-    }
-    return undefined;
-}
-function isTruthyEnv(value) {
-    const v = typeof value === 'string' ? value.trim().toLowerCase() : '';
-    return v === '1' || v === 'true' || v === 'yes' || v === 'on';
-}
-export function ensureApplyPatchSchema(seed) {
-    const schema = seed ? { ...seed } : {};
-    schema.type = typeof schema.type === 'string' ? schema.type : 'object';
-    const properties = isPlainObject(schema.properties) ? { ...schema.properties } : {};
-    properties.patch = {
-        type: 'string',
-        description: 'Patch text (*** Begin Patch / *** End Patch or GNU unified diff).'
-    };
-    properties.input = { type: 'string', description: 'Alias of patch (patch text). Prefer patch.' };
-    schema.properties = properties;
-    const requiredList = Array.isArray(schema.required)
-        ? schema.required.filter((entry) => typeof entry === 'string')
-        : [];
-    if (!requiredList.includes('patch')) {
-        requiredList.push('patch');
-    }
-    schema.required = requiredList;
-    if (typeof schema.additionalProperties !== 'boolean') {
-        schema.additionalProperties = false;
-    }
-    return schema;
-}
-function enforceBuiltinToolSchema(name, candidate) {
-    const normalizedName = typeof name === 'string' ? name.trim().toLowerCase() : '';
-    if (normalizedName === 'apply_patch') {
-        const base = asSchema(candidate);
-        return ensureApplyPatchSchema(base);
-    }
-    if (normalizedName === 'web_search') {
-        // For web_search we currently accept any incoming schema and fall back to a
-        // minimal object definition. Server-side web_search execution only relies
-        // on the function name + JSON arguments, so tool schema is best-effort.
-        const base = asSchema(candidate) ?? {};
-        if (!base.type) {
-            base.type = 'object';
-        }
-        if (!Object.prototype.hasOwnProperty.call(base, 'properties')) {
-            base.properties = {};
-        }
-        return base;
-    }
-    return asSchema(candidate);
-}
-const DEFAULT_SANITIZER = (value) => {
-    return sanitizeResponsesFunctionNameWithNative(value);
-};
-function resolveToolName(candidate, options) {
-    const sanitized = options?.sanitizeName?.(candidate);
-    if (typeof sanitized === 'string' && sanitized.trim().length) {
-        return sanitized.trim();
-    }
-    return DEFAULT_SANITIZER(candidate);
-}
-function pickToolName(candidates, options) {
-    for (const candidate of candidates) {
-        const name = resolveToolName(candidate, options);
-        if (name) {
-            return name;
-        }
-    }
-    return undefined;
-}
-function resolveToolDescription(candidate) {
-    if (typeof candidate === 'string') {
-        return candidate;
+function assertToolMappingNativeAvailable() {
+    if (typeof bridgeToolToChatDefinitionWithNative !== 'function' ||
+        typeof chatToolToBridgeDefinitionWithNative !== 'function' ||
+        typeof mapBridgeToolsToChatWithNative !== 'function' ||
+        typeof mapChatToolsToBridgeWithNative !== 'function') {
+        throw new Error('[tool-mapping] native bindings unavailable');
     }
-    return undefined;
 }
-function resolveToolParameters(container, fallback) {
-    if (container && Object.prototype.hasOwnProperty.call(container, 'parameters')) {
-        return container.parameters;
+function resolveSanitizeMode(options, fallback = 'responses') {
+    const probe = options?.sanitizeName?.('shell_command') ?? options?.sanitizeName?.('Bash');
+    if (typeof probe === 'string' && probe === 'shell_command') {
+        return 'anthropic';
     }
-    if (fallback && Object.prototype.hasOwnProperty.call(fallback, 'parameters')) {
-        return fallback.parameters;
+    if (typeof probe === 'string' && probe === 'Bash') {
+        return 'anthropic_denormalize';
     }
-    return undefined;
-}
-function resolveToolStrict(container, fallback) {
-    if (container && typeof container.strict === 'boolean') {
-        return container.strict;
-    }
-    if (fallback && typeof fallback.strict === 'boolean') {
-        return fallback.strict;
-    }
-    return undefined;
+    return fallback;
 }
 export function bridgeToolToChatDefinition(rawTool, options) {
     if (!rawTool || typeof rawTool !== 'object') {
         return null;
     }
-    const tool = rawTool;
-    const fnNode = tool.function && typeof tool.function === 'object' ? tool.function : undefined;
-    let name = pickToolName([fnNode?.name, tool.name], options);
-    // Special case for Responses builtin web_search tools:
-    // Codex / Claude‑code may send tools shaped as `{ type: "web_search", ... }`
-    // without a nested `function` node. Treat these as a canonical `web_search`
-    // function tool so downstream Chat / Standardized layers can reason over a
-    // single function-style web_search surface.
-    if (!name) {
-        const rawType = typeof tool.type === 'string' ? tool.type.trim().toLowerCase() : '';
-        if (rawType === 'web_search' || rawType.startsWith('web_search')) {
-            name = 'web_search';
-        }
-    }
-    if (!name)
-        return null;
-    const description = resolveToolDescription(fnNode?.description ?? tool.description);
-    const parameters = enforceBuiltinToolSchema(name, resolveToolParameters(fnNode, tool));
-    const strict = resolveToolStrict(fnNode, tool);
-    const rawType = typeof tool.type === 'string' && tool.type.trim().length ? tool.type.trim() : 'function';
-    const normalizedType = rawType.toLowerCase() === 'custom' ? 'function' : rawType;
-    const fnOut = { name };
-    if (description !== undefined) {
-        fnOut.description = description;
-    }
-    if (parameters !== undefined) {
-        fnOut.parameters = parameters;
-    }
-    if (strict !== undefined) {
-        fnOut.strict = strict;
-    }
-    return {
-        type: normalizedType,
-        function: fnOut
-    };
+    assertToolMappingNativeAvailable();
+    const sanitizeMode = resolveSanitizeMode(options, 'responses');
+    const mapped = bridgeToolToChatDefinitionWithNative(rawTool, { sanitizeMode });
+    return mapped ?? null;
 }
 export function mapBridgeToolsToChat(rawTools, options) {
     if (!Array.isArray(rawTools) || rawTools.length === 0) {
         return undefined;
     }
-    const mapped = rawTools
-        .map((entry) => bridgeToolToChatDefinition(entry, options))
-        .filter((entry) => !!entry);
+    assertToolMappingNativeAvailable();
+    const sanitizeMode = resolveSanitizeMode(options, 'responses');
+    const mapped = mapBridgeToolsToChatWithNative(rawTools, { sanitizeMode });
     return mapped.length ? mapped : undefined;
 }
 export function chatToolToBridgeDefinition(rawTool, options) {
     if (!rawTool || typeof rawTool !== 'object') {
         return null;
     }
-    const tool = rawTool;
-    const fnNode = tool.function && typeof tool.function === 'object' ? tool.function : undefined;
-    const name = pickToolName([fnNode?.name, tool.name], options);
-    if (!name) {
-        return null;
-    }
-    const description = resolveToolDescription(fnNode?.description);
-    const parameters = enforceBuiltinToolSchema(name, resolveToolParameters(fnNode, undefined));
-    const strict = resolveToolStrict(fnNode, undefined);
-    const normalizedType = typeof tool.type === 'string' && tool.type.trim().length ? tool.type.trim() : 'function';
-    const responseShape = {
-        type: normalizedType,
-        name
-    };
-    if (description !== undefined) {
-        responseShape.description = description;
-    }
-    if (parameters !== undefined) {
-        responseShape.parameters = parameters;
-    }
-    if (strict !== undefined) {
-        responseShape.strict = strict;
-    }
-    const fnOut = { name };
-    if (description !== undefined) {
-        fnOut.description = description;
-    }
-    if (parameters !== undefined) {
-        fnOut.parameters = parameters;
-    }
-    if (strict !== undefined) {
-        fnOut.strict = strict;
-    }
-    responseShape.function = fnOut;
-    return responseShape;
+    assertToolMappingNativeAvailable();
+    const sanitizeMode = resolveSanitizeMode(options, 'responses');
+    const mapped = chatToolToBridgeDefinitionWithNative(rawTool, { sanitizeMode });
+    return mapped ?? null;
 }
 export function mapChatToolsToBridge(rawTools, options) {
     if (!Array.isArray(rawTools) || rawTools.length === 0) {
         return undefined;
     }
-    if (!options?.sanitizeName) {
-        const mapped = mapChatToolsToBridgeWithNative(rawTools);
-        return mapped && mapped.length ? mapped : undefined;
-    }
-    const mapped = rawTools
-        .map((entry) => chatToolToBridgeDefinition(entry, options))
-        .filter((entry) => !!entry);
+    assertToolMappingNativeAvailable();
+    const sanitizeMode = resolveSanitizeMode(options, 'responses');
+    const mapped = mapChatToolsToBridgeWithNative(rawTools, { sanitizeMode });
     return mapped.length ? mapped : undefined;
 }