@jsonstudio/llms 0.6.2172 → 0.6.2979

package/dist/conversion/hub/tool-surface/tool-surface-engine.js

@@ -4,6 +4,7 @@ import { buildGeminiToolsFromBridge, prepareGeminiToolsForBridge } from '../../s
 import { mapAnthropicToolsToChat, mapChatToolsToAnthropicTools } from '../../shared/anthropic-message-utils.js';
 import { convertBridgeInputToChatMessages, convertMessagesToBridgeInput } from '../../shared/bridge-message-utils.js';
 import { resolveHubProtocolSpec } from '../policy/protocol-spec.js';
+import { normalizeProviderProtocolTokenWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 function clampSampleRate(value) {
     const num = typeof value === 'number' && Number.isFinite(value) ? value : 1;
     if (num <= 0)
@@ -428,16 +429,17 @@ export function applyProviderOutboundToolSurface(args) {
     if (!shouldSample(config, args.requestId)) {
         return args.payload;
     }
+    const normalizedProviderProtocol = normalizeProviderProtocolTokenWithNative(args.providerProtocol) ?? args.providerProtocol;
     const payload = args.payload;
     const tools = payload.tools;
-    const candidate = buildCandidateTools({ providerProtocol: args.providerProtocol, tools });
+    const candidate = buildCandidateTools({ providerProtocol: normalizedProviderProtocol, tools });
     if (!candidate) {
         // Still allow history/tool-call surface observation even when tool definitions don't need conversion.
     }
     const stageBase = `hub_toolsurface.${config.mode}.provider_outbound`;
     const toolSchemaCandidate = candidate?.candidateTools;
     const schemaDiff = candidate ? computeToolSchemaDiff(tools, toolSchemaCandidate) : { diffCount: 0, diffHead: [] };
-    const expectedHistoryCarrier = resolveExpectedHistoryCarrier(args.providerProtocol);
+    const expectedHistoryCarrier = resolveExpectedHistoryCarrier(normalizedProviderProtocol);
     let historyReason = undefined;
     let historyBaseline = undefined;
     let historyCandidate = undefined;
@@ -492,7 +494,7 @@ export function applyProviderOutboundToolSurface(args) {
         }
         args.stageRecorder?.record(stageBase, {
             kind: 'provider_outbound',
-            providerProtocol: args.providerProtocol,
+            providerProtocol: normalizedProviderProtocol,
             reason: candidate?.reason ?? historyReason,
             diffCount: totalDiffCount,
             diffHead: diffHeadMerged,

package/dist/conversion/responses/responses-host-policy.js

@@ -1,14 +1,4 @@
+import { evaluateResponsesHostPolicyWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
 export function evaluateResponsesHostPolicy(context, targetProtocol) {
-    const protocol = typeof targetProtocol === 'string' && targetProtocol.trim()
-        ? targetProtocol
-        : (typeof context?.targetProtocol === 'string' && context.targetProtocol.trim()
-            ? context.targetProtocol
-            : 'responses');
-    const normalized = protocol.toLowerCase();
-    const shouldStrip = normalized !== 'openai-responses' &&
-        normalized !== 'responses';
-    return {
-        shouldStripHostManagedFields: shouldStrip,
-        targetProtocol: normalized
-    };
+    return evaluateResponsesHostPolicyWithNative(context, targetProtocol);
 }

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

@@ -7,6 +7,7 @@ import { buildResponsesOutputFromChat } from '../../shared/responses-output-buil
 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 { normalizeResponsesToolCallArgumentsForClientWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
 function isPlainObject(value) {
     return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }
@@ -267,90 +268,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;

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

@@ -5,6 +5,7 @@ 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.js

@@ -3,13 +3,15 @@ import os from 'node:os';
 import path from 'node:path';
 import { ensureBridgeInstructions } from '../shared/bridge-instructions.js';
 import { evaluateResponsesHostPolicy } from './responses-host-policy.js';
-import { convertMessagesToBridgeInput, convertBridgeInputToChatMessages } from '../shared/bridge-message-utils.js';
+import { convertBridgeInputToChatMessages } from '../shared/bridge-message-utils.js';
 import { createToolCallIdTransformer, enforceToolCallIdStyle, resolveToolCallIdStyle, sanitizeResponsesFunctionName } from '../shared/responses-tool-utils.js';
-import { mapBridgeToolsToChat, mapChatToolsToBridge } from '../shared/tool-mapping.js';
+import { 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 { 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';
@@ -236,65 +238,30 @@ 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;
-    }
-    if (typeof payload.instructions === 'string' && payload.instructions.trim().length) {
-        context.systemInstruction = payload.instructions;
+    const captured = captureReqInboundResponsesContextSnapshotWithNative({
+        rawRequest: requestForCapture,
+        requestId: dto?.route?.requestId,
+        toolCallIdStyle: payload?.toolCallIdStyle ?? payload?.metadata?.toolCallIdStyle
+    });
+    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 +581,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
         }));

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

@@ -4,6 +4,7 @@ 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 { 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) {
@@ -564,12 +609,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 +1032,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 +1132,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 +1289,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

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

@@ -1,154 +1,10 @@
 import { buildShellDescription, hasApplyPatchToolDeclared, isShellToolName } from '../../tools/tool-description-utils.js';
+import { normalizeArgsBySchemaWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
-const normKey = (k) => k.toLowerCase().replace(/[^a-z0-9]+/g, '');
-function getDefaultAliases(prop) {
-    const p = prop.toLowerCase();
-    switch (p) {
-        case 'file_path': return ['path', 'file', 'filepath', 'filePath'];
-        case 'pattern': return ['glob', 'include', 'includes', 'query', 'regex'];
-        case 'content': return ['text', 'data', 'body'];
-        case 'old_string': return ['old', 'from', 'before', 'oldString', 'previous'];
-        case 'new_string': return ['new', 'to', 'after', 'newString', 'next'];
-        case 'command': return ['cmd', 'command_list', 'commandList'];
-        case 'path': return ['dir', 'directory'];
-        case 'glob': return ['include', 'includes', 'patterns'];
-        case 'todos': return ['items', 'list', 'tasks'];
-        case 'replace_all': return ['replaceAll', 'all', 'allOccurrences'];
-        default: return [];
-    }
-}
-function buildPropertyMap(schema) {
-    const map = new Map();
-    const props = schema?.properties || {};
-    for (const [p, s] of Object.entries(props)) {
-        map.set(normKey(p), p);
-        const aliases = s['x-aliases'];
-        if (Array.isArray(aliases)) {
-            for (const a of aliases) {
-                if (typeof a === 'string') {
-                    map.set(normKey(a), p);
-                }
-            }
-        }
-        for (const a of getDefaultAliases(p)) {
-            map.set(normKey(a), p);
-        }
-    }
-    return map;
-}
-function coerceType(value, schema) {
-    const t = schema?.type;
-    const want = Array.isArray(t) ? t[0] : t;
-    if (!want) {
-        return value;
-    }
-    switch (want) {
-        case 'string':
-            if (typeof value === 'string')
-                return value;
-            if (Array.isArray(value))
-                return value.map(v => String(v)).join(' ');
-            if (value === null || value === undefined)
-                return value;
-            return String(value);
-        case 'number':
-            if (typeof value === 'number')
-                return value;
-            if (typeof value === 'string') {
-                const n = Number(value);
-                return Number.isFinite(n) ? n : value;
-            }
-            return value;
-        case 'integer':
-            if (typeof value === 'number')
-                return Math.trunc(value);
-            if (typeof value === 'string') {
-                const n = parseInt(value, 10);
-                return Number.isFinite(n) ? n : value;
-            }
-            return value;
-        case 'boolean':
-            if (typeof value === 'boolean')
-                return value;
-            if (typeof value === 'string') {
-                const s = value.toLowerCase();
-                if (s === 'true')
-                    return true;
-                if (s === 'false')
-                    return false;
-            }
-            return value;
-        case 'array':
-            if (Array.isArray(value))
-                return value;
-            if (typeof value === 'string') {
-                // conservative: split commas/newlines; caller controls format
-                const parts = value.split(/[\n,]+/).map(s => s.trim()).filter(Boolean);
-                return parts.length ? parts : value;
-            }
-            return value;
-        case 'object':
-            if (value && typeof value === 'object')
-                return value;
-            return value;
-        default:
-            return value;
-    }
-}
 export function normalizeArgsBySchema(input, schema) {
-    if (!schema || !schema.properties || !isObject(input)) {
-        const ok = !!(isObject(input) && Object.keys(input).length > 0);
-        return ok ? { ok: true, value: input } : { ok: false, errors: ['no_schema_or_invalid_input'] };
-    }
-    const propMap = buildPropertyMap(schema);
-    const out = {};
-    const errors = [];
-    const additional = schema.additionalProperties !== false;
-    const reqList = Array.isArray(schema.required) ? schema.required : [];
-    if (Object.keys(input).length === 1 && typeof input._raw === 'string' && reqList.length === 1) {
-        const only = reqList[0];
-        const child = (schema.properties || {})[only];
-        if (child) {
-            const coerced = coerceType(input._raw, child);
-            if (typeof coerced === 'string' && coerced.trim().length > 0)
-                out[only] = coerced;
-        }
-    }
-    for (const [k, v] of Object.entries(input)) {
-        const key = normKey(k);
-        const target = propMap.get(key);
-        if (target) {
-            const childSchema = schema.properties[target];
-            out[target] = coerceType(v, childSchema);
-        }
-        else if (additional) {
-            out[k] = v;
-        }
-    }
-    const req = schema.required || [];
-    for (const r of req) {
-        if (!(r in out)) {
-            errors.push(`missing_required:${r}`);
-            continue;
-        }
-        const v = out[r];
-        if (typeof v === 'string' && v.trim().length === 0) {
-            errors.push(`missing_required:${r}`);
-            continue;
-        }
-        if (Array.isArray(v) && v.length === 0) {
-            errors.push(`missing_required:${r}`);
-            continue;
-        }
-        if (v && typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length === 0) {
-            errors.push(`missing_required:${r}`);
-            continue;
-        }
-    }
-    const ok = errors.length === 0;
-    return ok ? { ok, value: out } : { ok, value: out, errors };
+    return normalizeArgsBySchemaWithNative(input, schema);
 }
 // Tools normalizer (OpenAI-like)
 export function normalizeTools(tools) {