@jsonstudio/llms 0.6.568 → 0.6.626

package/dist/conversion/compat/profiles/responses-output2choices-test.json

@@ -1,12 +1,11 @@
 {
-  "id": "responses:output2choices-test",
-  "protocol": "openai-responses",
-  "response": {
-    "mappings": [
-      {
-        "action": "convert_responses_output_to_choices"
-      }
-    ]
-  }
+    "id": "responses:output2choices-test",
+    "protocol": "openai-responses",
+    "response": {
+        "mappings": [
+            {
+                "action": "convert_responses_output_to_choices"
+            }
+        ]
+    }
 }
-

package/dist/conversion/hub/pipeline/hub-pipeline.d.ts

@@ -61,7 +61,6 @@ export declare class HubPipeline {
     private buildAdapterContext;
     private maybeCreateStageRecorder;
     private asJsonObject;
-    private pickRawRequestBody;
     private normalizeRequest;
     private convertProcessNodeResult;
     private materializePayload;

package/dist/conversion/hub/pipeline/hub-pipeline.js

@@ -1,4 +1,5 @@
 import { Readable } from 'node:stream';
+import { isJsonObject } from '../types/json.js';
 import { VirtualRouterEngine } from '../../../router/virtual-router/engine.js';
 import { providerErrorCenter } from '../../../router/virtual-router/error-center.js';
 import { defaultSseCodecRegistry } from '../../../sse/index.js';
@@ -22,6 +23,7 @@ import { runReqOutboundStage1SemanticMap } from './stages/req_outbound/req_outbo
 import { runReqOutboundStage2FormatBuild } from './stages/req_outbound/req_outbound_stage2_format_build/index.js';
 import { runReqOutboundStage3Compat } from './stages/req_outbound/req_outbound_stage3_compat/index.js';
 import { extractSessionIdentifiersFromMetadata } from './session-identifiers.js';
+import { computeRequestTokens } from '../../../router/virtual-router/token-estimator.js';
 export class HubPipeline {
     routerEngine;
     config;
@@ -119,6 +121,18 @@ export class HubPipeline {
             }
         }
         const workingRequest = processedRequest ?? standardizedRequest;
+        // 使用与 VirtualRouter 一致的 tiktoken 计数逻辑，对标准化请求进行一次
+        // 上下文 token 估算，供后续 usage 归一化与统计使用。
+        try {
+            const estimatedTokens = computeRequestTokens(workingRequest, '');
+            if (typeof estimatedTokens === 'number' && Number.isFinite(estimatedTokens) && estimatedTokens > 0) {
+                normalized.metadata = normalized.metadata || {};
+                normalized.metadata.estimatedInputTokens = estimatedTokens;
+            }
+        }
+        catch {
+            // 估算失败不应影响主流程
+        }
         const normalizedMeta = normalized.metadata;
         const responsesResume = normalizedMeta && typeof normalizedMeta.responsesResume === 'object'
             ? normalizedMeta.responsesResume
@@ -182,66 +196,42 @@ export class HubPipeline {
         const outboundEndpoint = resolveEndpointForProviderProtocol(outboundAdapterContext.providerProtocol);
         const outboundRecorder = this.maybeCreateStageRecorder(outboundAdapterContext, outboundEndpoint);
         const outboundStart = Date.now();
-        const isResponsesSubmit = normalized.entryEndpoint === '/v1/responses.submit_tool_outputs' &&
-            outboundProtocol === 'openai-responses';
         let providerPayload;
-        if (isResponsesSubmit) {
-            providerPayload =
-                this.pickRawRequestBody(normalized.metadata) ?? normalized.payload;
-            const outboundEnd = Date.now();
-            nodeResults.push({
-                id: 'req_outbound',
-                success: true,
-                metadata: {
-                    node: 'req_outbound',
-                    executionTime: outboundEnd - outboundStart,
-                    startTime: outboundStart,
-                    endTime: outboundEnd,
-                    dataProcessed: {
-                        messages: 0,
-                        tools: 0
-                    },
-                    bypass: 'responses-submit-passthrough'
-                }
-            });
-        }
-        else {
-            const outboundStage1 = await runReqOutboundStage1SemanticMap({
-                request: workingRequest,
-                adapterContext: outboundAdapterContext,
-                semanticMapper: outboundSemanticMapper,
-                contextSnapshot: outboundContextSnapshot,
-                contextMetadataKey: outboundContextMetadataKey,
-                stageRecorder: outboundRecorder
-            });
-            let formattedPayload = await runReqOutboundStage2FormatBuild({
-                formatEnvelope: outboundStage1.formatEnvelope,
-                adapterContext: outboundAdapterContext,
-                formatAdapter: outboundFormatAdapter,
-                stageRecorder: outboundRecorder
-            });
-            formattedPayload = await runReqOutboundStage3Compat({
-                payload: formattedPayload,
-                adapterContext: outboundAdapterContext,
-                stageRecorder: outboundRecorder
-            });
-            providerPayload = formattedPayload;
-            const outboundEnd = Date.now();
-            nodeResults.push({
-                id: 'req_outbound',
-                success: true,
-                metadata: {
-                    node: 'req_outbound',
-                    executionTime: outboundEnd - outboundStart,
-                    startTime: outboundStart,
-                    endTime: outboundEnd,
-                    dataProcessed: {
-                        messages: workingRequest.messages.length,
-                        tools: workingRequest.tools?.length ?? 0
-                    }
+        const outboundStage1 = await runReqOutboundStage1SemanticMap({
+            request: workingRequest,
+            adapterContext: outboundAdapterContext,
+            semanticMapper: outboundSemanticMapper,
+            contextSnapshot: outboundContextSnapshot,
+            contextMetadataKey: outboundContextMetadataKey,
+            stageRecorder: outboundRecorder
+        });
+        let formattedPayload = await runReqOutboundStage2FormatBuild({
+            formatEnvelope: outboundStage1.formatEnvelope,
+            adapterContext: outboundAdapterContext,
+            formatAdapter: outboundFormatAdapter,
+            stageRecorder: outboundRecorder
+        });
+        formattedPayload = await runReqOutboundStage3Compat({
+            payload: formattedPayload,
+            adapterContext: outboundAdapterContext,
+            stageRecorder: outboundRecorder
+        });
+        providerPayload = formattedPayload;
+        const outboundEnd = Date.now();
+        nodeResults.push({
+            id: 'req_outbound',
+            success: true,
+            metadata: {
+                node: 'req_outbound',
+                executionTime: outboundEnd - outboundStart,
+                startTime: outboundStart,
+                endTime: outboundEnd,
+                dataProcessed: {
+                    messages: workingRequest.messages.length,
+                    tools: workingRequest.tools?.length ?? 0
                 }
-            });
-        }
+            }
+        });
         // 为响应侧 servertool/web_search 提供一次性 Chat 请求快照，便于在 Hub 内部实现
         // 第三跳（将工具结果注入消息历史后重新调用主模型）。
         //
@@ -322,7 +312,11 @@ export class HubPipeline {
         const contextNode = metadataNode && metadataNode.context && typeof metadataNode.context === 'object'
             ? metadataNode.context
             : undefined;
-        return coerceAliasMap(contextNode?.anthropicToolNameMap);
+        const fromContextNode = coerceAliasMap(contextNode?.anthropicToolNameMap);
+        if (fromContextNode) {
+            return fromContextNode;
+        }
+        return readAliasMapFromSemantics(chatEnvelope);
     }
     resolveProtocolHooks(protocol) {
         switch (protocol) {
@@ -409,6 +403,11 @@ export class HubPipeline {
         if (responsesResume) {
             adapterContext.responsesResume = responsesResume;
         }
+        // 透传 gemini_empty_reply_continue 的重试计数，便于在多次空回复后终止自动续写。
+        const emptyReplyCount = metadata.geminiEmptyReplyCount;
+        if (typeof emptyReplyCount === 'number' && Number.isFinite(emptyReplyCount)) {
+            adapterContext.geminiEmptyReplyCount = emptyReplyCount;
+        }
         if (target?.compatibilityProfile && typeof target.compatibilityProfile === 'string') {
             adapterContext.compatibilityProfile = target.compatibilityProfile;
         }
@@ -432,16 +431,6 @@ export class HubPipeline {
         }
         return value;
     }
-    pickRawRequestBody(metadata) {
-        if (!metadata || typeof metadata !== 'object') {
-            return undefined;
-        }
-        const raw = metadata.__raw_request_body;
-        if (!raw || typeof raw !== 'object') {
-            return undefined;
-        }
-        return raw;
-    }
     async normalizeRequest(request) {
         if (!request || typeof request !== 'object') {
             throw new Error('HubPipeline requires request payload');
@@ -695,3 +684,13 @@ function coerceAliasMap(candidate) {
     }
     return Object.keys(normalized).length ? normalized : undefined;
 }
+function readAliasMapFromSemantics(chatEnvelope) {
+    if (!chatEnvelope?.semantics || typeof chatEnvelope.semantics !== 'object') {
+        return undefined;
+    }
+    const node = chatEnvelope.semantics.anthropic;
+    if (!node || !isJsonObject(node)) {
+        return undefined;
+    }
+    return coerceAliasMap(node.toolAliasMap);
+}

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js

@@ -15,7 +15,6 @@ export function runRespOutboundStage1ClientRemap(options) {
         clientPayload = buildResponsesPayloadFromChat(options.payload, {
             requestId: options.requestId
         });
-        mergeOriginalResponsesPayload(clientPayload, options.adapterContext);
     }
     recordStage(options.stageRecorder, 'resp_outbound_stage1_client_remap', clientPayload);
     return clientPayload;
@@ -42,36 +41,3 @@ function resolveAliasMapFromContext(adapterContext) {
     }
     return Object.keys(map).length ? map : undefined;
 }
-function mergeOriginalResponsesPayload(payload, adapterContext) {
-    if (!adapterContext) {
-        return;
-    }
-    const raw = adapterContext.__raw_responses_payload;
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        return;
-    }
-    try {
-        if (payload.required_action == null && raw.required_action != null) {
-            payload.required_action = JSON.parse(JSON.stringify(raw.required_action));
-        }
-    }
-    catch {
-        /* ignore clone errors */
-    }
-    const rawStatus = typeof raw.status === 'string' ? raw.status : undefined;
-    if (rawStatus === 'requires_action') {
-        payload.status = 'requires_action';
-    }
-    // 如果桥接后的 payload 没有 usage，而原始 Responses 载荷带有 usage，则回填原始 usage，
-    // 确保 token usage 不在工具/桥接路径中丢失。
-    const payloadUsage = payload.usage;
-    const rawUsage = raw.usage;
-    if ((payloadUsage == null || typeof payloadUsage !== 'object') && rawUsage && typeof rawUsage === 'object') {
-        try {
-            payload.usage = JSON.parse(JSON.stringify(rawUsage));
-        }
-        catch {
-            payload.usage = rawUsage;
-        }
-    }
-}

package/dist/conversion/hub/process/chat-process.js

@@ -1,7 +1,7 @@
 import { runChatRequestToolFilters } from '../../shared/tool-filter-pipeline.js';
 import { ToolGovernanceEngine } from '../tool-governance/index.js';
-import { detectLastAssistantToolCategory } from '../../../router/virtual-router/tool-signals.js';
 import { ensureApplyPatchSchema } from '../../shared/tool-mapping.js';
+import { isJsonObject } from '../types/json.js';
 const toolGovernanceEngine = new ToolGovernanceEngine();
 export async function runHubChatProcess(options) {
     const startTime = Date.now();
@@ -404,24 +404,21 @@ function maybeInjectWebSearchTool(request, metadata) {
     if (!rawConfig || !Array.isArray(rawConfig.engines) || rawConfig.engines.length === 0) {
         return request;
     }
-    const injectPolicy = rawConfig.injectPolicy === 'always' || rawConfig.injectPolicy === 'selective'
-        ? rawConfig.injectPolicy
-        : 'selective';
+    const semanticsWebSearch = extractWebSearchSemantics(request.semantics);
+    if (semanticsWebSearch?.disable === true) {
+        return request;
+    }
+    const injectPolicy = semanticsWebSearch?.force === true
+        ? 'always'
+        : rawConfig.injectPolicy === 'always' || rawConfig.injectPolicy === 'selective'
+            ? rawConfig.injectPolicy
+            : 'selective';
     const intent = detectWebSearchIntent(request);
     if (injectPolicy === 'selective') {
+        // 仅当当前这一轮用户输入明确表达“联网搜索”意图时才注入 web_search。
+        // 不再依赖上一轮工具分类（read/search/websearch），避免形成隐式续写语义。
         if (!intent.hasIntent) {
-            // 当最近一条用户消息没有明显的“联网搜索”关键词时，
-            // 如果上一轮 assistant 的工具调用已经属于搜索类（如 web_search），
-            // 则仍然视为 web_search 续写场景，强制注入 web_search 工具，
-            // 以便在后续路由中按 servertool 逻辑跳过不适配的 Provider（例如 serverToolsDisabled 的 crs）。
-            const assistantMessages = Array.isArray(request.messages)
-                ? request.messages.filter((msg) => msg && msg.role === 'assistant')
-                : [];
-            const lastTool = detectLastAssistantToolCategory(assistantMessages);
-            const hasSearchToolContext = lastTool?.category === 'search';
-            if (!hasSearchToolContext) {
-                return request;
-            }
+            return request;
         }
     }
     const existingTools = Array.isArray(request.tools) ? request.tools : [];
@@ -522,6 +519,30 @@ function maybeInjectWebSearchTool(request, metadata) {
         tools: [...existingTools, webSearchTool]
     };
 }
+function extractWebSearchSemantics(semantics) {
+    if (!semantics || typeof semantics !== 'object') {
+        return undefined;
+    }
+    const extras = semantics.providerExtras;
+    if (!extras || !isJsonObject(extras)) {
+        return undefined;
+    }
+    const hint = extras.webSearch;
+    if (typeof hint === 'boolean') {
+        return hint ? { force: true } : { disable: true };
+    }
+    if (isJsonObject(hint)) {
+        const normalized = {};
+        if (hint.force === true) {
+            normalized.force = true;
+        }
+        if (hint.disable === true) {
+            normalized.disable = true;
+        }
+        return Object.keys(normalized).length ? normalized : undefined;
+    }
+    return undefined;
+}
 function detectWebSearchIntent(request) {
     const messages = Array.isArray(request.messages) ? request.messages : [];
     if (!messages.length) {

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

@@ -130,14 +130,6 @@ export async function convertProviderResponse(options) {
         catch {
             // ignore conversation capture errors
         }
-        if (formatEnvelope.payload && typeof formatEnvelope.payload === 'object') {
-            try {
-                options.context.__raw_responses_payload = JSON.parse(JSON.stringify(formatEnvelope.payload));
-            }
-            catch {
-                /* best-effort clone */
-            }
-        }
     }
     formatEnvelope.payload = runRespInboundStageCompatResponse({
         payload: formatEnvelope.payload,

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

@@ -21,6 +21,15 @@ function flattenAnthropicContent(content) {
     }
     return '';
 }
+function sanitizeAnthropicToolUseId(raw) {
+    if (typeof raw === 'string') {
+        const trimmed = raw.trim();
+        if (trimmed && /^[A-Za-z0-9_-]+$/.test(trimmed)) {
+            return trimmed;
+        }
+    }
+    return `call_${Math.random().toString(36).slice(2, 10)}`;
+}
 function createToolNameResolver(options) {
     const reverse = new Map();
     const aliasMap = options?.aliasMap;
@@ -281,6 +290,39 @@ export function buildOpenAIChatFromAnthropicMessage(payload, options) {
     }
     return chatResponse;
 }
+function mapShellCommandArgsForAnthropic(raw) {
+    const result = {};
+    const source = (raw && typeof raw === 'object' && !Array.isArray(raw)) ? raw : {};
+    const commandRaw = typeof source.command === 'string' && source.command.trim().length
+        ? source.command
+        : typeof source.cmd === 'string' && source.cmd.trim().length
+            ? source.cmd
+            : '';
+    const command = commandRaw.trim();
+    if (command) {
+        result.command = command;
+    }
+    const timeoutRaw = source.timeout_ms ?? source.timeout;
+    if (typeof timeoutRaw === 'number' && Number.isFinite(timeoutRaw)) {
+        result.timeout = timeoutRaw;
+    }
+    else if (typeof timeoutRaw === 'string' && timeoutRaw.trim().length) {
+        const parsed = Number(timeoutRaw.trim());
+        if (Number.isFinite(parsed)) {
+            result.timeout = parsed;
+        }
+    }
+    if (typeof source.description === 'string' && source.description.trim().length) {
+        result.description = source.description;
+    }
+    if (typeof source.run_in_background === 'boolean') {
+        result.run_in_background = source.run_in_background;
+    }
+    if (typeof source.dangerouslyDisableSandbox === 'boolean') {
+        result.dangerouslyDisableSandbox = source.dangerouslyDisableSandbox;
+    }
+    return result;
+}
 export function buildAnthropicResponseFromChat(chatResponse, options) {
     const choice = Array.isArray(chatResponse?.choices) ? chatResponse.choices[0] : undefined;
     const message = choice && typeof choice === 'object' ? choice.message : undefined;
@@ -327,6 +369,7 @@ export function buildAnthropicResponseFromChat(chatResponse, options) {
         const fn = call.function || {};
         if (typeof fn?.name !== 'string')
             continue;
+        const canonicalName = normalizeAnthropicToolName(fn.name) ?? fn.name;
         const serializedName = outboundAliasSerializer(fn.name);
         let parsedArgs = {};
         const args = fn.arguments;
@@ -341,9 +384,12 @@ export function buildAnthropicResponseFromChat(chatResponse, options) {
         else {
             parsedArgs = args ?? {};
         }
+        if ((canonicalName || '').trim() === 'shell_command') {
+            parsedArgs = mapShellCommandArgsForAnthropic(parsedArgs);
+        }
         contentBlocks.push({
             type: 'tool_use',
-            id: typeof call.id === 'string' ? call.id : `call_${Math.random().toString(36).slice(2, 8)}`,
+            id: sanitizeAnthropicToolUseId(call.id),
             name: serializedName,
             input: parsedArgs
         });

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

@@ -34,6 +34,43 @@ const ANTHROPIC_TOP_LEVEL_FIELDS = new Set([
 ]);
 const PASSTHROUGH_METADATA_PREFIX = 'rcc_passthrough_';
 const PASSTHROUGH_PARAMETERS = ['tool_choice'];
+function ensureSemantics(chat) {
+    if (!chat.semantics || typeof chat.semantics !== 'object') {
+        chat.semantics = {};
+    }
+    return chat.semantics;
+}
+function ensureAnthropicSemanticsNode(chat) {
+    const semantics = ensureSemantics(chat);
+    if (!semantics.anthropic || !isJsonObject(semantics.anthropic)) {
+        semantics.anthropic = {};
+    }
+    return semantics.anthropic;
+}
+function markExplicitEmptyTools(chat) {
+    const semantics = ensureSemantics(chat);
+    if (!semantics.tools || !isJsonObject(semantics.tools)) {
+        semantics.tools = {};
+    }
+    semantics.tools.explicitEmpty = true;
+}
+function readAnthropicSemantics(chat) {
+    if (!chat.semantics || typeof chat.semantics !== 'object') {
+        return undefined;
+    }
+    const node = chat.semantics.anthropic;
+    return node && isJsonObject(node) ? node : undefined;
+}
+function hasExplicitEmptyToolsSemantics(chat) {
+    if (!chat.semantics || typeof chat.semantics !== 'object') {
+        return false;
+    }
+    const toolsNode = chat.semantics.tools;
+    if (!toolsNode || !isJsonObject(toolsNode)) {
+        return false;
+    }
+    return Boolean(toolsNode.explicitEmpty);
+}
 function sanitizeAnthropicPayload(payload) {
     for (const key of Object.keys(payload)) {
         if (!ANTHROPIC_TOP_LEVEL_FIELDS.has(key)) {
@@ -91,6 +128,7 @@ export class AnthropicSemanticMapper {
         const metadata = chatEnvelope.metadata ?? { context: canonicalContext };
         chatEnvelope.metadata = metadata;
         metadata.context = canonicalContext;
+        let semanticsNode;
         const resolveExtraFields = () => {
             if (!isJsonObject(metadata.extraFields)) {
                 metadata.extraFields = {};
@@ -101,10 +139,13 @@ export class AnthropicSemanticMapper {
         const systemBlocks = cloneAnthropicSystemBlocks(payload.system);
         if (systemBlocks) {
             protocolState.systemBlocks = systemBlocks;
+            semanticsNode = semanticsNode ?? ensureAnthropicSemanticsNode(chatEnvelope);
+            semanticsNode.systemBlocks = jsonClone(systemBlocks);
         }
         if (payload.tools && Array.isArray(payload.tools) && payload.tools.length === 0) {
             metadata.toolsFieldPresent = true;
             resolveExtraFields().toolsFieldPresent = true;
+            markExplicitEmptyTools(chatEnvelope);
         }
         const aliasMap = buildAnthropicToolAliasMap(payload.tools);
         if (aliasMap) {
@@ -113,6 +154,8 @@ export class AnthropicSemanticMapper {
             canonicalContext.anthropicToolNameMap = aliasMap;
             metadata.anthropicToolNameMap = aliasMap;
             extraFields.anthropicToolNameMap = aliasMap;
+            semanticsNode = semanticsNode ?? ensureAnthropicSemanticsNode(chatEnvelope);
+            semanticsNode.toolAliasMap = jsonClone(aliasMap);
         }
         if (Array.isArray(payload.messages) && payload.messages.length) {
             const shapes = payload.messages.map((entry) => {
@@ -137,6 +180,8 @@ export class AnthropicSemanticMapper {
                 : {};
             mirrorNode.messageContentShape = shapes;
             extraFields.anthropicMirror = mirrorNode;
+            semanticsNode = semanticsNode ?? ensureAnthropicSemanticsNode(chatEnvelope);
+            semanticsNode.mirror = jsonClone(mirrorNode);
         }
         if (missing.length) {
             metadata.missingFields = Array.isArray(metadata.missingFields)
@@ -147,6 +192,8 @@ export class AnthropicSemanticMapper {
             (payload.metadata && isJsonObject(payload.metadata) ? jsonClone(payload.metadata) : undefined);
         if (providerMetadata) {
             metadata.providerMetadata = providerMetadata;
+            semanticsNode = semanticsNode ?? ensureAnthropicSemanticsNode(chatEnvelope);
+            semanticsNode.providerMetadata = jsonClone(providerMetadata);
         }
         const mergedParameters = { ...(chatEnvelope.parameters ?? {}) };
         const mergeParameters = (source) => {
@@ -217,6 +264,8 @@ export class AnthropicSemanticMapper {
             messages: chat.messages,
             tools: chat.tools
         };
+        const semanticsNode = readAnthropicSemantics(chat);
+        const explicitEmptyTools = (chat.metadata?.toolsFieldPresent === true) || hasExplicitEmptyToolsSemantics(chat);
         const trimmedParameters = chat.parameters && typeof chat.parameters === 'object' ? chat.parameters : undefined;
         if (trimmedParameters) {
             for (const [key, value] of Object.entries(trimmedParameters)) {
@@ -245,16 +294,19 @@ export class AnthropicSemanticMapper {
         if (baseRequest.max_output_tokens && !baseRequest.max_tokens) {
             baseRequest.max_tokens = baseRequest.max_output_tokens;
         }
-        if (isJsonObject(chat.metadata?.providerMetadata)) {
-            baseRequest.metadata = jsonClone(chat.metadata?.providerMetadata);
-        }
-        if (chat.metadata?.toolsFieldPresent && (!Array.isArray(chat.tools) || chat.tools.length === 0)) {
+        // 出站阶段不再直接透传其它协议的 providerMetadata，避免跨协议打洞；
+        // Anthropic 自身入口的 metadata 已在入站阶段通过 collectParameters/encodeMetadataPassthrough
+        // 按白名单收集，这里仅依赖这些显式映射结果。
+        if (explicitEmptyTools && (!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);
         }
+        else if (semanticsNode?.systemBlocks !== undefined) {
+            baseRequest.system = jsonClone(semanticsNode.systemBlocks);
+        }
         if (chat.metadata &&
             typeof chat.metadata === 'object' &&
             chat.metadata.extraFields &&
@@ -262,6 +314,9 @@ export class AnthropicSemanticMapper {
             chat.metadata.extraFields.anthropicMirror) {
             baseRequest.__anthropicMirror = jsonClone(chat.metadata.extraFields.anthropicMirror ?? {});
         }
+        else if (semanticsNode?.mirror && isJsonObject(semanticsNode.mirror)) {
+            baseRequest.__anthropicMirror = jsonClone(semanticsNode.mirror);
+        }
         const payloadSource = buildAnthropicRequestFromOpenAIChat(baseRequest);
         const payload = sanitizeAnthropicPayload(JSON.parse(JSON.stringify(payloadSource)));
         if (chat.metadata?.toolsFieldPresent && (!Array.isArray(chat.tools) || chat.tools.length === 0)) {

package/dist/conversion/hub/semantic-mappers/chat-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 function maybeAugmentApplyPatchErrorContent(content: string, toolName?: string): string;
+export declare class ChatSemanticMapper implements SemanticMapper {
+    toChat(format: FormatEnvelope, ctx: AdapterContext): Promise<ChatEnvelope>;
+    fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope>;
+}