@jsonstudio/rcc 0.85.9 → 0.89.3

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

@@ -0,0 +1,975 @@
+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';
+function isObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+function safeJson(v) {
+    try {
+        return JSON.stringify(v ?? {});
+    }
+    catch {
+        return '{}';
+    }
+}
+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 requireTrimmedString(value, context) {
+    if (typeof value !== 'string') {
+        throw new Error(`Anthropic bridge constraint violated: ${context} must be a string`);
+    }
+    const trimmed = value.trim();
+    if (!trimmed.length) {
+        throw new Error(`Anthropic bridge constraint violated: ${context} must not be empty`);
+    }
+    return trimmed;
+}
+function requireSystemText(block, context) {
+    const text = flattenAnthropicText(block).trim();
+    if (!text) {
+        throw new Error(`Anthropic bridge constraint violated: ${context} must contain text`);
+    }
+    return text;
+}
+const ANTHROPIC_TOOL_NAME_ALIASES = new Map([
+    ['bash', 'shell_command'],
+    ['shell', 'shell_command'],
+    ['terminal', 'shell_command']
+]);
+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'
+]);
+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 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) {
+    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 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 === '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;
+                toolCalls.push({ 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) {
+            const msg = {
+                role,
+                content: (hasText ? normalized.contentText : undefined) ?? combinedText ?? ''
+            };
+            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 ('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
+    }
+    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 reasoningField = 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() });
+    }
+    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 = 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') {
+                try {
+                    input = JSON.parse(argsRaw);
+                }
+                catch {
+                    input = { _raw: argsRaw };
+                }
+            }
+            else {
+                input = argsRaw ?? {};
+            }
+            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;
+        }
+        return lookup.get(trimmed) ?? lookup.get(trimmed.toLowerCase()) ?? trimmed;
+    };
+}
+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 = 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 Error('Anthropic bridge constraint violated: unsupported system payload type');
+        };
+        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 text = collectText(m.content).trim();
+        if (role === 'system') {
+            if (!text) {
+                throw new Error('Anthropic bridge constraint violated: Chat system message must contain text');
+            }
+            pushSystemBlock(text);
+            continue;
+        }
+        if (role === 'tool') {
+            const toolCallId = 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 Error(`Anthropic bridge constraint violated: tool result ${toolCallId} has no matching tool call`);
+            }
+            const block = {
+                type: 'tool_result',
+                content: text
+            };
+            block.tool_use_id = toolCallId;
+            messages.push({
+                role: 'user',
+                content: [block]
+            });
+            continue;
+        }
+        const blocks = [];
+        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 = 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') {
+                try {
+                    input = JSON.parse(argsRaw);
+                }
+                catch {
+                    input = { _raw: argsRaw };
+                }
+            }
+            else {
+                input = argsRaw ?? {};
+            }
+            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 (targetShape === 'string' || (!targetShape && !hasStructuredBlocks)) {
+                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;
+    }
+    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 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 = cloneAnthropicSchema(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 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;
+}