@jsonstudio/llms 0.4.6 → 0.6.2

package/dist/conversion/hub/response/response-runtime.d.ts

@@ -0,0 +1,8 @@
+import type { JsonObject } from '../types/json.js';
+type ToolAliasMap = Record<string, string>;
+interface AnthropicResponseOptions {
+    aliasMap?: ToolAliasMap;
+}
+export declare function buildOpenAIChatFromAnthropicMessage(payload: JsonObject, options?: AnthropicResponseOptions): JsonObject;
+export declare function buildAnthropicResponseFromChat(chatResponse: JsonObject, options?: AnthropicResponseOptions): JsonObject;
+export {};

package/dist/conversion/hub/response/response-runtime.js

@@ -2,6 +2,8 @@ import { extractToolCallsFromReasoningText } from '../../shared/reasoning-tool-p
 import { deriveToolCallKey } from '../../shared/tool-call-utils.js';
 import { createBridgeActionState, runBridgeActionPipeline } from '../../shared/bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from '../../shared/bridge-policies.js';
+import { normalizeAnthropicToolName } from '../../shared/anthropic-message-utils.js';
+import { registerResponsesReasoning, consumeResponsesReasoning, registerResponsesOutputTextMeta, consumeResponsesOutputTextMeta } from '../../shared/responses-reasoning-registry.js';
 function flattenAnthropicContent(content) {
     if (typeof content === 'string')
         return content;
@@ -19,12 +21,106 @@ function flattenAnthropicContent(content) {
     }
     return '';
 }
-export function buildOpenAIChatFromAnthropicMessage(payload) {
+function createToolNameResolver(options) {
+    const reverse = new Map();
+    const aliasMap = options?.aliasMap;
+    if (aliasMap && typeof aliasMap === 'object') {
+        for (const [canonical, providerName] of Object.entries(aliasMap)) {
+            if (typeof canonical !== 'string' || typeof providerName !== 'string')
+                continue;
+            const normalizedProvider = providerName.trim().toLowerCase();
+            if (!normalizedProvider.length)
+                continue;
+            if (!reverse.has(normalizedProvider)) {
+                reverse.set(normalizedProvider, canonical.trim());
+            }
+        }
+    }
+    return (rawName) => {
+        const trimmed = typeof rawName === 'string' ? rawName.trim() : '';
+        if (!trimmed.length) {
+            return '';
+        }
+        const lookup = reverse.get(trimmed.toLowerCase());
+        if (lookup && lookup.trim().length) {
+            return lookup.trim();
+        }
+        const normalized = normalizeAnthropicToolName(trimmed);
+        return (normalized && normalized.trim().length ? normalized : trimmed).trim();
+    };
+}
+function extractAliasMapFromChatPayload(payload) {
+    const metadata = payload?.metadata;
+    if (metadata && typeof metadata === 'object' && metadata.anthropicToolNameMap) {
+        const candidate = metadata.anthropicToolNameMap;
+        if (candidate && typeof candidate === 'object') {
+            const serialized = {};
+            for (const [key, value] of Object.entries(candidate)) {
+                if (typeof key === 'string' && typeof value === 'string') {
+                    const trimmedKey = key.trim();
+                    const trimmedValue = value.trim();
+                    if (trimmedKey.length && trimmedValue.length) {
+                        serialized[trimmedKey] = trimmedValue;
+                    }
+                }
+            }
+            if (Object.keys(serialized).length) {
+                return serialized;
+            }
+        }
+    }
+    if (payload?.anthropicToolNameMap && typeof payload.anthropicToolNameMap === 'object') {
+        const map = {};
+        for (const [key, value] of Object.entries(payload.anthropicToolNameMap)) {
+            if (typeof key === 'string' && typeof value === 'string') {
+                const trimmedKey = key.trim();
+                const trimmedValue = value.trim();
+                if (trimmedKey.length && trimmedValue.length) {
+                    map[trimmedKey] = trimmedValue;
+                }
+            }
+        }
+        if (Object.keys(map).length) {
+            return map;
+        }
+    }
+    return undefined;
+}
+function createToolAliasSerializer(aliasMap) {
+    if (!aliasMap || typeof aliasMap !== 'object') {
+        return (name) => name;
+    }
+    const lookup = new Map();
+    for (const [canonical, providerName] of Object.entries(aliasMap)) {
+        if (typeof canonical !== 'string' || typeof providerName !== 'string')
+            continue;
+        const key = canonical.trim().toLowerCase();
+        if (!key.length)
+            continue;
+        if (!lookup.has(key)) {
+            lookup.set(key, providerName);
+        }
+    }
+    if (!lookup.size) {
+        return (name) => name;
+    }
+    return (name) => {
+        const trimmed = typeof name === 'string' ? name.trim() : '';
+        if (!trimmed.length) {
+            return name;
+        }
+        const resolved = lookup.get(trimmed.toLowerCase());
+        return resolved ? resolved : name;
+    };
+}
+export function buildOpenAIChatFromAnthropicMessage(payload, options) {
     const content = Array.isArray(payload?.content) ? payload.content : [];
     const textParts = [];
     const toolCalls = [];
+    const aliasCollector = {};
     const inferredToolCalls = [];
     const reasoningParts = [];
+    const resolveToolName = createToolNameResolver(options);
     if (typeof payload?.reasoning_content === 'string' && payload.reasoning_content.trim().length) {
         reasoningParts.push(String(payload.reasoning_content).trim());
     }
@@ -36,9 +132,10 @@ export function buildOpenAIChatFromAnthropicMessage(payload) {
             textParts.push(part.text);
         }
         else if (kind === 'tool_use') {
-            const name = typeof part.name === 'string'
+            const rawName = typeof part.name === 'string'
                 ? String(part.name)
                 : '';
+            const name = rawName ? resolveToolName(rawName) : '';
             const id = typeof part.id === 'string'
                 ? String(part.id)
                 : `call_${Math.random().toString(36).slice(2, 10)}`;
@@ -57,6 +154,10 @@ export function buildOpenAIChatFromAnthropicMessage(payload) {
             }
             if (name) {
                 toolCalls.push({ id, name, args });
+                const trimmedRaw = rawName.trim();
+                if (trimmedRaw.length && !aliasCollector[name]) {
+                    aliasCollector[name] = trimmedRaw;
+                }
             }
         }
         else if (kind === 'thinking' || kind === 'reasoning') {
@@ -137,7 +238,7 @@ export function buildOpenAIChatFromAnthropicMessage(payload) {
     }
     const stopReason = typeof payload['stop_reason'] === 'string' ? payload['stop_reason'] : undefined;
     const finishReason = canonicalToolCalls.length ? 'tool_calls' : mapFinishReason(stopReason);
-    return {
+    const chatResponse = {
         id: typeof payload.id === 'string' ? payload.id : `chatcmpl_${Date.now()}`,
         object: 'chat.completion',
         created: typeof payload?.['created'] === 'number' ? payload['created'] : Math.floor(Date.now() / 1000),
@@ -153,10 +254,24 @@ export function buildOpenAIChatFromAnthropicMessage(payload) {
             ? payload['usage']
             : undefined
     };
+    const preserved = consumeResponsesReasoning(chatResponse.id);
+    if (preserved && preserved.length) {
+        chatResponse.__responses_reasoning = preserved;
+    }
+    const preservedOutputMeta = consumeResponsesOutputTextMeta(chatResponse.id);
+    if (preservedOutputMeta) {
+        chatResponse.__responses_output_text_meta = preservedOutputMeta;
+    }
+    if (Object.keys(aliasCollector).length && !chatResponse.anthropicToolNameMap) {
+        chatResponse.anthropicToolNameMap = aliasCollector;
+    }
+    return chatResponse;
 }
-export function buildAnthropicResponseFromChat(chatResponse) {
+export function buildAnthropicResponseFromChat(chatResponse, options) {
     const choice = Array.isArray(chatResponse?.choices) ? chatResponse.choices[0] : undefined;
     const message = choice && typeof choice === 'object' ? choice.message : undefined;
+    const aliasMap = options?.aliasMap ?? extractAliasMapFromChatPayload(chatResponse);
+    const outboundAliasSerializer = createToolAliasSerializer(aliasMap);
     if (message) {
         try {
             const bridgePolicy = resolveBridgePolicy({ protocol: 'anthropic-messages' });
@@ -198,6 +313,7 @@ export function buildAnthropicResponseFromChat(chatResponse) {
         const fn = call.function || {};
         if (typeof fn?.name !== 'string')
             continue;
+        const serializedName = outboundAliasSerializer(fn.name);
         let parsedArgs = {};
         const args = fn.arguments;
         if (typeof args === 'string') {
@@ -214,10 +330,22 @@ export function buildAnthropicResponseFromChat(chatResponse) {
         contentBlocks.push({
             type: 'tool_use',
             id: typeof call.id === 'string' ? call.id : `call_${Math.random().toString(36).slice(2, 8)}`,
-            name: fn.name,
+            name: serializedName,
             input: parsedArgs
         });
     }
+    const toolResults = extractToolResultBlocks(chatResponse);
+    for (const block of toolResults) {
+        const sanitized = {
+            type: 'tool_result',
+            tool_use_id: block.tool_use_id,
+            content: block.content ?? ''
+        };
+        if (typeof block.is_error === 'boolean') {
+            sanitized.is_error = block.is_error;
+        }
+        contentBlocks.push(sanitized);
+    }
     const usage = chatResponse?.usage;
     const stopReason = typeof choice?.finish_reason === 'string'
         ? choice.finish_reason
@@ -244,7 +372,14 @@ export function buildAnthropicResponseFromChat(chatResponse) {
             }
             : undefined
     };
-    return sanitizeAnthropicMessage(raw);
+    const sanitized = sanitizeAnthropicMessage(raw);
+    if (Array.isArray(chatResponse?.__responses_reasoning)) {
+        registerResponsesReasoning(sanitized.id, chatResponse.__responses_reasoning);
+    }
+    if (chatResponse?.__responses_output_text_meta) {
+        registerResponsesOutputTextMeta(sanitized.id, chatResponse.__responses_output_text_meta);
+    }
+    return sanitized;
 }
 function sanitizeAnthropicMessage(message) {
     const sanitized = {};
@@ -276,6 +411,17 @@ function sanitizeContentBlock(block) {
             return null;
         return { type: 'text', text: block.text };
     }
+    if (type === 'thinking' || type === 'reasoning') {
+        const text = typeof block.text === 'string'
+            ? block.text
+            : flattenAnthropicContent(block.content);
+        if (!text || !String(text).trim().length)
+            return null;
+        return {
+            type: type === 'reasoning' ? 'reasoning' : 'thinking',
+            text: String(text)
+        };
+    }
     if (type === 'tool_use') {
         const id = typeof block.id === 'string' && block.id.trim() ? block.id : `call_${Math.random().toString(36).slice(2, 8)}`;
         const name = typeof block.name === 'string' ? block.name : '';
@@ -303,3 +449,90 @@ function sanitizeContentBlock(block) {
     }
     return null;
 }
+function extractToolResultBlocks(chatResponse) {
+    const results = [];
+    const seen = new Set();
+    const append = (candidate) => {
+        if (!candidate)
+            return;
+        if (seen.has(candidate.tool_use_id)) {
+            return;
+        }
+        seen.add(candidate.tool_use_id);
+        results.push(candidate);
+    };
+    const primary = Array.isArray(chatResponse.tool_outputs)
+        ? chatResponse.tool_outputs
+        : [];
+    primary.forEach(entry => append(normalizeToolResultEntry(entry)));
+    const meta = chatResponse.metadata;
+    if (meta && typeof meta === 'object') {
+        const captured = meta.capturedToolResults;
+        if (Array.isArray(captured)) {
+            captured.forEach(entry => append(normalizeToolResultEntry(entry)));
+        }
+    }
+    if (choiceHasCapturedResults(chatResponse)) {
+        try {
+            const choice = Array.isArray(chatResponse?.choices) ? chatResponse.choices[0] : undefined;
+            const msgMeta = choice && typeof choice === 'object' ? choice.message : undefined;
+            const captured = msgMeta && typeof msgMeta === 'object'
+                ? msgMeta.capturedToolResults
+                : undefined;
+            if (Array.isArray(captured)) {
+                captured.forEach(entry => append(normalizeToolResultEntry(entry)));
+            }
+        }
+        catch {
+            /* ignore best-effort metadata extraction */
+        }
+    }
+    return results;
+}
+function choiceHasCapturedResults(chatResponse) {
+    if (!Array.isArray(chatResponse?.choices)) {
+        return false;
+    }
+    const first = chatResponse.choices[0];
+    if (!first || typeof first !== 'object') {
+        return false;
+    }
+    const message = first.message;
+    if (!message || typeof message !== 'object') {
+        return false;
+    }
+    return Array.isArray(message.capturedToolResults);
+}
+function normalizeToolResultEntry(entry) {
+    if (!entry || typeof entry !== 'object') {
+        return null;
+    }
+    const rawId = entry.tool_call_id ?? entry.call_id ?? entry.id;
+    if (typeof rawId !== 'string' || !rawId.trim().length) {
+        return null;
+    }
+    const toolUseId = rawId.trim();
+    const rawContent = 'content' in entry ? entry.content : entry.output;
+    const content = normalizeToolContent(rawContent);
+    const isError = typeof entry.is_error === 'boolean' ? entry.is_error : undefined;
+    return {
+        tool_use_id: toolUseId,
+        content,
+        is_error: isError
+    };
+}
+function normalizeToolContent(value) {
+    if (value == null) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    try {
+        const serialized = JSON.stringify(value);
+        return serialized;
+    }
+    catch {
+        return String(value);
+    }
+}

package/dist/conversion/hub/semantic-mappers/anthropic-mapper.d.ts

@@ -0,0 +1,8 @@
+import type { SemanticMapper } from '../format-adapters/index.js';
+import type { AdapterContext, ChatEnvelope } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+export declare class AnthropicSemanticMapper implements SemanticMapper {
+    private readonly chatMapper;
+    toChat(format: FormatEnvelope, ctx: AdapterContext): Promise<ChatEnvelope>;
+    fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope>;
+}

package/dist/conversion/hub/semantic-mappers/anthropic-mapper.js

@@ -3,7 +3,9 @@ import { buildOpenAIChatFromAnthropic, buildAnthropicRequestFromOpenAIChat } fro
 import { createBridgeActionState, runBridgeActionPipeline } from '../../shared/bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from '../../shared/bridge-policies.js';
 import { encodeMetadataPassthrough, extractMetadataPassthrough } from '../../shared/metadata-passthrough.js';
-import { mapAnthropicToolsToChat } from '../../shared/anthropic-message-utils.js';
+import { buildAnthropicToolAliasMap } from '../../shared/anthropic-message-utils.js';
+import { ChatSemanticMapper } from './chat-mapper.js';
+import { ensureProtocolState, getProtocolState } from '../../shared/protocol-state.js';
 const ANTHROPIC_PARAMETER_KEYS = [
     'model',
     'temperature',
@@ -32,6 +34,14 @@ const ANTHROPIC_TOP_LEVEL_FIELDS = new Set([
 ]);
 const PASSTHROUGH_METADATA_PREFIX = 'rcc_passthrough_';
 const PASSTHROUGH_PARAMETERS = ['tool_choice'];
+function sanitizeAnthropicPayload(payload) {
+    for (const key of Object.keys(payload)) {
+        if (!ANTHROPIC_TOP_LEVEL_FIELDS.has(key)) {
+            delete payload[key];
+        }
+    }
+    return payload;
+}
 function collectParameters(payload) {
     const params = {};
     for (const key of ANTHROPIC_PARAMETER_KEYS) {
@@ -44,39 +54,18 @@ function collectParameters(payload) {
     }
     return Object.keys(params).length ? params : undefined;
 }
-function normalizeToolContent(content) {
-    if (typeof content === 'string')
-        return content;
-    if (content == null)
-        return '';
-    try {
-        return JSON.stringify(content);
+function cloneAnthropicSystemBlocks(value) {
+    if (value === undefined || value === null) {
+        return undefined;
     }
-    catch {
-        return String(content ?? '');
+    const blocks = Array.isArray(value) ? value : [value];
+    if (!blocks.length) {
+        return undefined;
     }
-}
-function collectToolOutputsFromMessages(messages, missing) {
-    const outputs = [];
-    messages.forEach((msg, index) => {
-        if (!msg || typeof msg !== 'object')
-            return;
-        if (msg.role !== 'tool')
-            return;
-        const callId = msg.tool_call_id || msg.id;
-        if (typeof callId !== 'string' || !callId.trim()) {
-            missing.push({ path: `messages[${index}].tool_call_id`, reason: 'missing_tool_call_id' });
-            return;
-        }
-        outputs.push({
-            tool_call_id: callId.trim(),
-            content: normalizeToolContent(msg.content),
-            name: typeof msg.name === 'string' ? msg.name : undefined
-        });
-    });
-    return outputs.length ? outputs : undefined;
+    return blocks.map((entry) => jsonClone(entry));
 }
 export class AnthropicSemanticMapper {
+    chatMapper = new ChatSemanticMapper();
     async toChat(format, ctx) {
         const payload = (format.payload ?? {});
         const missing = [];
@@ -84,39 +73,114 @@ export class AnthropicSemanticMapper {
             missing.push({ path: 'messages', reason: 'absent' });
         if (typeof payload.model !== 'string')
             missing.push({ path: 'model', reason: 'absent' });
-        const openaiPayload = buildOpenAIChatFromAnthropic(payload);
-        const messages = Array.isArray(openaiPayload.messages)
-            ? openaiPayload.messages
-            : [];
-        const toolOutputs = collectToolOutputsFromMessages(messages, missing);
-        const tools = mapAnthropicToolsToChat(payload.tools, missing);
-        let parameters = collectParameters(payload);
         const passthrough = extractMetadataPassthrough(payload.metadata, {
             prefix: PASSTHROUGH_METADATA_PREFIX,
             keys: PASSTHROUGH_PARAMETERS
         });
-        if (passthrough.passthrough) {
-            parameters = { ...(parameters || {}), ...passthrough.passthrough };
+        const openaiPayload = buildOpenAIChatFromAnthropic(payload);
+        const canonicalContext = {
+            ...ctx,
+            providerProtocol: 'openai-chat',
+            entryEndpoint: ctx.entryEndpoint || '/v1/chat/completions'
+        };
+        const chatEnvelope = await this.chatMapper.toChat({
+            protocol: 'openai-chat',
+            direction: 'request',
+            payload: openaiPayload
+        }, canonicalContext);
+        const metadata = chatEnvelope.metadata ?? { context: canonicalContext };
+        chatEnvelope.metadata = metadata;
+        metadata.context = canonicalContext;
+        const resolveExtraFields = () => {
+            if (!isJsonObject(metadata.extraFields)) {
+                metadata.extraFields = {};
+            }
+            return metadata.extraFields;
+        };
+        const protocolState = ensureProtocolState(metadata, 'anthropic');
+        const systemBlocks = cloneAnthropicSystemBlocks(payload.system);
+        if (systemBlocks) {
+            protocolState.systemBlocks = systemBlocks;
         }
-        const metadata = { context: ctx };
         if (payload.tools && Array.isArray(payload.tools) && payload.tools.length === 0) {
             metadata.toolsFieldPresent = true;
+            resolveExtraFields().toolsFieldPresent = true;
+        }
+        const aliasMap = buildAnthropicToolAliasMap(payload.tools);
+        if (aliasMap) {
+            const extraFields = resolveExtraFields();
+            ctx.anthropicToolNameMap = aliasMap;
+            canonicalContext.anthropicToolNameMap = aliasMap;
+            metadata.anthropicToolNameMap = aliasMap;
+            extraFields.anthropicToolNameMap = aliasMap;
+        }
+        if (Array.isArray(payload.messages) && payload.messages.length) {
+            const shapes = payload.messages.map((entry) => {
+                if (!entry || typeof entry !== 'object') {
+                    return 'unknown';
+                }
+                const rawContent = entry.content;
+                if (typeof rawContent === 'string') {
+                    return 'string';
+                }
+                if (Array.isArray(rawContent)) {
+                    return 'array';
+                }
+                if (rawContent === null || rawContent === undefined) {
+                    return 'null';
+                }
+                return typeof rawContent;
+            });
+            const extraFields = resolveExtraFields();
+            const mirrorNode = extraFields.anthropicMirror && typeof extraFields.anthropicMirror === 'object'
+                ? extraFields.anthropicMirror
+                : {};
+            mirrorNode.messageContentShape = shapes;
+            extraFields.anthropicMirror = mirrorNode;
         }
         if (missing.length) {
-            metadata.missingFields = missing;
+            metadata.missingFields = Array.isArray(metadata.missingFields)
+                ? [...metadata.missingFields, ...missing]
+                : missing;
         }
-        if (passthrough.metadata) {
-            metadata.providerMetadata = passthrough.metadata;
+        const providerMetadata = passthrough.metadata ??
+            (payload.metadata && isJsonObject(payload.metadata) ? jsonClone(payload.metadata) : undefined);
+        if (providerMetadata) {
+            metadata.providerMetadata = providerMetadata;
         }
-        else if (payload.metadata && isJsonObject(payload.metadata)) {
-            metadata.providerMetadata = jsonClone(payload.metadata);
+        const mergedParameters = { ...(chatEnvelope.parameters ?? {}) };
+        const mergeParameters = (source) => {
+            if (!source) {
+                return;
+            }
+            for (const [key, value] of Object.entries(source)) {
+                if (mergedParameters[key] !== undefined) {
+                    continue;
+                }
+                mergedParameters[key] = jsonClone(value);
+            }
+        };
+        mergeParameters(collectParameters(payload));
+        if (providerMetadata) {
+            mergedParameters.metadata = jsonClone(providerMetadata);
+        }
+        if (passthrough.passthrough) {
+            for (const [key, value] of Object.entries(passthrough.passthrough)) {
+                mergedParameters[key] = jsonClone(value);
+            }
+        }
+        if (Object.keys(mergedParameters).length) {
+            chatEnvelope.parameters = mergedParameters;
+        }
+        else {
+            delete chatEnvelope.parameters;
         }
         try {
             const bridgePolicy = resolveBridgePolicy({ protocol: 'anthropic-messages' });
             const actions = resolvePolicyActions(bridgePolicy, 'request_inbound');
             if (actions?.length) {
                 const actionState = createBridgeActionState({
-                    messages: messages,
+                    messages: chatEnvelope.messages,
                     rawRequest: payload,
                     metadata: metadata
                 });
@@ -133,13 +197,7 @@ export class AnthropicSemanticMapper {
         catch {
             // best-effort metadata extraction
         }
-        return {
-            messages,
-            tools,
-            toolOutputs,
-            parameters,
-            metadata
-        };
+        return chatEnvelope;
     }
     async fromChat(chat, ctx) {
         const model = chat.parameters?.model;
@@ -147,11 +205,21 @@ export class AnthropicSemanticMapper {
             throw new Error('ChatEnvelope.parameters.model is required for anthropic-messages outbound conversion');
         }
         const baseRequest = {
-            ...(chat.parameters || {}),
             model,
             messages: chat.messages,
             tools: chat.tools
         };
+        const trimmedParameters = chat.parameters && typeof chat.parameters === 'object' ? chat.parameters : undefined;
+        if (trimmedParameters) {
+            for (const [key, value] of Object.entries(trimmedParameters)) {
+                if (ANTHROPIC_TOP_LEVEL_FIELDS.has(key) || key === 'stop') {
+                    if (key === 'messages' || key === 'tools') {
+                        continue;
+                    }
+                    baseRequest[key] = value;
+                }
+            }
+        }
         const passthroughMetadata = encodeMetadataPassthrough(chat.parameters, {
             prefix: PASSTHROUGH_METADATA_PREFIX,
             keys: PASSTHROUGH_PARAMETERS
@@ -175,8 +243,19 @@ export class AnthropicSemanticMapper {
         if (chat.metadata?.toolsFieldPresent && (!Array.isArray(chat.tools) || chat.tools.length === 0)) {
             baseRequest.tools = [];
         }
+        const protocolState = getProtocolState(chat.metadata, 'anthropic');
+        if (protocolState?.systemBlocks !== undefined) {
+            baseRequest.system = jsonClone(protocolState.systemBlocks);
+        }
+        if (chat.metadata &&
+            typeof chat.metadata === 'object' &&
+            chat.metadata.extraFields &&
+            typeof chat.metadata.extraFields === 'object' &&
+            chat.metadata.extraFields.anthropicMirror) {
+            baseRequest.__anthropicMirror = jsonClone(chat.metadata.extraFields.anthropicMirror ?? {});
+        }
         const payloadSource = buildAnthropicRequestFromOpenAIChat(baseRequest);
-        const payload = JSON.parse(JSON.stringify(payloadSource));
+        const payload = sanitizeAnthropicPayload(JSON.parse(JSON.stringify(payloadSource)));
         if (chat.metadata?.toolsFieldPresent && (!Array.isArray(chat.tools) || chat.tools.length === 0)) {
             payload.tools = [];
         }
@@ -210,6 +289,7 @@ export class AnthropicSemanticMapper {
         catch {
             // ignore metadata propagation failures
         }
+        sanitizeAnthropicPayload(payload);
         return {
             protocol: 'anthropic-messages',
             direction: 'response',