@jsonstudio/llms 0.6.2172 → 0.6.3214

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

@@ -1,12 +1,13 @@
 import { evaluateResponsesHostPolicy } from '../responses-host-policy.js';
-import { canonicalizeChatResponseTools } from '../../shared/tool-canonicalizer.js';
 import { normalizeMessageReasoningTools } from '../../shared/reasoning-tool-normalizer.js';
-import { createBridgeActionState, runBridgeActionPipeline } from '../../shared/bridge-actions.js';
-import { resolveBridgePolicy, resolvePolicyActions } from '../../shared/bridge-policies.js';
+import { createBridgeActionState, runBridgeActionPipeline } from '../../bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from '../../bridge-policies.js';
 import { buildResponsesOutputFromChat } from '../../shared/responses-output-builder.js';
 import { consumeResponsesPayloadSnapshot, consumeResponsesPassthrough } from '../../shared/responses-reasoning-registry.js';
 import { sanitizeResponsesFunctionName, stripInternalToolingMetadata } from '../../shared/responses-tool-utils.js';
-import { ProviderProtocolError } from '../../shared/errors.js';
+import { ProviderProtocolError } from '../../provider-protocol-error.js';
+import { normalizeResponsesToolCallArgumentsForClientWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+import { normalizeChatResponseReasoningToolsWithNative } from '../../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
 function isPlainObject(value) {
     return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }
@@ -76,6 +77,9 @@ function mergeResponseOutputItems(baseOutput, sourceOutput) {
         if (isMissingResponseField(baseItem.summary) && sourceItem.summary !== undefined) {
             baseItem.summary = deepCloneRecord({ value: sourceItem.summary }).value;
         }
+        if (isMissingResponseField(baseItem.encrypted_content) && sourceItem.encrypted_content !== undefined) {
+            baseItem.encrypted_content = deepCloneRecord({ value: sourceItem.encrypted_content }).value;
+        }
         return baseItem;
     });
 }
@@ -267,90 +271,13 @@ function normalizeResponsesToolCallArgumentsForClient(responsesPayload, context)
     if (!toolsRaw.length) {
         return;
     }
-    const toolIndex = buildClientToolIndex(toolsRaw);
-    if (!toolIndex.size) {
-        return;
-    }
-    const normalizeCallArgs = (toolName, argsRaw) => {
-        const spec = toolIndex.get(toolName);
-        if (!spec)
-            return argsRaw;
-        // format:"freeform" means client expects raw text (not JSON) in the arguments field.
-        if (typeof spec.format === 'string' && spec.format.trim().toLowerCase() === 'freeform') {
-            const rawText = extractFreeformTextFromArgs(argsRaw);
-            if (rawText && rawText.trim().length) {
-                return rawText;
-            }
-            return argsRaw;
-        }
-        // Schema-aware key alignment for common server-side tools.
-        const params = spec.parameters;
-        if (!params)
-            return argsRaw;
-        const schema = extractJsonSchemaLike(params);
-        if (!schema)
-            return argsRaw;
-        const parsed = tryParseJson(argsRaw);
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return argsRaw;
-        }
-        const record = parsed;
-        const repaired = repairToolArgsBySchemaKeys(toolName, record, schema);
-        if (!repaired) {
-            return argsRaw;
-        }
-        try {
-            return JSON.stringify(repaired);
-        }
-        catch {
-            return argsRaw;
-        }
-    };
-    // 1) output[] function_call items
-    const output = Array.isArray(responsesPayload.output) ? responsesPayload.output : [];
-    for (const item of output) {
-        if (!item || typeof item !== 'object')
-            continue;
-        const type = typeof item.type === 'string' ? String(item.type).trim().toLowerCase() : '';
-        if (type !== 'function_call')
-            continue;
-        const name = typeof item.name === 'string' ? String(item.name).trim() : '';
-        if (!name)
-            continue;
-        const targetName = resolveClientToolName(toolIndex, name);
-        if (!targetName)
-            continue;
-        if (targetName !== name) {
-            item.name = targetName;
-        }
-        item.arguments = normalizeCallArgs(targetName, item.arguments);
-    }
-    // 2) required_action.submit_tool_outputs.tool_calls[] tool calls
-    const toolCalls = responsesPayload?.required_action?.submit_tool_outputs?.tool_calls;
-    const calls = Array.isArray(toolCalls) ? toolCalls : [];
-    for (const call of calls) {
-        if (!call || typeof call !== 'object')
-            continue;
-        const fn = call.function && typeof call.function === 'object' && !Array.isArray(call.function) ? call.function : null;
-        const name = (typeof fn?.name === 'string' ? String(fn.name).trim() : '') ||
-            (typeof call.name === 'string' ? String(call.name).trim() : '');
-        if (!name)
-            continue;
-        const targetName = resolveClientToolName(toolIndex, name);
-        if (!targetName)
-            continue;
-        if (typeof call.name === 'string' && call.name !== targetName) {
-            call.name = targetName;
-        }
-        if (fn && typeof fn === 'object' && fn.name !== targetName) {
-            fn.name = targetName;
-        }
-        const normalizedArgs = normalizeCallArgs(targetName, fn?.arguments ?? call.arguments);
-        if (fn && typeof fn === 'object') {
-            fn.arguments = normalizedArgs;
+    const normalized = normalizeResponsesToolCallArgumentsForClientWithNative(responsesPayload, toolsRaw);
+    for (const key of Object.keys(responsesPayload)) {
+        if (!Object.prototype.hasOwnProperty.call(normalized, key)) {
+            delete responsesPayload[key];
         }
-        call.arguments = normalizedArgs;
     }
+    Object.assign(responsesPayload, normalized);
 }
 function unwrapData(value) {
     let current = value;
@@ -457,7 +384,7 @@ export function buildResponsesPayloadFromChat(payload, context) {
         }
         return mergedFallback;
     }
-    const canonical = canonicalizeChatResponseTools(response);
+    const canonical = normalizeChatResponseReasoningToolsWithNative(response);
     const choices = Array.isArray(canonical?.choices) ? canonical.choices : [];
     const primaryChoice = choices[0] && typeof choices[0] === 'object' ? choices[0] : undefined;
     const message = primaryChoice && typeof primaryChoice.message === 'object' ? primaryChoice.message : undefined;

package/dist/conversion/responses/responses-openai-bridge/types.d.ts

@@ -1,10 +1,11 @@
-import type { BridgeInputItem, BridgeToolDefinition } from '../../shared/bridge-message-types.js';
+import type { BridgeInputItem, BridgeToolDefinition } from '../../types/bridge-message-types.js';
 import type { ChatToolDefinition } from '../../hub/types/chat-envelope.js';
 import type { JsonObject, JsonValue } from '../../hub/types/json.js';
 import type { ToolCallIdStyle } from '../../shared/responses-tool-utils.js';
 export type Unknown = Record<string, unknown>;
 export interface ResponsesRequestContext extends Unknown {
     requestId?: string;
+    targetProtocol?: string;
     originalSystemMessages?: string[];
     input?: BridgeInputItem[];
     include?: unknown;

package/dist/conversion/responses/responses-openai-bridge.d.ts

@@ -1,4 +1,4 @@
-import type { BridgeInputBuildResult } from '../shared/bridge-message-utils.js';
+import type { BridgeInputBuildResult } from '../bridge-message-utils.js';
 import type { BuildChatRequestResult, BuildResponsesRequestResult, ResponsesRequestContext } from './responses-openai-bridge/types.js';
 export type { BuildChatRequestResult, BuildResponsesRequestResult, ResponsesRequestContext } from './responses-openai-bridge/types.js';
 export declare function captureResponsesContext(payload: Record<string, unknown>, dto?: {

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

@@ -1,18 +1,20 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { ensureBridgeInstructions } from '../shared/bridge-instructions.js';
+import { ensureBridgeInstructions } from '../bridge-instructions.js';
 import { evaluateResponsesHostPolicy } from './responses-host-policy.js';
-import { convertMessagesToBridgeInput, convertBridgeInputToChatMessages } from '../shared/bridge-message-utils.js';
+import { convertBridgeInputToChatMessages } from '../bridge-message-utils.js';
 import { createToolCallIdTransformer, enforceToolCallIdStyle, resolveToolCallIdStyle, sanitizeResponsesFunctionName } from '../shared/responses-tool-utils.js';
-import { mapBridgeToolsToChat, mapChatToolsToBridge } from '../shared/tool-mapping.js';
-import { ProviderProtocolError } from '../shared/errors.js';
-import { readRuntimeMetadata } from '../shared/runtime-metadata.js';
-import { clampResponsesInputItemId } from '../shared/bridge-id-utils.js';
-import { isImagePath } from '../shared/media.js';
+import { mapChatToolsToBridge } from '../shared/tool-mapping.js';
+import { ProviderProtocolError } from '../provider-protocol-error.js';
+import { readRuntimeMetadata } from '../runtime-metadata.js';
+import { clampResponsesInputItemId } from '../bridge-id-utils.js';
+import { isImagePath } from '../media.js';
+import { captureReqInboundResponsesContextSnapshotWithNative, mapReqInboundBridgeToolsToChatWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+import { buildBridgeHistoryWithNative } from '../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
 // --- Utilities (ported strictly) ---
-import { createBridgeActionState, runBridgeActionPipeline } from '../shared/bridge-actions.js';
-import { resolveBridgePolicy, resolvePolicyActions } from '../shared/bridge-policies.js';
+import { createBridgeActionState, runBridgeActionPipeline } from '../bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from '../bridge-policies.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -43,7 +45,7 @@ function filterBridgeInputForUpstream(input, options) {
         return [clone];
     });
 }
-// normalizeTools unified in ../shared/args-mapping.ts
+// normalizeTools unified in ../args-mapping.ts
 // --- Structured self-repair helpers for tool failures (Responses path) ---
 const IMAGE_MIME_BY_EXT = {
     '.png': 'image/png',
@@ -236,65 +238,40 @@ function appendLocalImageBlockOnLatestUserInput(messages, context) {
 export function captureResponsesContext(payload, dto) {
     const preservedInput = cloneBridgeEntries(payload.input);
     ensureBridgeInstructions(payload);
-    const inheritedParameters = payload.parameters && typeof payload.parameters === 'object'
-        ? { ...payload.parameters }
-        : {};
-    const topLevelParameterKeys = [
-        'temperature',
-        'top_p',
-        'max_tokens',
-        'max_output_tokens',
-        'seed',
-        'logit_bias',
-        'user',
-        'parallel_tool_calls',
-        'tool_choice',
-        'response_format',
-        'service_tier',
-        'truncation',
-        'include',
-        'store',
-        'prompt_cache_key',
-        'reasoning'
-    ];
-    for (const key of topLevelParameterKeys) {
-        if (payload[key] !== undefined && inheritedParameters[key] === undefined) {
-            inheritedParameters[key] = payload[key];
-        }
-    }
-    const context = {
-        requestId: dto?.route?.requestId,
-        input: preservedInput,
-        include: payload.include,
-        store: payload.store,
-        serviceTier: payload.service_tier,
-        truncation: payload.truncation,
-        toolChoice: payload.tool_choice,
-        parallelToolCalls: typeof payload.parallel_tool_calls === 'boolean' ? payload.parallel_tool_calls : undefined,
-        metadata: (payload.metadata && typeof payload.metadata === 'object') ? payload.metadata : undefined,
-        responseFormat: payload.response_format,
-        stream: typeof payload.stream === 'boolean' ? payload.stream : undefined,
-        isChatPayload: Array.isArray(payload.messages)
+    const requestForCapture = {
+        ...payload,
+        ...(preservedInput ? { input: preservedInput } : {})
     };
-    if (Object.keys(inheritedParameters).length) {
-        context.parameters = inheritedParameters;
+    const captured = captureReqInboundResponsesContextSnapshotWithNative({
+        rawRequest: requestForCapture,
+        requestId: dto?.route?.requestId,
+        toolCallIdStyle: payload?.toolCallIdStyle ?? payload?.metadata?.toolCallIdStyle
+    });
+    const instructionReasoning = payload?.__rcc_reasoning_instructions;
+    if (instructionReasoning !== undefined && instructionReasoning !== null) {
+        const segments = Array.isArray(instructionReasoning) ? instructionReasoning : [instructionReasoning];
+        const normalized = segments
+            .map((entry) => (typeof entry === 'string' ? entry.trim() : String(entry ?? '').trim()))
+            .filter((entry) => entry.length > 0);
+        if (normalized.length) {
+            captured.__rcc_reasoning_instructions_segments = normalized;
+        }
     }
-    if (typeof payload.instructions === 'string' && payload.instructions.trim().length) {
-        context.systemInstruction = payload.instructions;
+    if (preservedInput) {
+        captured.input = preservedInput;
     }
-    if (Array.isArray(payload.tools)) {
-        context.toolsRaw = cloneBridgeEntries(payload.tools);
+    if (!captured.systemInstruction && typeof payload.instructions === 'string' && payload.instructions.trim().length) {
+        captured.systemInstruction = payload.instructions;
     }
-    context.isResponsesPayload = !context.isChatPayload && Array.isArray(context.input);
-    return context;
+    return captured;
 }
 export function buildChatRequestFromResponses(payload, context) {
     // V3: 对 Responses 路径仅做“形状转换”，不做参数解析/修复。
     // 将顶层 { type,name,description,parameters,strict } 归一为 OpenAI Chat tools 形状：
     // { type:'function', function:{ name,description,parameters,strict? } }
-    const toolsNormalized = mapBridgeToolsToChat(payload.tools, {
-        sanitizeName: sanitizeResponsesFunctionName
-    });
+    const toolsNormalized = Array.isArray(context.toolsNormalized) && context.toolsNormalized.length
+        ? cloneBridgeEntries(context.toolsNormalized)
+        : mapReqInboundBridgeToolsToChatWithNative(payload.tools);
     // 不在 Responses 路径进行 MCP 工具注入；统一由 Chat 后半段治理注入
     let messages = convertBridgeInputToChatMessages({
         input: context.input,
@@ -614,7 +591,7 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
         sanitizeBridgeHistory(normalizeBridgeHistory(envelopeMetadata?.bridgeHistory)) ??
         sanitizeBridgeHistory(fallbackHistory);
     const history = historySeed ??
-        sanitizeBridgeHistory(convertMessagesToBridgeInput({
+        sanitizeBridgeHistory(buildBridgeHistoryWithNative({
             messages,
             tools: Array.isArray(out.tools) ? out.tools : undefined
         }));
@@ -629,12 +606,35 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
         typeof envelopeMetadata?.systemInstruction === 'string' && envelopeMetadata.systemInstruction.trim().length ? envelopeMetadata.systemInstruction.trim() : undefined,
         combinedSystemInstruction && combinedSystemInstruction.length > 0 ? combinedSystemInstruction : undefined
     ];
+    let resolvedInstruction;
     for (const candidate of instructionCandidates) {
         if (candidate && candidate.length) {
-            out.instructions = candidate;
+            resolvedInstruction = candidate;
             break;
         }
     }
+    if (resolvedInstruction && resolvedInstruction.length) {
+        const reasoningSegments = (() => {
+            if (!ctx || typeof ctx !== 'object')
+                return [];
+            const ctxAny = ctx;
+            const raw = ctxAny.__rcc_reasoning_instructions_segments;
+            if (!raw)
+                return [];
+            const segments = Array.isArray(raw) ? raw : [raw];
+            return segments
+                .map((entry) => (typeof entry === 'string' ? entry.trim() : String(entry ?? '').trim()))
+                .filter((entry) => entry.length > 0);
+        })();
+        if (reasoningSegments.length) {
+            const combined = `${reasoningSegments.join('\n')}\n${resolvedInstruction}`.trim();
+            out.instructions = combined;
+            out.instructions_is_raw = true;
+        }
+        else {
+            out.instructions = resolvedInstruction;
+        }
+    }
     // 不追加 metadata，以便 roundtrip 与原始 payload 对齐；系统提示直接写入 instructions。
     const upstreamInput = filterBridgeInputForUpstream(input, { allowToolCallId: toolCallIdStyle === 'preserve' });
     if (upstreamInput.length) {

package/dist/conversion/{shared/runtime-metadata.d.ts → runtime-metadata.d.ts}

@@ -1,4 +1,4 @@
-import { type JsonObject } from '../hub/types/json.js';
+import { type JsonObject } from './hub/types/json.js';
 export type RuntimeMetadataCarrier = Record<string, unknown> & {
     __rt?: JsonObject;
 };

package/dist/conversion/runtime-metadata.js

@@ -0,0 +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 = 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 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 = cloneRuntimeMetadataWithNative(carrier);
+    return rt && isJsonObject(rt) ? jsonClone(rt) : undefined;
+}

package/dist/conversion/shared/anthropic-message-utils.js

@@ -1,9 +1,10 @@
-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 { normalizeChatMessageContent } from './chat-output-normalizer.js';
 import { mapBridgeToolsToChat, mapChatToolsToBridge } from './tool-mapping.js';
 import { jsonClone } from '../hub/types/json.js';
-import { ProviderProtocolError } from './errors.js';
+import { ProviderProtocolError } from '../provider-protocol-error.js';
+import { parseLenientJsonishWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -15,6 +16,27 @@ function safeJson(v) {
         return '{}';
     }
 }
+function stripOpenAIChatToolAliasFields(messages) {
+    for (const message of messages) {
+        if (!message || typeof message !== 'object') {
+            continue;
+        }
+        const role = String(message.role || '').toLowerCase();
+        if (role === 'assistant' && Array.isArray(message.tool_calls)) {
+            for (const call of message.tool_calls) {
+                if (!call || typeof call !== 'object') {
+                    continue;
+                }
+                delete call.tool_call_id;
+                delete call.call_id;
+            }
+            continue;
+        }
+        if (role === 'tool') {
+            delete message.call_id;
+        }
+    }
+}
 function sanitizeToolUseId(raw) {
     const trimmed = typeof raw === 'string' ? raw.trim() : '';
     if (!trimmed) {
@@ -186,6 +208,28 @@ const ANTHROPIC_TOP_LEVEL_FIELDS = new Set([
     'tool_choice',
     'thinking'
 ]);
+const ANTHROPIC_STABLE_TOOL_SCHEMA_NAMES = new Set([
+    'exec_command',
+    'write_stdin',
+    'apply_patch',
+    'request_user_input',
+    'update_plan',
+    'view_image',
+    'web_search',
+    'clock',
+    'continue_execution',
+    'review'
+]);
+const ANTHROPIC_STABLE_TOOL_SCHEMA_KEYS = new Map([
+    ['exec_command', new Set(['cmd', 'command', 'workdir', 'justification', 'login', 'max_output_tokens', 'sandbox_permissions', 'shell', 'yield_time_ms', 'tty', 'prefix_rule'])],
+    ['write_stdin', new Set(['session_id', 'chars', 'text', 'yield_time_ms', 'max_output_tokens'])],
+    ['apply_patch', new Set(['patch', 'input', 'instructions', 'text', 'file', 'changes'])],
+    ['request_user_input', new Set(['questions'])],
+    ['update_plan', new Set(['explanation', 'plan'])],
+    ['view_image', new Set(['path'])],
+    ['web_search', new Set(['query', 'q', 'domains', 'recency'])],
+    ['clock', new Set(['action', 'items', 'taskId'])]
+]);
 export function normalizeAnthropicToolName(value) {
     if (typeof value !== 'string') {
         return undefined;
@@ -505,6 +549,7 @@ export function buildOpenAIChatFromAnthropic(payload) {
     catch {
         // ignore policy failures
     }
+    stripOpenAIChatToolAliasFields(newMessages);
     return request;
 }
 export function buildAnthropicFromOpenAIChat(oa, options) {
@@ -545,11 +590,22 @@ export function buildAnthropicFromOpenAIChat(oa, options) {
             blocks.push({ type: 'text', text });
         }
     }
-    const reasoningField = typeof msg?.reasoning_content === 'string'
-        ? msg.reasoning_content
-        : typeof msg?.reasoning === 'string'
-            ? msg.reasoning
-            : undefined;
+    const extensionReasoning = body?.__responses_reasoning;
+    const extensionContent = Array.isArray(extensionReasoning?.content)
+        ? extensionReasoning?.content?.map((entry) => String(entry.text ?? '')).filter((text) => text.trim().length > 0)
+        : [];
+    const extensionSummary = Array.isArray(extensionReasoning?.summary)
+        ? extensionReasoning?.summary?.map((entry) => String(entry.text ?? '')).filter((text) => text.trim().length > 0)
+        : [];
+    const extensionText = extensionContent.length > 0
+        ? extensionContent.join('\n')
+        : (extensionSummary.length > 0 ? extensionSummary.join('\n') : undefined);
+    const reasoningField = extensionText ??
+        (typeof msg?.reasoning_content === 'string'
+            ? msg.reasoning_content
+            : typeof msg?.reasoning === 'string'
+                ? msg.reasoning
+                : undefined);
     if (reasoningField && reasoningField.trim().length) {
         blocks.push({ type: 'thinking', text: reasoningField.trim() });
     }
@@ -564,12 +620,8 @@ export function buildAnthropicFromOpenAIChat(oa, options) {
             const argsRaw = fn.arguments;
             let input;
             if (typeof argsRaw === 'string') {
-                try {
-                    input = JSON.parse(argsRaw);
-                }
-                catch {
-                    input = { _raw: argsRaw };
-                }
+                const parsed = parseLenientJsonishWithNative(argsRaw);
+                input = parsed && typeof parsed === 'object' ? parsed : { _raw: argsRaw };
             }
             else {
                 input = argsRaw ?? {};
@@ -991,12 +1043,8 @@ export function buildAnthropicRequestFromOpenAIChat(chatReq) {
             const argsRaw = fn.arguments;
             let input;
             if (typeof argsRaw === 'string') {
-                try {
-                    input = JSON.parse(argsRaw);
-                }
-                catch {
-                    input = { _raw: argsRaw };
-                }
+                const parsed = parseLenientJsonishWithNative(argsRaw);
+                input = parsed && typeof parsed === 'object' ? parsed : { _raw: argsRaw };
             }
             else {
                 input = argsRaw ?? {};
@@ -1095,6 +1143,107 @@ function cloneAnthropicSchema(value) {
     }
     return { type: 'object', properties: {} };
 }
+function normalizeAnthropicSchemaType(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim().toLowerCase();
+        if (trimmed === 'string' ||
+            trimmed === 'number' ||
+            trimmed === 'integer' ||
+            trimmed === 'boolean' ||
+            trimmed === 'object' ||
+            trimmed === 'array') {
+            return trimmed;
+        }
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            const normalized = normalizeAnthropicSchemaType(entry);
+            if (normalized) {
+                return normalized;
+            }
+        }
+    }
+    return undefined;
+}
+function compactAnthropicPropertySchema(schema) {
+    if (!isPlainRecord(schema)) {
+        return { type: 'string' };
+    }
+    const out = {};
+    const type = normalizeAnthropicSchemaType(schema.type);
+    if (type) {
+        out.type = type;
+    }
+    if (typeof schema.description === 'string' && schema.description.trim()) {
+        out.description = schema.description;
+    }
+    const enumRaw = Array.isArray(schema.enum) ? schema.enum : undefined;
+    if (enumRaw && enumRaw.length) {
+        const enumValues = enumRaw
+            .filter((entry) => {
+            const entryType = typeof entry;
+            return entryType === 'string' || entryType === 'number' || entryType === 'boolean';
+        })
+            .slice(0, 64);
+        if (enumValues.length) {
+            out.enum = enumValues;
+            if (!out.type) {
+                const inferred = typeof enumValues[0];
+                out.type = inferred === 'boolean' ? 'boolean' : inferred === 'number' ? 'number' : 'string';
+            }
+        }
+    }
+    if (out.type === 'array') {
+        const items = isPlainRecord(schema.items) ? schema.items : {};
+        const itemType = normalizeAnthropicSchemaType(items.type) ?? 'string';
+        out.items = { type: itemType };
+    }
+    else if (out.type === 'object') {
+        out.properties = {};
+        out.additionalProperties = false;
+    }
+    if (!out.type) {
+        out.type = 'string';
+    }
+    return out;
+}
+function sanitizeAnthropicBuiltinInputSchema(toolName, schemaSource) {
+    const normalizedName = toolName.trim().toLowerCase();
+    if (!ANTHROPIC_STABLE_TOOL_SCHEMA_NAMES.has(normalizedName)) {
+        return cloneAnthropicSchema(schemaSource);
+    }
+    const source = cloneAnthropicSchema(schemaSource);
+    const sourceProperties = isPlainRecord(source.properties) ? source.properties : {};
+    const allowedKeys = ANTHROPIC_STABLE_TOOL_SCHEMA_KEYS.get(normalizedName);
+    const sanitizedProperties = {};
+    for (const [key, value] of Object.entries(sourceProperties)) {
+        if (allowedKeys && !allowedKeys.has(key)) {
+            continue;
+        }
+        sanitizedProperties[key] = compactAnthropicPropertySchema(value);
+    }
+    const required = Array.isArray(source.required)
+        ? source.required.filter((entry) => typeof entry === 'string' && entry.trim().length > 0)
+        : [];
+    const filteredRequired = allowedKeys
+        ? required.filter((key) => allowedKeys.has(key))
+        : required;
+    for (const key of filteredRequired) {
+        if (!Object.prototype.hasOwnProperty.call(sanitizedProperties, key)) {
+            sanitizedProperties[key] = { type: 'string' };
+        }
+    }
+    const output = {
+        type: 'object',
+        properties: sanitizedProperties,
+        additionalProperties: false
+    };
+    if (filteredRequired.length) {
+        output.required = Array.from(new Set(filteredRequired));
+    }
+    return output;
+}
 function prepareAnthropicBridgeTools(rawTools, missing) {
     if (!Array.isArray(rawTools) || rawTools.length === 0) {
         return undefined;
@@ -1151,7 +1300,7 @@ function convertBridgeToolToAnthropic(def) {
             ? def.description
             : undefined;
     const schemaSource = fnNode?.parameters ?? def.parameters;
-    const inputSchema = cloneAnthropicSchema(schemaSource);
+    const inputSchema = sanitizeAnthropicBuiltinInputSchema(name, schemaSource);
     const tool = {
         name,
         input_schema: inputSchema