@jsonstudio/llms 0.6.954 → 0.6.1164

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

@@ -15,6 +15,7 @@ import { runRespOutboundStage1ClientRemap } from '../pipeline/stages/resp_outbou
 import { runRespOutboundStage2SseStream } from '../pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.js';
 import { recordResponsesResponse } from '../../shared/responses-conversation-store.js';
 import { runServerToolOrchestration } from '../../../servertool/engine.js';
+import { commitClockReservation, normalizeClockConfig } from '../../../servertool/clock/task-store.js';
 const PROVIDER_RESPONSE_REGISTRY = {
     'openai-chat': {
         createFormatAdapter: () => new ChatFormatAdapter(),
@@ -52,6 +53,123 @@ function resolveClientProtocol(entryEndpoint) {
         return 'anthropic-messages';
     return 'openai-chat';
 }
+function isToolSurfaceShadowEnabled() {
+    const raw = String(process.env.ROUTECODEX_HUB_TOOL_SURFACE_MODE || '').trim().toLowerCase();
+    if (!raw)
+        return false;
+    if (raw === 'off' || raw === '0' || raw === 'false')
+        return false;
+    return raw === 'observe' || raw === 'shadow' || raw === 'enforce';
+}
+function isJsonRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function coerceClockReservation(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const rec = value;
+    const reservationId = typeof rec.reservationId === 'string' ? rec.reservationId.trim() : '';
+    const sessionId = typeof rec.sessionId === 'string' ? rec.sessionId.trim() : '';
+    const taskIdsRaw = Array.isArray(rec.taskIds) ? rec.taskIds : [];
+    const taskIds = taskIdsRaw
+        .filter((t) => typeof t === 'string' && t.trim().length)
+        .map((t) => String(t).trim());
+    const reservedAtMs = typeof rec.reservedAtMs === 'number' && Number.isFinite(rec.reservedAtMs)
+        ? Math.floor(rec.reservedAtMs)
+        : Date.now();
+    if (!reservationId || !sessionId || taskIds.length === 0) {
+        return null;
+    }
+    return { reservationId, sessionId, taskIds, reservedAtMs };
+}
+async function maybeCommitClockReservationFromContext(context) {
+    try {
+        const clockConfig = normalizeClockConfig(context.clock);
+        if (!clockConfig) {
+            return;
+        }
+        const reservation = coerceClockReservation(context.__clockReservation);
+        if (!reservation) {
+            return;
+        }
+        await commitClockReservation(reservation, clockConfig);
+    }
+    catch {
+        // best-effort: never break response conversion due to clock persistence errors
+    }
+}
+function detectProviderResponseShape(payload) {
+    if (!isJsonRecord(payload))
+        return 'unknown';
+    const obj = payload;
+    if (Array.isArray(obj.choices))
+        return 'openai-chat';
+    if (Array.isArray(obj.output) || obj.object === 'response')
+        return 'openai-responses';
+    if (typeof obj.type === 'string' && String(obj.type).toLowerCase() === 'message' && Array.isArray(obj.content)) {
+        return 'anthropic-messages';
+    }
+    if (Array.isArray(obj.candidates))
+        return 'gemini-chat';
+    return 'unknown';
+}
+function summarizeToolCallsFromProviderResponse(payload) {
+    try {
+        if (!isJsonRecord(payload))
+            return {};
+        const obj = payload;
+        // openai-chat
+        if (Array.isArray(obj.choices)) {
+            const msg = obj.choices?.[0]?.message;
+            const tcs = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
+            const names = tcs
+                .map((tc) => String(tc?.function?.name || '').trim())
+                .filter((s) => s.length)
+                .slice(0, 10);
+            return { toolCallCount: tcs.length, toolNames: names.length ? names : undefined };
+        }
+        // openai-responses
+        if (Array.isArray(obj.output)) {
+            const out = obj.output;
+            const fnCalls = out.filter((it) => it && typeof it === 'object' && String(it.type || '').toLowerCase() === 'function_call');
+            const names = fnCalls
+                .map((it) => String(it?.name || '').trim())
+                .filter((s) => s.length)
+                .slice(0, 10);
+            return { toolCallCount: fnCalls.length, toolNames: names.length ? names : undefined };
+        }
+        // anthropic-messages
+        if (Array.isArray(obj.content)) {
+            const blocks = obj.content;
+            const uses = blocks.filter((b) => b && typeof b === 'object' && String(b.type || '').toLowerCase() === 'tool_use');
+            const names = uses
+                .map((b) => String(b?.name || '').trim())
+                .filter((s) => s.length)
+                .slice(0, 10);
+            return { toolCallCount: uses.length, toolNames: names.length ? names : undefined };
+        }
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
+function stripInternalPolicyDebugFields(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return;
+    }
+    const target = payload;
+    // These are internal debug/transport markers that must not leak across hub boundaries.
+    // They also break hub policy allowlists (Phase 0/1 observation) and confuse tool-surface detection.
+    delete target._transformed;
+    delete target._originalFormat;
+    delete target._targetFormat;
+    delete target.__responses_output_text_meta;
+    delete target.__responses_reasoning;
+    delete target.__responses_payload_snapshot;
+    delete target.__responses_passthrough;
+}
 function supportsSseProtocol(protocol) {
     return protocol === 'openai-chat' || protocol === 'openai-responses' || protocol === 'anthropic-messages' || protocol === 'gemini-chat';
 }
@@ -68,6 +186,16 @@ function extractDisplayModel(context) {
     }
     return undefined;
 }
+function extractClientFacingRequestId(context) {
+    const contextAny = context;
+    const candidates = [contextAny.clientRequestId, contextAny.groupRequestId, context.requestId];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'string' && candidate.trim()) {
+            return candidate.trim();
+        }
+    }
+    return undefined;
+}
 function applyModelOverride(payload, model) {
     if (!model || !payload || typeof payload !== 'object') {
         return;
@@ -107,6 +235,7 @@ export async function convertProviderResponse(options) {
         /* logging best-effort */
     }
     const displayModel = extractDisplayModel(options.context);
+    const clientFacingRequestId = extractClientFacingRequestId(options.context) ?? options.context.requestId;
     const plan = PROVIDER_RESPONSE_REGISTRY[options.providerProtocol];
     if (!plan) {
         throw new Error(`Unknown provider protocol: ${options.providerProtocol}`);
@@ -142,6 +271,27 @@ export async function convertProviderResponse(options) {
         adapterContext: options.context,
         stageRecorder: options.stageRecorder
     });
+    stripInternalPolicyDebugFields(formatEnvelope.payload);
+    // Phase 2 (shadow): response tool surface mismatch detection (provider inbound).
+    // Only records diffs; does not rewrite payload.
+    try {
+        if (options.stageRecorder && isToolSurfaceShadowEnabled()) {
+            const detected = detectProviderResponseShape(formatEnvelope.payload);
+            if (detected !== 'unknown' && detected !== options.providerProtocol) {
+                const summary = summarizeToolCallsFromProviderResponse(formatEnvelope.payload);
+                options.stageRecorder.record('hub_toolsurface.shadow.provider_inbound', {
+                    kind: 'provider_inbound',
+                    expectedProtocol: options.providerProtocol,
+                    detectedProtocol: detected,
+                    ...(summary.toolCallCount !== undefined ? { toolCallCount: summary.toolCallCount } : {}),
+                    ...(summary.toolNames ? { toolNames: summary.toolNames } : {})
+                });
+            }
+        }
+    }
+    catch {
+        // never break response conversion
+    }
     // Phase 0/1: observe provider inbound payload violations (best-effort; no rewrites here).
     try {
         if (formatEnvelope.payload && typeof formatEnvelope.payload === 'object' && !Array.isArray(formatEnvelope.payload)) {
@@ -183,6 +333,7 @@ export async function convertProviderResponse(options) {
             requestId: options.context.requestId,
             entryEndpoint: options.entryEndpoint,
             providerProtocol: options.providerProtocol,
+            stageRecorder: options.stageRecorder,
             providerInvoker: options.providerInvoker,
             reenterPipeline: options.reenterPipeline
         });
@@ -229,11 +380,31 @@ export async function convertProviderResponse(options) {
     const clientPayload = runRespOutboundStage1ClientRemap({
         payload: finalizeResult.finalizedPayload,
         clientProtocol,
-        requestId: options.context.requestId,
+        requestId: clientFacingRequestId,
         adapterContext: options.context,
         stageRecorder: options.stageRecorder
     });
     applyModelOverride(clientPayload, displayModel);
+    stripInternalPolicyDebugFields(clientPayload);
+    // Phase 2 (shadow): response tool surface mismatch detection (client outbound).
+    try {
+        if (options.stageRecorder && isToolSurfaceShadowEnabled()) {
+            const detected = detectProviderResponseShape(clientPayload);
+            if (detected !== 'unknown' && detected !== clientProtocol) {
+                const summary = summarizeToolCallsFromProviderResponse(clientPayload);
+                options.stageRecorder.record('hub_toolsurface.shadow.client_outbound', {
+                    kind: 'client_outbound',
+                    expectedProtocol: clientProtocol,
+                    detectedProtocol: detected,
+                    ...(summary.toolCallCount !== undefined ? { toolCallCount: summary.toolCallCount } : {}),
+                    ...(summary.toolNames ? { toolNames: summary.toolNames } : {})
+                });
+            }
+        }
+    }
+    catch {
+        // never break response conversion
+    }
     // Phase 0/1: observe client outbound payload violations (best-effort; no rewrites here).
     try {
         if (clientPayload && typeof clientPayload === 'object' && !Array.isArray(clientPayload)) {
@@ -252,10 +423,12 @@ export async function convertProviderResponse(options) {
     const outbound = await runRespOutboundStage2SseStream({
         clientPayload,
         clientProtocol,
-        requestId: options.context.requestId,
+        requestId: clientFacingRequestId,
         wantsStream,
         stageRecorder: options.stageRecorder
     });
+    // Commit scheduled-task delivery only after a successful client payload/stream is prepared.
+    await maybeCommitClockReservationFromContext(options.context);
     if (outbound.stream) {
         return { __sse_responses: outbound.stream, format: clientProtocol };
     }

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

@@ -189,7 +189,7 @@ export function buildOpenAIChatFromAnthropicMessage(payload, options) {
         switch (reason) {
             case 'tool_use': return 'tool_calls';
             case 'max_tokens': return 'length';
-            case 'stop_sequence': return 'content_filter';
+            case 'stop_sequence': return 'stop';
             default: return 'stop';
         }
     };

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

@@ -1,8 +1 @@
-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>;
-}
+export { AnthropicSemanticMapper } from '../operation-table/semantic-mappers/anthropic-mapper.js';

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

@@ -1,365 +1 @@
-import { isJsonObject, jsonClone } from '../types/json.js';
-import { buildOpenAIChatFromAnthropic, buildAnthropicRequestFromOpenAIChat } from '../../codecs/anthropic-openai-codec.js';
-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 { 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',
-    'top_p',
-    'top_k',
-    'max_tokens',
-    'max_output_tokens',
-    'metadata',
-    'stream',
-    'tool_choice'
-];
-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'
-]);
-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)) {
-            delete payload[key];
-        }
-    }
-    return payload;
-}
-function collectParameters(payload) {
-    const params = {};
-    for (const key of ANTHROPIC_PARAMETER_KEYS) {
-        if (payload[key] !== undefined) {
-            params[key] = payload[key];
-        }
-    }
-    if (Array.isArray(payload.stop_sequences)) {
-        params.stop = payload.stop_sequences;
-    }
-    return Object.keys(params).length ? params : undefined;
-}
-function cloneAnthropicSystemBlocks(value) {
-    if (value === undefined || value === null) {
-        return undefined;
-    }
-    const blocks = Array.isArray(value) ? value : [value];
-    if (!blocks.length) {
-        return undefined;
-    }
-    return blocks.map((entry) => jsonClone(entry));
-}
-export class AnthropicSemanticMapper {
-    chatMapper = new ChatSemanticMapper();
-    async toChat(format, ctx) {
-        const payload = (format.payload ?? {});
-        const missing = [];
-        if (!Array.isArray(payload.messages))
-            missing.push({ path: 'messages', reason: 'absent' });
-        if (typeof payload.model !== 'string')
-            missing.push({ path: 'model', reason: 'absent' });
-        const passthrough = extractMetadataPassthrough(payload.metadata, {
-            prefix: PASSTHROUGH_METADATA_PREFIX,
-            keys: PASSTHROUGH_PARAMETERS
-        });
-        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;
-        let semanticsNode;
-        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;
-            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) {
-            const extraFields = resolveExtraFields();
-            ctx.anthropicToolNameMap = aliasMap;
-            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) => {
-                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;
-            semanticsNode = semanticsNode ?? ensureAnthropicSemanticsNode(chatEnvelope);
-            semanticsNode.mirror = jsonClone(mirrorNode);
-        }
-        if (missing.length) {
-            metadata.missingFields = Array.isArray(metadata.missingFields)
-                ? [...metadata.missingFields, ...missing]
-                : missing;
-        }
-        const providerMetadata = passthrough.metadata ??
-            (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) => {
-            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: chatEnvelope.messages,
-                    rawRequest: payload,
-                    metadata: metadata
-                });
-                runBridgeActionPipeline({
-                    stage: 'request_inbound',
-                    actions,
-                    protocol: bridgePolicy?.protocol ?? 'anthropic-messages',
-                    moduleType: bridgePolicy?.moduleType ?? 'anthropic-messages',
-                    requestId: ctx.requestId,
-                    state: actionState
-                });
-            }
-        }
-        catch {
-            // best-effort metadata extraction
-        }
-        return chatEnvelope;
-    }
-    async fromChat(chat, ctx) {
-        // Ensure tool_use / tool_result ordering and per-session history for /v1/messages style entrypoints.
-        try {
-            const { applyToolSessionCompat } = await import('../tool-session-compat.js');
-            await applyToolSessionCompat(chat, ctx);
-        }
-        catch {
-            // best-effort compat; do not block outbound mapping
-        }
-        const model = chat.parameters?.model;
-        if (typeof model !== 'string' || !model.trim()) {
-            throw new Error('ChatEnvelope.parameters.model is required for anthropic-messages outbound conversion');
-        }
-        const baseRequest = {
-            model,
-            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)) {
-                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
-        });
-        if (passthroughMetadata) {
-            const rawMetadata = baseRequest.metadata;
-            const existingMetadata = isJsonObject(rawMetadata)
-                ? jsonClone(rawMetadata)
-                : {};
-            for (const [key, value] of Object.entries(passthroughMetadata)) {
-                existingMetadata[key] = value;
-            }
-            baseRequest.metadata = existingMetadata;
-        }
-        if (baseRequest.max_output_tokens && !baseRequest.max_tokens) {
-            baseRequest.max_tokens = baseRequest.max_output_tokens;
-        }
-        // 出站阶段不再直接透传其它协议的 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 &&
-            typeof chat.metadata.extraFields === 'object' &&
-            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)) {
-            payload.tools = [];
-        }
-        try {
-            const bridgePolicy = resolveBridgePolicy({ protocol: 'anthropic-messages' });
-            const actions = resolvePolicyActions(bridgePolicy, 'request_outbound');
-            if (actions?.length) {
-                const capturedToolResults = Array.isArray(chat.toolOutputs)
-                    ? chat.toolOutputs.map((entry) => ({
-                        tool_call_id: entry.tool_call_id,
-                        output: entry.content,
-                        name: entry.name
-                    }))
-                    : undefined;
-                const actionState = createBridgeActionState({
-                    messages: Array.isArray(payload.messages) ? payload.messages : undefined,
-                    rawRequest: payload,
-                    metadata: chat.metadata,
-                    capturedToolResults
-                });
-                runBridgeActionPipeline({
-                    stage: 'request_outbound',
-                    actions,
-                    protocol: bridgePolicy?.protocol ?? 'anthropic-messages',
-                    moduleType: bridgePolicy?.moduleType ?? 'anthropic-messages',
-                    requestId: ctx.requestId,
-                    state: actionState
-                });
-            }
-        }
-        catch {
-            // ignore metadata propagation failures
-        }
-        sanitizeAnthropicPayload(payload);
-        return {
-            protocol: 'anthropic-messages',
-            direction: 'response',
-            payload,
-            meta: {
-                context: ctx
-            }
-        };
-    }
-}
+export { AnthropicSemanticMapper } from '../operation-table/semantic-mappers/anthropic-mapper.js';

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

@@ -1,8 +1 @@
-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>;
-}
+export { ChatSemanticMapper, maybeAugmentApplyPatchErrorContent } from '../operation-table/semantic-mappers/chat-mapper.js';