@jsonstudio/rcc 0.90.323 → 0.90.364

package/vendor/@jsonstudio/llms/dist/conversion/shared/anthropic-message-utils.js

@@ -0,0 +1,1416 @@
+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 '../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);
+}
+function safeJson(v) {
+    try {
+        return JSON.stringify(v ?? {});
+    }
+    catch {
+        return '{}';
+    }
+}
+function stripOpenAIChatToolAliasFields(messages) {
+    // No-op: preserve tool_call_id/call_id for downstream consumers and regression parity.
+    void messages;
+}
+function stripToolCallIdFieldsFromAssistant(messages) {
+    for (const message of messages) {
+        if (!message || typeof message !== 'object')
+            continue;
+        const role = String(message.role || '').toLowerCase();
+        if (role !== 'assistant')
+            continue;
+        const calls = message.tool_calls;
+        if (!Array.isArray(calls))
+            continue;
+        for (const call of calls) {
+            if (!call || typeof call !== 'object')
+                continue;
+            delete call.call_id;
+            delete call.tool_call_id;
+        }
+    }
+}
+function sanitizeToolUseId(raw) {
+    const trimmed = typeof raw === 'string' ? raw.trim() : '';
+    if (!trimmed) {
+        return `call_${Math.random().toString(36).slice(2, 10)}`;
+    }
+    if (/^[A-Za-z0-9_-]+$/.test(trimmed)) {
+        return trimmed;
+    }
+    const sanitized = trimmed
+        .replace(/[^A-Za-z0-9_-]/g, '_')
+        .replace(/_{2,}/g, '_')
+        .replace(/^_+/, '')
+        .replace(/_+$/, '');
+    return sanitized || `call_${Math.random().toString(36).slice(2, 10)}`;
+}
+function flattenAnthropicText(content) {
+    if (content == null)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content))
+        return content.map(flattenAnthropicText).join('');
+    if (typeof content === 'object') {
+        const t = String(content.type || '').toLowerCase();
+        if (t === 'text' && typeof content.text === 'string')
+            return String(content.text);
+        if (Array.isArray(content.content))
+            return content.content.map(flattenAnthropicText).join('');
+        if (typeof content.content === 'string')
+            return String(content.content);
+    }
+    return '';
+}
+function normalizeToolResultContent(block) {
+    if (!block || typeof block !== 'object') {
+        return '';
+    }
+    const content = block.content;
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        const segments = [];
+        for (const entry of content) {
+            const segment = extractToolResultSegment(entry);
+            if (segment) {
+                segments.push(segment);
+            }
+        }
+        if (segments.length) {
+            return segments.join('\n');
+        }
+    }
+    else if (content != null) {
+        try {
+            return JSON.stringify(content);
+        }
+        catch {
+            return String(content);
+        }
+    }
+    return '';
+}
+function extractToolResultSegment(entry) {
+    if (entry == null) {
+        return '';
+    }
+    if (typeof entry === 'string') {
+        return entry;
+    }
+    if (Array.isArray(entry)) {
+        return entry.map(extractToolResultSegment).filter(Boolean).join('');
+    }
+    if (typeof entry === 'object') {
+        const node = entry;
+        const type = typeof node.type === 'string' ? node.type.toLowerCase() : '';
+        if (type === 'input_text' || type === 'input_json' || type === 'tool_result_status' || type === 'status' || type === 'metadata') {
+            return '';
+        }
+        if (type === 'output_text' || type === 'text' || type === 'reasoning' || type === 'log') {
+            return flattenAnthropicText(entry);
+        }
+        if (type === 'output_json' || type === 'json') {
+            const payload = node.content ?? node.text ?? node.data ?? node.output;
+            if (payload === undefined) {
+                return '';
+            }
+            try {
+                return JSON.stringify(payload);
+            }
+            catch {
+                return String(payload ?? '');
+            }
+        }
+        if (typeof node.text === 'string') {
+            return node.text;
+        }
+        if ('content' in node) {
+            const nested = extractToolResultSegment(node.content);
+            if (nested) {
+                return nested;
+            }
+        }
+        try {
+            return JSON.stringify(entry);
+        }
+        catch {
+            return '';
+        }
+    }
+    return String(entry);
+}
+function resolveProtocolErrorCode(context) {
+    const ctx = context.toLowerCase();
+    return ctx.includes('tool') ? 'TOOL_PROTOCOL_ERROR' : 'MALFORMED_REQUEST';
+}
+function requireTrimmedString(value, context) {
+    if (typeof value !== 'string') {
+        throw new ProviderProtocolError(`Anthropic bridge constraint violated: ${context} must be a string`, {
+            code: resolveProtocolErrorCode(context),
+            protocol: 'anthropic-messages',
+            providerType: 'anthropic',
+            details: { context, actualType: typeof value }
+        });
+    }
+    const trimmed = value.trim();
+    if (!trimmed.length) {
+        throw new ProviderProtocolError(`Anthropic bridge constraint violated: ${context} must not be empty`, {
+            code: resolveProtocolErrorCode(context),
+            protocol: 'anthropic-messages',
+            providerType: 'anthropic',
+            details: { context }
+        });
+    }
+    return trimmed;
+}
+function requireSystemText(block, context) {
+    const text = flattenAnthropicText(block).trim();
+    if (!text) {
+        throw new ProviderProtocolError(`Anthropic bridge constraint violated: ${context} must contain text`, {
+            code: resolveProtocolErrorCode(context),
+            protocol: 'anthropic-messages',
+            providerType: 'anthropic',
+            details: { context }
+        });
+    }
+    return text;
+}
+const ANTHROPIC_TOOL_NAME_ALIASES = new Map();
+const CANONICAL_TO_ANTHROPIC_TOOL_NAMES = new Map([['shell_command', 'Bash']]);
+const ANTHROPIC_TOP_LEVEL_FIELDS = new Set([
+    'model',
+    'messages',
+    'tools',
+    'system',
+    'stop_sequences',
+    'temperature',
+    'top_p',
+    'top_k',
+    'max_tokens',
+    'max_output_tokens',
+    'metadata',
+    'stream',
+    '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;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const lower = trimmed.toLowerCase();
+    const alias = ANTHROPIC_TOOL_NAME_ALIASES.get(lower);
+    if (alias) {
+        return alias;
+    }
+    if (lower.startsWith('mcp__')) {
+        return lower;
+    }
+    return lower;
+}
+export function denormalizeAnthropicToolName(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const lower = trimmed.toLowerCase();
+    const mapped = CANONICAL_TO_ANTHROPIC_TOOL_NAMES.get(lower);
+    if (mapped) {
+        return mapped;
+    }
+    if (lower.startsWith('mcp__')) {
+        return trimmed;
+    }
+    return trimmed;
+}
+function coerceShellLikeCommand(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed.length ? trimmed : undefined;
+    }
+    if (Array.isArray(value)) {
+        const parts = value
+            .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))
+            .filter((entry) => entry.length > 0);
+        if (!parts.length) {
+            return undefined;
+        }
+        return parts.join(' ');
+    }
+    return undefined;
+}
+function normalizeShellLikeToolInput(toolName, input) {
+    const canonical = normalizeAnthropicToolName(toolName);
+    if (canonical !== 'shell_command') {
+        return input;
+    }
+    const rawToolName = typeof toolName === 'string' ? toolName.trim().toLowerCase() : '';
+    const isExecCommand = rawToolName === 'exec_command';
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        const cmd = coerceShellLikeCommand(input);
+        if (!cmd) {
+            return {};
+        }
+        return isExecCommand ? { cmd } : { command: cmd };
+    }
+    const next = { ...input };
+    const commandValue = coerceShellLikeCommand(next.command);
+    const cmdValue = coerceShellLikeCommand(next.cmd);
+    const fallbackValue = coerceShellLikeCommand(next.script) ??
+        coerceShellLikeCommand(next.toon);
+    if (commandValue) {
+        next.command = commandValue;
+    }
+    if (cmdValue) {
+        next.cmd = cmdValue;
+    }
+    if (!commandValue && !cmdValue && fallbackValue) {
+        if (isExecCommand) {
+            next.cmd = fallbackValue;
+        }
+        else {
+            next.command = fallbackValue;
+        }
+    }
+    else if (!commandValue && cmdValue && !isExecCommand) {
+        next.command = cmdValue;
+    }
+    else if (!cmdValue && commandValue && isExecCommand) {
+        next.cmd = commandValue;
+    }
+    if (!isExecCommand && 'cmd' in next) {
+        delete next.cmd;
+    }
+    if (typeof next.workdir !== 'string' && typeof next.cwd === 'string' && next.cwd.trim().length > 0) {
+        next.workdir = next.cwd.trim();
+    }
+    return next;
+}
+function invertAnthropicAliasMap(source) {
+    if (!source) {
+        return undefined;
+    }
+    const inverted = {};
+    for (const [canonical, raw] of Object.entries(source)) {
+        if (typeof canonical !== 'string' || typeof raw !== 'string') {
+            continue;
+        }
+        const trimmedCanonical = canonical.trim();
+        const trimmedRaw = raw.trim();
+        if (!trimmedCanonical.length) {
+            continue;
+        }
+        if (trimmedRaw.length) {
+            inverted[trimmedRaw.toLowerCase()] = trimmedCanonical;
+        }
+        if (!inverted[trimmedCanonical.toLowerCase()]) {
+            inverted[trimmedCanonical.toLowerCase()] = trimmedCanonical;
+        }
+    }
+    return Object.keys(inverted).length ? inverted : undefined;
+}
+export function buildOpenAIChatFromAnthropic(payload, options) {
+    const newMessages = [];
+    const body = isObject(payload) ? payload : {};
+    const canonicalAliasMap = coerceAliasRecord(buildAnthropicToolAliasMap(body.tools));
+    const reverseAliasMap = invertAnthropicAliasMap(canonicalAliasMap);
+    const resolveToolName = (candidate) => {
+        if (typeof candidate !== 'string') {
+            return '';
+        }
+        const trimmed = candidate.trim();
+        if (!trimmed.length) {
+            return trimmed;
+        }
+        const normalized = normalizeAnthropicToolName(trimmed) ?? trimmed;
+        if (reverseAliasMap) {
+            const direct = reverseAliasMap[trimmed.toLowerCase()];
+            if (typeof direct === 'string' && direct.trim().length) {
+                return direct.trim();
+            }
+            const normalizedLookup = reverseAliasMap[normalized.toLowerCase()];
+            if (typeof normalizedLookup === 'string' && normalizedLookup.trim().length) {
+                return normalizedLookup.trim();
+            }
+        }
+        return normalized;
+    };
+    const rawSystem = body.system;
+    const systemBlocks = Array.isArray(rawSystem)
+        ? rawSystem
+        : rawSystem !== undefined && rawSystem !== null
+            ? [rawSystem]
+            : [];
+    for (const block of systemBlocks) {
+        const text = requireSystemText(block, 'system entry');
+        newMessages.push({ role: 'system', content: text });
+    }
+    const msgs = Array.isArray(body.messages) ? body.messages : [];
+    for (const m of msgs) {
+        if (!m || typeof m !== 'object')
+            continue;
+        const role = typeof m.role === 'string' ? String(m.role) : 'user';
+        const content = m.content;
+        if (!Array.isArray(content)) {
+            const text = flattenAnthropicText(content);
+            if (text) {
+                const normalized = normalizeChatMessageContent(text);
+                const message = {
+                    role,
+                    content: normalized.contentText ?? text
+                };
+                if (typeof normalized.reasoningText === 'string' && normalized.reasoningText.trim().length) {
+                    message.reasoning_content = normalized.reasoningText.trim();
+                }
+                newMessages.push(message);
+            }
+            continue;
+        }
+        const textParts = [];
+        const imageBlocks = [];
+        const toolCalls = [];
+        const reasoningParts = [];
+        const toolResults = [];
+        for (const block of content) {
+            if (!block || typeof block !== 'object')
+                continue;
+            const t = String(block.type || '').toLowerCase();
+            if (t === 'text' && typeof block.text === 'string') {
+                const s = block.text.trim();
+                if (s)
+                    textParts.push(s);
+            }
+            else if (t === 'thinking' || t === 'reasoning') {
+                const thinkingText = flattenAnthropicText(block).trim();
+                if (thinkingText) {
+                    reasoningParts.push(thinkingText);
+                }
+            }
+            else if (t === 'image') {
+                const source = block.source;
+                if (source && typeof source === 'object') {
+                    const s = source;
+                    const srcType = typeof s.type === 'string' ? s.type.toLowerCase() : '';
+                    let url;
+                    if (srcType === 'url' && typeof s.url === 'string') {
+                        url = s.url;
+                    }
+                    else if (srcType === 'base64' && typeof s.data === 'string') {
+                        const mediaType = typeof s.media_type === 'string' && s.media_type.trim().length
+                            ? s.media_type.trim()
+                            : 'image/png';
+                        url = `data:${mediaType};base64,${s.data}`;
+                    }
+                    if (url && url.trim().length) {
+                        imageBlocks.push({
+                            type: 'image_url',
+                            image_url: { url: url.trim() }
+                        });
+                    }
+                }
+            }
+            else if (t === 'tool_use') {
+                const name = requireTrimmedString(block.name, 'tool_use.name');
+                const id = requireTrimmedString(block.id, 'tool_use.id');
+                const input = block.input ?? {};
+                const args = safeJson(input);
+                const canonicalName = resolveToolName(name) || name;
+                const includeIds = options?.includeToolCallIds === true;
+                toolCalls.push({
+                    id,
+                    ...(includeIds ? { call_id: id, tool_call_id: id } : {}),
+                    type: 'function',
+                    function: { name: canonicalName, arguments: args }
+                });
+            }
+            else if (t === 'tool_result') {
+                const callId = requireTrimmedString(block.tool_call_id ??
+                    block.call_id ??
+                    block.tool_use_id ??
+                    block.id, 'tool_result.tool_use_id');
+                const contentStr = normalizeToolResultContent(block);
+                toolResults.push({ role: 'tool', tool_call_id: callId, content: contentStr });
+            }
+        }
+        const combinedText = textParts.join('\n');
+        const normalized = normalizeChatMessageContent(combinedText);
+        const hasRawText = typeof combinedText === 'string' && combinedText.trim().length > 0;
+        const mergedReasoning = [...reasoningParts];
+        if (typeof normalized.reasoningText === 'string' && normalized.reasoningText.trim().length) {
+            mergedReasoning.push(normalized.reasoningText.trim());
+        }
+        const hasText = typeof normalized.contentText === 'string' && normalized.contentText.length > 0;
+        const hasReasoning = mergedReasoning.length > 0;
+        if (hasText || hasRawText || toolCalls.length > 0 || hasReasoning || imageBlocks.length > 0) {
+            let contentNode = (hasText ? normalized.contentText : undefined) ?? combinedText ?? '';
+            if (imageBlocks.length > 0) {
+                const blocks = [];
+                const textPayload = (hasText ? normalized.contentText : undefined) ?? combinedText ?? '';
+                if (typeof textPayload === 'string' && textPayload.trim().length) {
+                    blocks.push({ type: 'text', text: textPayload.trim() });
+                }
+                for (const img of imageBlocks) {
+                    blocks.push(jsonClone(img));
+                }
+                contentNode = blocks;
+            }
+            const msg = {
+                role,
+                content: contentNode
+            };
+            if (toolCalls.length)
+                msg.tool_calls = toolCalls;
+            if (hasReasoning) {
+                msg.reasoning_content = mergedReasoning.join('\n');
+            }
+            newMessages.push(msg);
+        }
+        for (const tr of toolResults)
+            newMessages.push(tr);
+    }
+    const request = { messages: newMessages };
+    if (typeof body.model === 'string')
+        request.model = body.model;
+    if (typeof body.max_tokens === 'number')
+        request.max_tokens = body.max_tokens;
+    if (typeof body.temperature === 'number')
+        request.temperature = body.temperature;
+    if (typeof body.top_p === 'number')
+        request.top_p = body.top_p;
+    if (typeof body.stream === 'boolean')
+        request.stream = body.stream;
+    if (typeof body.id === 'string') {
+        request.request_id = body.id;
+    }
+    else if (typeof body.request_id === 'string') {
+        request.request_id = body.request_id;
+    }
+    if ('tool_choice' in body)
+        request.tool_choice = body.tool_choice;
+    const normalizedTools = mapAnthropicToolsToChat(body.tools);
+    if (normalizedTools !== undefined) {
+        request.tools = normalizedTools;
+    }
+    try {
+        const bridgePolicy = resolveBridgePolicy({ protocol: 'anthropic-messages' });
+        const actions = resolvePolicyActions(bridgePolicy, 'request_inbound');
+        if (actions?.length) {
+            const actionState = createBridgeActionState({
+                messages: newMessages,
+                rawRequest: body
+            });
+            runBridgeActionPipeline({
+                stage: 'request_inbound',
+                actions,
+                protocol: bridgePolicy?.protocol ?? 'anthropic-messages',
+                moduleType: bridgePolicy?.moduleType ?? 'anthropic-messages',
+                requestId: typeof body?.id === 'string' ? String(body.id) : undefined,
+                state: actionState
+            });
+        }
+    }
+    catch {
+        // ignore policy failures
+    }
+    stripToolCallIdFieldsFromAssistant(newMessages);
+    stripOpenAIChatToolAliasFields(newMessages);
+    return request;
+}
+export function buildAnthropicFromOpenAIChat(oa, options) {
+    const mapFinishReason = (reason) => {
+        if (typeof reason !== 'string' || !reason.trim().length) {
+            return undefined;
+        }
+        const mapping = {
+            stop: 'end_turn',
+            length: 'max_tokens',
+            tool_calls: 'tool_use',
+            content_filter: 'stop_sequence',
+            function_call: 'tool_use'
+        };
+        return mapping[reason.trim()];
+    };
+    const body = isObject(oa) ? oa : {};
+    const choices = Array.isArray(body.choices) ? body.choices : [];
+    const primary = choices[0] && typeof choices[0] === 'object' ? choices[0] : {};
+    const msg = isObject(primary.message) ? primary.message : {};
+    const role = typeof msg.role === 'string' ? msg.role : 'assistant';
+    const blocks = [];
+    const content = msg?.content;
+    const contentArray = Array.isArray(content) ? content : undefined;
+    if (typeof content === 'string') {
+        blocks.push({ type: 'text', text: content });
+    }
+    if (contentArray) {
+        const text = contentArray
+            .map((p) => p && typeof p.text === 'string'
+            ? String(p.text)
+            : typeof p === 'string'
+                ? p
+                : '')
+            .filter(Boolean)
+            .join('');
+        if (text) {
+            blocks.push({ type: 'text', text });
+        }
+    }
+    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 extensionEncrypted = typeof extensionReasoning?.encrypted_content === 'string' && extensionReasoning.encrypted_content.trim().length
+        ? extensionReasoning.encrypted_content.trim()
+        : undefined;
+    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() });
+    }
+    if (extensionEncrypted) {
+        blocks.push({ type: 'redacted_thinking', data: extensionEncrypted });
+    }
+    const toolCalls = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
+    const toolNameResolver = createAnthropicToolNameResolver(options?.toolNameMap ?? extractToolNameMapFromPayload(oa));
+    for (const tc of toolCalls) {
+        try {
+            const id = sanitizeToolUseId(requireTrimmedString(tc?.id, 'chat.tool_call.id'));
+            const fn = isObject(tc?.function) ? tc.function : {};
+            const canonicalName = requireTrimmedString(fn.name, 'chat.tool_call.function.name');
+            const name = toolNameResolver ? toolNameResolver(canonicalName) : canonicalName;
+            const argsRaw = fn.arguments;
+            let input;
+            if (typeof argsRaw === 'string') {
+                const parsed = parseLenientJsonishWithNative(argsRaw);
+                input = parsed && typeof parsed === 'object' ? parsed : { _raw: argsRaw };
+            }
+            else {
+                input = argsRaw ?? {};
+            }
+            input = normalizeShellLikeToolInput(name, input);
+            blocks.push({ type: 'tool_use', id, name, input });
+        }
+        catch {
+            // ignore malformed tool call
+        }
+    }
+    const usageChunk = isObject(body.usage) ? body.usage : {};
+    const inputTokens = Number(usageChunk.prompt_tokens ?? usageChunk.input_tokens ?? 0);
+    const outputTokens = Number(usageChunk.completion_tokens ?? usageChunk.output_tokens ?? 0);
+    const finishReason = Array.isArray(body.choices) &&
+        body.choices[0] &&
+        typeof body.choices[0]?.finish_reason === 'string'
+        ? String(body.choices[0].finish_reason).trim()
+        : undefined;
+    const stopReasonCandidate = mapFinishReason(finishReason) ||
+        mapFinishReason(typeof primary?.finish_reason === 'string' ? String(primary.finish_reason) : undefined) ||
+        (typeof body?.stop_reason === 'string' ? String(body.stop_reason).trim() : undefined) ||
+        (typeof primary?.stop_reason === 'string' ? String(primary.stop_reason).trim() : undefined);
+    const hasToolCalls = toolCalls.length > 0;
+    const stopReason = stopReasonCandidate ?? (hasToolCalls ? 'tool_use' : 'end_turn');
+    const resolveResponseId = () => {
+        const preferred = [
+            body?.id,
+            body?.response?.id,
+            body?.response_id
+        ];
+        for (const candidateRaw of preferred) {
+            if (typeof candidateRaw !== 'string')
+                continue;
+            const candidate = candidateRaw.trim();
+            if (!candidate.length)
+                continue;
+            if (candidate.startsWith('resp_')) {
+                return candidate;
+            }
+        }
+        const fromRequest = typeof options?.requestId === 'string' && options.requestId.trim().startsWith('resp_')
+            ? options.requestId.trim()
+            : undefined;
+        return fromRequest ?? `resp_${Date.now()}`;
+    };
+    const resolveCreated = () => {
+        const candidateNumbers = [
+            body?.created,
+            body?.created_at,
+            body?.response?.created,
+            body?.response?.created_at
+        ];
+        for (const candidate of candidateNumbers) {
+            if (typeof candidate === 'number' && Number.isFinite(candidate)) {
+                return Math.floor(candidate);
+            }
+        }
+        return Math.floor(Date.now() / 1000);
+    };
+    return {
+        id: resolveResponseId(),
+        type: 'message',
+        role,
+        model: String(body.model || 'unknown'),
+        created: resolveCreated(),
+        content: blocks,
+        usage: inputTokens || outputTokens ? { input_tokens: inputTokens, output_tokens: outputTokens } : undefined,
+        stop_reason: stopReason
+    };
+}
+function extractToolNameMapFromPayload(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return undefined;
+    }
+    const candidateSources = [
+        payload.anthropicToolNameMap,
+        payload.__anthropicToolNameMap,
+        payload.metadata &&
+            typeof payload.metadata === 'object'
+            ? payload.metadata.anthropicToolNameMap
+            : undefined,
+        payload.metadata &&
+            typeof payload.metadata === 'object'
+            ? payload.metadata.extraFields &&
+                typeof payload.metadata.extraFields === 'object'
+                ? payload.metadata.extraFields.anthropicToolNameMap
+                : undefined
+            : undefined,
+        payload.metadata &&
+            typeof payload.metadata === 'object' &&
+            payload.metadata.capturedContext &&
+            typeof payload.metadata.capturedContext === 'object'
+            ? (payload.metadata.capturedContext.__hub_capture &&
+                typeof payload.metadata.capturedContext.__hub_capture === 'object'
+                ? payload.metadata.capturedContext.__hub_capture.extraFields &&
+                    typeof payload.metadata.capturedContext.__hub_capture.extraFields === 'object'
+                    ? payload.metadata.capturedContext.__hub_capture.extraFields
+                    : undefined
+                : undefined)
+            : undefined
+    ];
+    for (const candidate of candidateSources) {
+        const map = coerceAliasRecord(candidate);
+        if (map) {
+            return map;
+        }
+    }
+    return undefined;
+}
+function coerceAliasRecord(candidate) {
+    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+        return undefined;
+    }
+    let hasEntry = false;
+    const output = {};
+    for (const [key, value] of Object.entries(candidate)) {
+        if (typeof key !== 'string' || typeof value !== 'string') {
+            continue;
+        }
+        const trimmedKey = key.trim();
+        if (!trimmedKey.length) {
+            continue;
+        }
+        output[trimmedKey] = value;
+        hasEntry = true;
+    }
+    return hasEntry ? output : undefined;
+}
+function createAnthropicToolNameResolver(source) {
+    if (!source) {
+        return undefined;
+    }
+    const lookup = new Map();
+    for (const [key, value] of Object.entries(source)) {
+        if (typeof key !== 'string' || typeof value !== 'string')
+            continue;
+        const canonical = key.trim();
+        if (!canonical.length)
+            continue;
+        const alias = value.trim() || canonical;
+        lookup.set(canonical, alias);
+        const lower = canonical.toLowerCase();
+        if (!lookup.has(lower)) {
+            lookup.set(lower, alias);
+        }
+    }
+    if (!lookup.size) {
+        return undefined;
+    }
+    return (name) => {
+        const trimmed = name.trim();
+        if (!trimmed.length) {
+            return name;
+        }
+        const direct = lookup.get(trimmed) ?? lookup.get(trimmed.toLowerCase());
+        if (direct) {
+            return direct;
+        }
+        const normalized = normalizeAnthropicToolName(trimmed);
+        if (normalized) {
+            return lookup.get(normalized) ?? lookup.get(normalized.toLowerCase()) ?? trimmed;
+        }
+        return trimmed;
+    };
+}
+function normalizeAnthropicToolChoice(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (isPlainRecord(value)) {
+        // Already an object – best-effort clone while trimming type, and also support
+        // Chat-style { type: 'function', function: { name } } by mapping to Anthropic's
+        // { type: 'tool', name } shape.
+        const cloned = cloneAnthropicSchema(value);
+        const rawType = typeof cloned.type === 'string' ? String(cloned.type).trim() : '';
+        if (rawType) {
+            cloned.type = rawType;
+            return cloned;
+        }
+        const selectorType = typeof cloned.type === 'string' ? String(cloned.type).trim() : '';
+        const fn = cloned.function;
+        if (selectorType === 'function' &&
+            fn &&
+            typeof fn === 'object' &&
+            typeof fn.name === 'string' &&
+            String(fn.name).trim().length) {
+            return { type: 'tool', name: String(fn.name).trim() };
+        }
+        return cloned;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed.length) {
+            return undefined;
+        }
+        const lower = trimmed.toLowerCase();
+        if (lower === 'auto') {
+            return { type: 'auto' };
+        }
+        if (lower === 'none') {
+            return { type: 'none' };
+        }
+        if (lower === 'any') {
+            return { type: 'any' };
+        }
+        if (lower === 'required') {
+            // "required" in canonical Chat roughly maps to Anthropic's "any" semantics:
+            // the model must choose some tool if available.
+            return { type: 'any' };
+        }
+        // Fallback: preserve custom mode as-is in type field.
+        return { type: trimmed };
+    }
+    return undefined;
+}
+export function buildAnthropicRequestFromOpenAIChat(chatReq) {
+    const requestBody = isObject(chatReq) ? chatReq : {};
+    const model = String(requestBody?.model || 'unknown');
+    const messages = [];
+    try {
+        const bridgePolicy = resolveBridgePolicy({ protocol: 'anthropic-messages' });
+        const actions = resolvePolicyActions(bridgePolicy, 'request_outbound');
+        if (actions?.length && Array.isArray(requestBody.messages)) {
+            const actionState = createBridgeActionState({
+                messages: requestBody.messages,
+                rawRequest: requestBody
+            });
+            runBridgeActionPipeline({
+                stage: 'request_outbound',
+                actions,
+                protocol: bridgePolicy?.protocol ?? 'anthropic-messages',
+                moduleType: bridgePolicy?.moduleType ?? 'anthropic-messages',
+                state: actionState
+            });
+        }
+    }
+    catch {
+        // ignore policy errors
+    }
+    const collectText = (val) => {
+        if (!val)
+            return '';
+        if (typeof val === 'string')
+            return val;
+        if (Array.isArray(val))
+            return val.map(collectText).join('');
+        if (typeof val === 'object') {
+            if (typeof val.text === 'string')
+                return String(val.text);
+            if (Array.isArray(val.content))
+                return collectText(val.content);
+        }
+        return '';
+    };
+    const msgs = Array.isArray(requestBody?.messages) ? requestBody.messages : [];
+    const mirrorShapes = extractMirrorShapesFromRequest(requestBody);
+    let mirrorIndex = 0;
+    const knownToolCallIds = new Set();
+    for (const m of msgs) {
+        if (!m || typeof m !== 'object')
+            continue;
+        const role = String(m.role || 'user');
+        if (role !== 'assistant')
+            continue;
+        const toolCalls = m.tool_calls;
+        if (!Array.isArray(toolCalls))
+            continue;
+        for (const tc of toolCalls) {
+            if (!tc || typeof tc !== 'object')
+                continue;
+            const id = sanitizeToolUseId(requireTrimmedString(tc.id, 'chat.tool_call.id'));
+            knownToolCallIds.add(id);
+        }
+    }
+    const systemBlocks = [];
+    const pushSystemBlock = (text) => {
+        const trimmed = text.trim();
+        if (trimmed)
+            systemBlocks.push({ type: 'text', text: trimmed });
+    };
+    try {
+        const sys = requestBody.system;
+        const ingestSystem = (val) => {
+            if (!val)
+                return;
+            if (typeof val === 'string') {
+                pushSystemBlock(requireSystemText(val, 'top-level system'));
+                return;
+            }
+            if (Array.isArray(val)) {
+                for (const entry of val)
+                    ingestSystem(entry);
+                return;
+            }
+            if (typeof val === 'object') {
+                pushSystemBlock(requireSystemText(val, 'top-level system'));
+                return;
+            }
+            throw new ProviderProtocolError('Anthropic bridge constraint violated: unsupported system payload type', {
+                code: 'MALFORMED_REQUEST',
+                protocol: 'anthropic-messages',
+                providerType: 'anthropic',
+                details: { context: 'top-level system', actualType: typeof val }
+            });
+        };
+        ingestSystem(sys);
+    }
+    catch {
+        // ignore system pre-scan errors
+    }
+    for (const m of msgs) {
+        if (!m || typeof m !== 'object')
+            continue;
+        const role = String(m.role || 'user');
+        let targetShape;
+        if (role !== 'system' && Array.isArray(mirrorShapes)) {
+            targetShape = mirrorShapes[mirrorIndex];
+            mirrorIndex += 1;
+        }
+        const contentNode = m.content;
+        const text = collectText(contentNode).trim();
+        if (role === 'system') {
+            if (!text) {
+                throw new ProviderProtocolError('Anthropic bridge constraint violated: Chat system message must contain text', {
+                    code: 'MALFORMED_REQUEST',
+                    protocol: 'anthropic-messages',
+                    providerType: 'anthropic',
+                    details: { context: 'chat.system', original: contentNode }
+                });
+            }
+            pushSystemBlock(text);
+            continue;
+        }
+        if (role === 'tool') {
+            const toolCallId = sanitizeToolUseId(requireTrimmedString(m.tool_call_id ?? m.call_id ?? m.tool_use_id ?? m.id, 'tool_result.tool_call_id'));
+            if (!knownToolCallIds.has(toolCallId)) {
+                throw new ProviderProtocolError(`Anthropic bridge constraint violated: tool result ${toolCallId} has no matching tool call`, {
+                    code: 'TOOL_PROTOCOL_ERROR',
+                    protocol: 'anthropic-messages',
+                    providerType: 'anthropic',
+                    details: { toolCallId }
+                });
+            }
+            const block = {
+                type: 'tool_result',
+                content: text
+            };
+            block.tool_use_id = toolCallId;
+            messages.push({
+                role: 'user',
+                content: [block]
+            });
+            continue;
+        }
+        const blocks = [];
+        if (Array.isArray(contentNode)) {
+            // Preserve or synthesize image blocks where possible, and fall back to text for the rest.
+            for (const entry of contentNode) {
+                if (!entry || typeof entry !== 'object')
+                    continue;
+                const node = entry;
+                const t = typeof node.type === 'string' ? node.type.toLowerCase() : '';
+                if (t === 'image' && node.source && typeof node.source === 'object') {
+                    // Pass-through Anthropic image block as-is.
+                    blocks.push({
+                        type: 'image',
+                        source: jsonClone(node.source)
+                    });
+                    continue;
+                }
+                if (t === 'image_url') {
+                    let url = '';
+                    const imageUrl = node.image_url;
+                    if (typeof imageUrl === 'string') {
+                        url = imageUrl;
+                    }
+                    else if (imageUrl && typeof imageUrl === 'object' && typeof imageUrl.url === 'string') {
+                        url = imageUrl.url;
+                    }
+                    const trimmed = url.trim();
+                    if (!trimmed.length)
+                        continue;
+                    const source = {};
+                    if (trimmed.startsWith('data:')) {
+                        const match = /^data:([^;,]+)?(?:;base64)?,(.*)$/s.exec(trimmed);
+                        if (match) {
+                            const mediaType = (match[1] || '').trim() || 'image/png';
+                            source.type = 'base64';
+                            source.media_type = mediaType;
+                            source.data = match[2] || '';
+                        }
+                        else {
+                            source.type = 'url';
+                            source.url = trimmed;
+                        }
+                    }
+                    else {
+                        source.type = 'url';
+                        source.url = trimmed;
+                    }
+                    blocks.push({
+                        type: 'image',
+                        source
+                    });
+                }
+            }
+        }
+        if (text) {
+            blocks.push({ type: 'text', text });
+        }
+        const toolCalls = Array.isArray(m.tool_calls) ? m.tool_calls : [];
+        for (const tc of toolCalls) {
+            if (!tc || typeof tc !== 'object')
+                continue;
+            const id = sanitizeToolUseId(requireTrimmedString(tc.id, 'chat.tool_call.id'));
+            const fn = tc.function || {};
+            const name = requireTrimmedString(fn.name, 'chat.tool_call.function.name');
+            const argsRaw = fn.arguments;
+            let input;
+            if (typeof argsRaw === 'string') {
+                const parsed = parseLenientJsonishWithNative(argsRaw);
+                input = parsed && typeof parsed === 'object' ? parsed : { _raw: argsRaw };
+            }
+            else {
+                input = argsRaw ?? {};
+            }
+            input = normalizeShellLikeToolInput(name, input);
+            blocks.push({ type: 'tool_use', id, name, input });
+        }
+        if (blocks.length > 0) {
+            const hasStructuredBlocks = blocks.some((block) => block && typeof block === 'object' && block.type !== 'text');
+            let contentNode = blocks;
+            if (!hasStructuredBlocks && (targetShape === 'string' || !targetShape)) {
+                contentNode = text;
+            }
+            messages.push({ role, content: contentNode });
+        }
+    }
+    const out = { model };
+    if (systemBlocks.length) {
+        out.system = systemBlocks;
+    }
+    out.messages = messages;
+    const anthropicTools = mapChatToolsToAnthropicTools(requestBody.tools);
+    if (anthropicTools !== undefined) {
+        out.tools = anthropicTools;
+    }
+    const normalizedToolChoice = normalizeAnthropicToolChoice(requestBody.tool_choice);
+    if (normalizedToolChoice !== undefined) {
+        out.tool_choice = normalizedToolChoice;
+    }
+    if (requestBody.thinking !== undefined) {
+        try {
+            out.thinking = JSON.parse(JSON.stringify(requestBody.thinking));
+        }
+        catch {
+            out.thinking = requestBody.thinking;
+        }
+    }
+    try {
+        if (requestBody.metadata && typeof requestBody.metadata === 'object') {
+            out.metadata = JSON.parse(JSON.stringify(requestBody.metadata));
+        }
+    }
+    catch {
+        // best-effort metadata clone
+    }
+    const mt = Number(requestBody.max_tokens ??
+        requestBody.maxTokens ??
+        NaN);
+    if (Number.isFinite(mt) && mt > 0)
+        out.max_tokens = mt;
+    if (typeof requestBody.temperature === 'number') {
+        out.temperature = Number(requestBody.temperature);
+    }
+    if (typeof requestBody.top_p === 'number') {
+        out.top_p = Number(requestBody.top_p);
+    }
+    if (typeof requestBody.stream === 'boolean') {
+        out.stream = Boolean(requestBody.stream);
+    }
+    const stop = requestBody.stop;
+    if (typeof stop === 'string' && stop.trim()) {
+        out.stop_sequences = [stop.trim()];
+    }
+    else if (Array.isArray(stop) && stop.length > 0) {
+        out.stop_sequences = stop.map((s) => String(s)).filter(Boolean);
+    }
+    return pruneAnthropicRequest(out);
+}
+function isPlainRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function coerceJsonValue(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => coerceJsonValue(entry));
+    }
+    if (isPlainRecord(value)) {
+        const obj = {};
+        for (const [key, entry] of Object.entries(value)) {
+            obj[key] = coerceJsonValue(entry);
+        }
+        return obj;
+    }
+    return String(value ?? '');
+}
+function cloneAnthropicSchema(value) {
+    if (isPlainRecord(value)) {
+        try {
+            return JSON.parse(JSON.stringify(value));
+        }
+        catch {
+            return 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;
+    }
+    const result = [];
+    rawTools.forEach((entry, index) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            missing?.push({
+                path: `tools[${index}]`,
+                reason: 'invalid_entry',
+                originalValue: jsonClone(coerceJsonValue(entry))
+            });
+            return;
+        }
+        const name = typeof entry.name === 'string'
+            ? entry.name
+            : undefined;
+        if (!name) {
+            missing?.push({ path: `tools[${index}].name`, reason: 'missing_name' });
+            return;
+        }
+        const description = typeof entry.description === 'string'
+            ? entry.description
+            : undefined;
+        const schemaSource = entry.input_schema;
+        const parameters = cloneAnthropicSchema(schemaSource);
+        result.push({
+            type: 'function',
+            function: {
+                name,
+                description,
+                parameters
+            }
+        });
+    });
+    return result.length ? result : undefined;
+}
+function convertBridgeToolToAnthropic(def) {
+    if (!def || typeof def !== 'object') {
+        return null;
+    }
+    const fnNode = def.function && typeof def.function === 'object' ? def.function : undefined;
+    const name = typeof fnNode?.name === 'string'
+        ? fnNode.name
+        : typeof def.name === 'string'
+            ? def.name
+            : undefined;
+    if (!name) {
+        return null;
+    }
+    const description = typeof fnNode?.description === 'string'
+        ? fnNode.description
+        : typeof def.description === 'string'
+            ? def.description
+            : undefined;
+    const schemaSource = fnNode?.parameters ?? def.parameters;
+    const inputSchema = sanitizeAnthropicBuiltinInputSchema(name, schemaSource);
+    const tool = {
+        name,
+        input_schema: inputSchema
+    };
+    if (description !== undefined) {
+        tool.description = description;
+    }
+    return tool;
+}
+export function mapAnthropicToolsToChat(rawTools, missing) {
+    const prepared = prepareAnthropicBridgeTools(rawTools, missing);
+    if (prepared === undefined) {
+        return undefined;
+    }
+    return mapBridgeToolsToChat(prepared, { sanitizeName: normalizeAnthropicToolName });
+}
+export function mapChatToolsToAnthropicTools(rawTools) {
+    if (!Array.isArray(rawTools) || rawTools.length === 0) {
+        return undefined;
+    }
+    const bridgeDefs = mapChatToolsToBridge(rawTools, { sanitizeName: denormalizeAnthropicToolName });
+    if (!bridgeDefs || !bridgeDefs.length) {
+        return undefined;
+    }
+    const converted = bridgeDefs
+        .map((def) => convertBridgeToolToAnthropic(def))
+        .filter((entry) => !!entry);
+    return converted.length ? converted : undefined;
+}
+function pruneAnthropicRequest(payload) {
+    for (const key of Object.keys(payload)) {
+        if (!ANTHROPIC_TOP_LEVEL_FIELDS.has(key)) {
+            delete payload[key];
+        }
+    }
+    return payload;
+}
+function extractMirrorShapesFromRequest(source) {
+    const directMirror = source &&
+        typeof source === 'object' &&
+        source.__anthropicMirror &&
+        typeof source.__anthropicMirror === 'object'
+        ? source.__anthropicMirror
+        : extractMirrorFromMetadata(source);
+    if (!directMirror) {
+        return undefined;
+    }
+    const shapes = directMirror.messageContentShape;
+    if (!Array.isArray(shapes)) {
+        return undefined;
+    }
+    return shapes.map((entry) => (typeof entry === 'string' ? entry : String(entry ?? '')));
+}
+function extractMirrorFromMetadata(source) {
+    if (!source || typeof source !== 'object') {
+        return undefined;
+    }
+    const metadata = source.metadata;
+    if (!metadata || typeof metadata !== 'object') {
+        return undefined;
+    }
+    const extraFields = metadata.extraFields;
+    if (!extraFields || typeof extraFields !== 'object') {
+        return undefined;
+    }
+    const mirror = extraFields.anthropicMirror;
+    return mirror && typeof mirror === 'object' ? mirror : undefined;
+}
+export function buildAnthropicToolAliasMap(rawTools) {
+    if (!Array.isArray(rawTools) || rawTools.length === 0) {
+        return undefined;
+    }
+    const aliasMap = new Map();
+    for (const entry of rawTools) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            continue;
+        }
+        const rawName = typeof entry.name === 'string'
+            ? entry.name.trim()
+            : undefined;
+        if (!rawName) {
+            continue;
+        }
+        const normalized = normalizeAnthropicToolName(rawName) ?? rawName;
+        const canonicalKey = normalized.trim();
+        if (!canonicalKey.length) {
+            continue;
+        }
+        aliasMap.set(canonicalKey, rawName);
+        const lowered = canonicalKey.toLowerCase();
+        const lowerKey = canonicalKey.toLowerCase();
+        if (lowerKey !== canonicalKey && !aliasMap.has(lowerKey)) {
+            aliasMap.set(lowerKey, rawName);
+        }
+    }
+    if (!aliasMap.size) {
+        return undefined;
+    }
+    const serialized = {};
+    for (const [key, value] of aliasMap.entries()) {
+        serialized[key] = value;
+    }
+    return serialized;
+}