@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/conversion/hub/format-adapters/anthropic-format-adapter.js

@@ -0,0 +1,42 @@
+import { parseReqInboundFormatEnvelopeWithNative, parseRespInboundFormatEnvelopeWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
+import { normalizeReqInboundReasoningPayloadWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+import { normalizeRespInboundReasoningPayloadWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+export class AnthropicFormatAdapter {
+    protocol = 'anthropic-messages';
+    async parseRequest(original, _ctx) {
+        const parsed = parseReqInboundFormatEnvelopeWithNative({
+            rawRequest: original,
+            protocol: this.protocol
+        });
+        const payload = normalizeReqInboundReasoningPayloadWithNative({
+            payload: parsed.payload,
+            protocol: this.protocol
+        });
+        return {
+            protocol: this.protocol,
+            direction: 'request',
+            payload
+        };
+    }
+    async buildRequest(format, _ctx) {
+        return format.payload;
+    }
+    async parseResponse(original, _ctx) {
+        const parsed = parseRespInboundFormatEnvelopeWithNative({
+            payload: original,
+            protocol: this.protocol
+        });
+        const payload = normalizeRespInboundReasoningPayloadWithNative({
+            payload: parsed.payload,
+            protocol: this.protocol
+        });
+        return {
+            protocol: this.protocol,
+            direction: 'response',
+            payload
+        };
+    }
+    async buildResponse(format, _ctx) {
+        return format.payload;
+    }
+}

package/vendor/llmswitch-core/dist/conversion/hub/format-adapters/chat-format-adapter.d.ts

@@ -0,0 +1,17 @@
+import type { FormatAdapter } from './index.js';
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { JsonObject, JsonValue } from '../types/json.js';
+interface ChatFormatPayload extends JsonObject {
+    messages?: JsonValue[];
+    tools?: JsonValue[];
+    tool_outputs?: JsonValue[];
+}
+export declare class ChatFormatAdapter implements FormatAdapter {
+    readonly protocol = "openai-chat";
+    parseRequest(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<ChatFormatPayload>>;
+    buildRequest(format: FormatEnvelope<ChatFormatPayload>, _ctx: AdapterContext): Promise<ChatFormatPayload>;
+    parseResponse(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<ChatFormatPayload>>;
+    buildResponse(format: FormatEnvelope<ChatFormatPayload>, _ctx: AdapterContext): Promise<ChatFormatPayload>;
+}
+export {};

package/vendor/llmswitch-core/dist/conversion/hub/format-adapters/chat-format-adapter.js

@@ -0,0 +1,42 @@
+import { parseReqInboundFormatEnvelopeWithNative, parseRespInboundFormatEnvelopeWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
+import { normalizeReqInboundReasoningPayloadWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+import { normalizeRespInboundReasoningPayloadWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+export class ChatFormatAdapter {
+    protocol = 'openai-chat';
+    async parseRequest(original, _ctx) {
+        const parsed = parseReqInboundFormatEnvelopeWithNative({
+            rawRequest: original,
+            protocol: this.protocol
+        });
+        const payload = normalizeReqInboundReasoningPayloadWithNative({
+            payload: parsed.payload,
+            protocol: this.protocol
+        });
+        return {
+            protocol: this.protocol,
+            direction: 'request',
+            payload
+        };
+    }
+    async buildRequest(format, _ctx) {
+        return format.payload;
+    }
+    async parseResponse(original, _ctx) {
+        const parsed = parseRespInboundFormatEnvelopeWithNative({
+            payload: original,
+            protocol: this.protocol
+        });
+        const payload = normalizeRespInboundReasoningPayloadWithNative({
+            payload: parsed.payload,
+            protocol: this.protocol
+        });
+        return {
+            protocol: this.protocol,
+            direction: 'response',
+            payload
+        };
+    }
+    async buildResponse(format, _ctx) {
+        return format.payload;
+    }
+}

package/vendor/llmswitch-core/dist/conversion/hub/format-adapters/gemini-format-adapter.d.ts

@@ -0,0 +1,16 @@
+import type { FormatAdapter } from './index.js';
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { JsonObject } from '../types/json.js';
+interface GeminiFormatPayload extends JsonObject {
+    contents?: JsonObject[];
+    tools?: JsonObject[];
+}
+export declare class GeminiFormatAdapter implements FormatAdapter {
+    readonly protocol = "gemini-chat";
+    parseRequest(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<GeminiFormatPayload>>;
+    buildRequest(format: FormatEnvelope<GeminiFormatPayload>, _ctx: AdapterContext): Promise<GeminiFormatPayload>;
+    parseResponse(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<GeminiFormatPayload>>;
+    buildResponse(format: FormatEnvelope<GeminiFormatPayload>, _ctx: AdapterContext): Promise<GeminiFormatPayload>;
+}
+export {};

package/vendor/llmswitch-core/dist/conversion/hub/format-adapters/gemini-format-adapter.js

@@ -0,0 +1,42 @@
+import { parseReqInboundFormatEnvelopeWithNative, parseRespInboundFormatEnvelopeWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
+import { normalizeReqInboundReasoningPayloadWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+import { normalizeRespInboundReasoningPayloadWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+export class GeminiFormatAdapter {
+    protocol = 'gemini-chat';
+    async parseRequest(original, _ctx) {
+        const parsed = parseReqInboundFormatEnvelopeWithNative({
+            rawRequest: original,
+            protocol: this.protocol
+        });
+        const payload = normalizeReqInboundReasoningPayloadWithNative({
+            payload: parsed.payload,
+            protocol: this.protocol
+        });
+        return {
+            protocol: this.protocol,
+            direction: 'request',
+            payload
+        };
+    }
+    async buildRequest(format, _ctx) {
+        return format.payload;
+    }
+    async parseResponse(original, _ctx) {
+        const parsed = parseRespInboundFormatEnvelopeWithNative({
+            payload: original,
+            protocol: this.protocol
+        });
+        const payload = normalizeRespInboundReasoningPayloadWithNative({
+            payload: parsed.payload,
+            protocol: this.protocol
+        });
+        return {
+            protocol: this.protocol,
+            direction: 'response',
+            payload
+        };
+    }
+    async buildResponse(format, _ctx) {
+        return format.payload;
+    }
+}

package/vendor/llmswitch-core/dist/conversion/hub/format-adapters/index.d.ts

@@ -0,0 +1,21 @@
+import type { AdapterContext, ChatEnvelope } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { JsonObject } from '../types/json.js';
+export interface FormatAdapter<TRequestPayload extends JsonObject = JsonObject, TResponsePayload extends JsonObject = JsonObject> {
+    readonly protocol: string;
+    parseRequest(original: TRequestPayload, ctx: AdapterContext): Promise<FormatEnvelope<TRequestPayload>> | FormatEnvelope<TRequestPayload>;
+    buildRequest(format: FormatEnvelope, ctx: AdapterContext): Promise<TRequestPayload> | TRequestPayload;
+    parseResponse(original: TResponsePayload, ctx: AdapterContext): Promise<FormatEnvelope<TResponsePayload>> | FormatEnvelope<TResponsePayload>;
+    buildResponse(format: FormatEnvelope, ctx: AdapterContext): Promise<TResponsePayload> | TResponsePayload;
+}
+export interface StageRecorder {
+    record(stage: string, payload: object): void;
+}
+export interface SemanticMapper {
+    toChat(format: FormatEnvelope, ctx: AdapterContext): Promise<ChatEnvelope> | ChatEnvelope;
+    fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope> | FormatEnvelope;
+}
+export { ChatFormatAdapter } from './chat-format-adapter.js';
+export { AnthropicFormatAdapter } from './anthropic-format-adapter.js';
+export { ResponsesFormatAdapter } from './responses-format-adapter.js';
+export { GeminiFormatAdapter } from './gemini-format-adapter.js';

package/vendor/llmswitch-core/dist/conversion/hub/format-adapters/index.js

@@ -0,0 +1,4 @@
+export { ChatFormatAdapter } from './chat-format-adapter.js';
+export { AnthropicFormatAdapter } from './anthropic-format-adapter.js';
+export { ResponsesFormatAdapter } from './responses-format-adapter.js';
+export { GeminiFormatAdapter } from './gemini-format-adapter.js';

package/vendor/llmswitch-core/dist/conversion/hub/format-adapters/responses-format-adapter.d.ts

@@ -0,0 +1,19 @@
+import type { FormatAdapter } from './index.js';
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { JsonObject, JsonValue } from '../types/json.js';
+interface ResponsesFormatPayload extends JsonObject {
+    input?: JsonValue[];
+    tools?: JsonValue[];
+    tool_outputs?: JsonValue[];
+    output?: JsonValue[];
+    id?: string;
+}
+export declare class ResponsesFormatAdapter implements FormatAdapter {
+    readonly protocol = "openai-responses";
+    parseRequest(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<ResponsesFormatPayload>>;
+    buildRequest(format: FormatEnvelope<ResponsesFormatPayload>, _ctx: AdapterContext): Promise<ResponsesFormatPayload>;
+    parseResponse(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<ResponsesFormatPayload>>;
+    buildResponse(format: FormatEnvelope<ResponsesFormatPayload>, _ctx: AdapterContext): Promise<ResponsesFormatPayload>;
+}
+export {};

package/vendor/llmswitch-core/dist/conversion/hub/format-adapters/responses-format-adapter.js

@@ -0,0 +1,42 @@
+import { parseReqInboundFormatEnvelopeWithNative, parseRespInboundFormatEnvelopeWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
+import { normalizeReqInboundReasoningPayloadWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+import { normalizeRespInboundReasoningPayloadWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+export class ResponsesFormatAdapter {
+    protocol = 'openai-responses';
+    async parseRequest(original, _ctx) {
+        const parsed = parseReqInboundFormatEnvelopeWithNative({
+            rawRequest: original,
+            protocol: this.protocol
+        });
+        const payload = normalizeReqInboundReasoningPayloadWithNative({
+            payload: parsed.payload,
+            protocol: this.protocol
+        });
+        return {
+            protocol: this.protocol,
+            direction: 'request',
+            payload
+        };
+    }
+    async buildRequest(format, _ctx) {
+        return format.payload;
+    }
+    async parseResponse(original, _ctx) {
+        const parsed = parseRespInboundFormatEnvelopeWithNative({
+            payload: original,
+            protocol: this.protocol
+        });
+        const payload = normalizeRespInboundReasoningPayloadWithNative({
+            payload: parsed.payload,
+            protocol: this.protocol
+        });
+        return {
+            protocol: this.protocol,
+            direction: 'response',
+            payload
+        };
+    }
+    async buildResponse(format, _ctx) {
+        return format.payload;
+    }
+}

package/vendor/llmswitch-core/dist/conversion/hub/hub-feature.d.ts

@@ -0,0 +1 @@
+export declare function isHubProtocolEnabled(protocol: string): boolean;

package/vendor/llmswitch-core/dist/conversion/hub/hub-feature.js

@@ -0,0 +1,26 @@
+import { normalizeProviderProtocolTokenWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+const DISABLE_FLAG = (process.env.ROUTECODEX_HUB_ENABLED || process.env.ROUTECODEX_ENABLE_HUB) ?? '1';
+const PROTOCOL_LIST = process.env.ROUTECODEX_HUB_PROTOCOLS;
+function parseProtocolList(input) {
+    if (!input)
+        return null;
+    const entries = input
+        .split(',')
+        .map((token) => normalizeProviderProtocolTokenWithNative(token) ?? token.trim().toLowerCase())
+        .filter(Boolean);
+    if (!entries.length) {
+        return null;
+    }
+    return new Set(entries);
+}
+const normalizedList = parseProtocolList(PROTOCOL_LIST);
+export function isHubProtocolEnabled(protocol) {
+    if (DISABLE_FLAG.trim() === '0' || DISABLE_FLAG.trim().toLowerCase() === 'false') {
+        return false;
+    }
+    if (!normalizedList) {
+        return true;
+    }
+    const normalizedProtocol = normalizeProviderProtocolTokenWithNative(protocol) ?? protocol.trim().toLowerCase();
+    return normalizedList.has(normalizedProtocol);
+}

package/vendor/llmswitch-core/dist/conversion/hub/node-support.d.ts

@@ -0,0 +1,19 @@
+import type { StandardizedRequest, ProcessedRequest } from './types/standardized.js';
+import type { HubNodeContext, HubNodeResult } from './types/node.js';
+export interface HubInboundOptions {
+    protocol: string;
+    rawRequest: Record<string, unknown>;
+    nodeContext: HubNodeContext;
+    nodeId: string;
+    inputFormat: string;
+    outputFormat: string;
+    startTime: number;
+}
+export interface HubOutboundOptions {
+    protocol: string;
+    request: StandardizedRequest | ProcessedRequest;
+    nodeContext: HubNodeContext;
+}
+export declare function shouldUseHub(protocol: string): boolean;
+export declare function runHubInboundConversion(options: HubInboundOptions): Promise<HubNodeResult>;
+export declare function runHubOutboundConversion(options: HubOutboundOptions): Promise<Record<string, unknown>>;

package/vendor/llmswitch-core/dist/conversion/hub/node-support.js

@@ -0,0 +1,136 @@
+import { createProtocolPlans } from './registry.js';
+import { runInboundPipeline } from './pipelines/inbound.js';
+import { runOutboundPipeline } from './pipelines/outbound.js';
+import { createSnapshotRecorder } from './snapshot-recorder.js';
+import { ConversionError } from './types/errors.js';
+import { isHubProtocolEnabled } from './hub-feature.js';
+import { chatEnvelopeToStandardizedWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+import { standardizedToChatEnvelopeWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
+export function shouldUseHub(protocol) {
+    return isHubProtocolEnabled(protocol);
+}
+export async function runHubInboundConversion(options) {
+    const adapterContext = deriveAdapterContext(options.nodeContext, options.protocol);
+    const rawPayload = ensureJsonObject(options.rawRequest, options.nodeId);
+    const stageRecorder = maybeCreateStageRecorder(adapterContext, options.nodeContext.request.endpoint);
+    const { inbound } = createProtocolPlans(options.protocol);
+    const chatEnvelope = await runInboundPipeline({
+        rawRequest: rawPayload,
+        context: adapterContext,
+        plan: inbound,
+        stageRecorder
+    });
+    const standardized = chatEnvelopeToStandardizedWithNative({
+        chatEnvelope: chatEnvelope,
+        adapterContext: adapterContext,
+        endpoint: options.nodeContext.request.endpoint,
+        requestId: options.nodeContext.request.id
+    });
+    return buildHubNodeResult({
+        nodeId: options.nodeId,
+        startTime: options.startTime,
+        standardized,
+        inputFormat: options.inputFormat,
+        outputFormat: options.outputFormat
+    });
+}
+export async function runHubOutboundConversion(options) {
+    const adapterContext = deriveAdapterContext(options.nodeContext, options.protocol);
+    // Snapshots must be grouped by the client-facing entry endpoint, not by the provider protocol.
+    // A /v1/responses request routed to an anthropic upstream is still a responses *entry* request.
+    const stageRecorder = maybeCreateStageRecorder(adapterContext, options.nodeContext.request.endpoint);
+    const { outbound } = createProtocolPlans(options.protocol);
+    const chatEnvelope = standardizedToChatEnvelopeWithNative({
+        request: options.request,
+        adapterContext: adapterContext
+    });
+    const payload = await runOutboundPipeline({
+        chat: chatEnvelope,
+        context: adapterContext,
+        plan: outbound,
+        stageRecorder
+    });
+    return payload;
+}
+function maybeCreateStageRecorder(adapterContext, defaultEndpoint) {
+    const flag = process.env.ROUTECODEX_HUB_SNAPSHOTS;
+    if (flag && flag.trim() === '0') {
+        return undefined;
+    }
+    const endpoint = defaultEndpoint || adapterContext.entryEndpoint || '/v1/chat/completions';
+    return createSnapshotRecorder(adapterContext, endpoint);
+}
+function resolveEndpointForProtocol(protocol) {
+    if (!protocol)
+        return undefined;
+    const value = protocol.toLowerCase();
+    if (value === 'openai-responses')
+        return '/v1/responses';
+    if (value === 'openai-chat')
+        return '/v1/chat/completions';
+    if (value === 'anthropic-messages' || value === 'anthropic')
+        return '/v1/messages';
+    if (value === 'gemini' || value === 'google-gemini')
+        return '/v1/responses';
+    return undefined;
+}
+function ensureJsonObject(value, nodeId) {
+    if (!value || typeof value !== 'object') {
+        throw new ConversionError('Hub inbound requires JSON object payload', nodeId);
+    }
+    return value;
+}
+function buildHubNodeResult(options) {
+    return {
+        success: true,
+        data: {
+            standardizedRequest: options.standardized,
+            originalFormat: options.inputFormat,
+            targetFormat: options.outputFormat
+        },
+        metadata: {
+            node: options.nodeId,
+            executionTime: Date.now() - options.startTime,
+            startTime: options.startTime,
+            endTime: Date.now(),
+            dataProcessed: {
+                messages: options.standardized.messages.length,
+                tools: options.standardized.tools?.length ?? 0
+            }
+        }
+    };
+}
+function deriveAdapterContext(context, fallbackProtocol) {
+    const requestContext = (context.request.context ?? {});
+    const metadata = (requestContext.metadata ?? {});
+    const target = metadata.target;
+    const providerProtocol = target?.outboundProfile ||
+        (typeof metadata.providerProtocol === 'string' ? metadata.providerProtocol : undefined) ||
+        fallbackProtocol;
+    const streamingHint = metadata.stream === true ? 'force' : metadata.stream === false ? 'disable' : 'auto';
+    const toolCallIdStyle = normalizeToolCallIdStyleCandidate(metadata.toolCallIdStyle);
+    return {
+        requestId: context.request.id,
+        entryEndpoint: (typeof requestContext.entryEndpoint === 'string' ? requestContext.entryEndpoint : context.request.endpoint) ||
+            '/v1/chat/completions',
+        providerProtocol,
+        providerId: (target?.providerKey || metadata.providerKey),
+        routeId: metadata.routeName,
+        profileId: metadata.pipelineId,
+        streamingHint,
+        toolCallIdStyle
+    };
+}
+function normalizeToolCallIdStyleCandidate(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'fc') {
+        return 'fc';
+    }
+    if (normalized === 'preserve') {
+        return 'preserve';
+    }
+    return undefined;
+}

package/vendor/llmswitch-core/dist/conversion/hub/operation-table/operation-table-runner.d.ts

@@ -0,0 +1,18 @@
+import type { AdapterContext, ChatEnvelope } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { JsonObject } from '../types/json.js';
+export declare function applyHubOperationTableInbound(options: {
+    formatEnvelope: FormatEnvelope<JsonObject>;
+    chatEnvelope: ChatEnvelope;
+    adapterContext: AdapterContext;
+}): void;
+export declare function applyHubOperationTableOutboundPreMap(options: {
+    protocol: string;
+    chatEnvelope: ChatEnvelope;
+    adapterContext: AdapterContext;
+}): Promise<void>;
+export declare function applyHubOperationTableOutboundPostMap(options: {
+    chatEnvelope: ChatEnvelope;
+    formatEnvelope: FormatEnvelope<JsonObject>;
+    adapterContext: AdapterContext;
+}): void;

package/vendor/llmswitch-core/dist/conversion/hub/operation-table/operation-table-runner.js

@@ -0,0 +1,162 @@
+import { createBridgeActionState, runBridgeActionPipeline } from '../../bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from '../../bridge-policies.js';
+import { normalizeProviderProtocolTokenWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+const INBOUND_BRIDGE_SPECS = {
+    'openai-chat': { protocol: 'openai-chat', stage: 'request_inbound', messages: 'chat_envelope' },
+    // Keep parity with the legacy semantic mapper behavior: do not pass messages[] into the action state
+    // for openai-responses, since the bridge actions here are used as metadata hooks only.
+    'openai-responses': { protocol: 'openai-responses', stage: 'request_inbound', messages: 'none', includeCapturedToolResults: true, moduleType: 'openai-responses' },
+    'anthropic-messages': { protocol: 'anthropic-messages', stage: 'request_inbound', messages: 'chat_envelope' },
+    'gemini-chat': { protocol: 'gemini-chat', stage: 'request_inbound', messages: 'chat_envelope' }
+};
+const OUTBOUND_BRIDGE_SPECS = {
+    'openai-chat': { protocol: 'openai-chat', stage: 'request_outbound', messages: 'format_payload_messages', includeCapturedToolResults: true },
+    // Keep parity: openai-responses outbound actions should not touch normalized messages.
+    'openai-responses': { protocol: 'openai-responses', stage: 'request_outbound', messages: 'none', moduleType: 'openai-responses' },
+    'anthropic-messages': { protocol: 'anthropic-messages', stage: 'request_outbound', messages: 'none', includeCapturedToolResults: true },
+    // Keep parity with legacy gemini mapper: outbound hooks operate on ChatEnvelope.messages (not Gemini contents).
+    'gemini-chat': { protocol: 'gemini-chat', stage: 'request_outbound', messages: 'chat_envelope', includeCapturedToolResults: true }
+};
+function isSupportedProtocol(protocol) {
+    const normalizedProtocol = normalizeProviderProtocolTokenWithNative(protocol) ?? protocol;
+    return normalizedProtocol === 'openai-chat' ||
+        normalizedProtocol === 'openai-responses' ||
+        normalizedProtocol === 'anthropic-messages' ||
+        normalizedProtocol === 'gemini-chat';
+}
+function extractPayloadMessages(payload) {
+    const value = payload?.messages;
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function buildCapturedToolResults(toolOutputs) {
+    if (!Array.isArray(toolOutputs) || toolOutputs.length === 0) {
+        return undefined;
+    }
+    return toolOutputs.map((entry) => ({
+        tool_call_id: entry.tool_call_id,
+        output: entry.content,
+        name: entry.name
+    }));
+}
+function applyBridgePolicy(spec, options) {
+    const bridgePolicy = resolveBridgePolicy({ protocol: spec.protocol, moduleType: spec.moduleType ?? spec.protocol });
+    const actions = resolvePolicyActions(bridgePolicy, spec.stage);
+    if (!actions?.length) {
+        return;
+    }
+    const metadata = options.chatEnvelope.metadata;
+    const messages = spec.messages === 'chat_envelope'
+        ? options.chatEnvelope.messages
+        : spec.messages === 'format_payload_messages'
+            ? extractPayloadMessages(options.payload)
+            : undefined;
+    const capturedToolResults = spec.includeCapturedToolResults
+        ? buildCapturedToolResults(options.chatEnvelope.toolOutputs)
+        : undefined;
+    const actionState = createBridgeActionState({
+        ...(messages ? { messages } : {}),
+        rawRequest: options.payload,
+        metadata,
+        ...(capturedToolResults ? { capturedToolResults } : {})
+    });
+    runBridgeActionPipeline({
+        stage: spec.stage,
+        actions,
+        protocol: bridgePolicy?.protocol ?? spec.protocol,
+        moduleType: bridgePolicy?.moduleType ?? spec.moduleType ?? spec.protocol,
+        requestId: options.requestId,
+        state: actionState
+    });
+    if (spec.messages === 'chat_envelope') {
+        options.chatEnvelope.messages = actionState.messages;
+    }
+}
+function normalizeToolContent(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value == null)
+        return '';
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value ?? '');
+    }
+}
+function rebuildGeminiToolOutputsFromMessages(chatEnvelope) {
+    const messages = Array.isArray(chatEnvelope.messages) ? chatEnvelope.messages : [];
+    const missing = Array.isArray(chatEnvelope.metadata?.missingFields) ? chatEnvelope.metadata.missingFields : undefined;
+    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()) {
+            if (missing) {
+                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
+        });
+    });
+    chatEnvelope.toolOutputs = outputs.length ? outputs : undefined;
+}
+export function applyHubOperationTableInbound(options) {
+    const protocol = normalizeProviderProtocolTokenWithNative(options.formatEnvelope.protocol)
+        ?? options.formatEnvelope.protocol;
+    if (!isSupportedProtocol(protocol)) {
+        return;
+    }
+    const payload = (options.formatEnvelope.payload ?? {});
+    const spec = INBOUND_BRIDGE_SPECS[protocol];
+    applyBridgePolicy(spec, {
+        requestId: options.adapterContext.requestId,
+        chatEnvelope: options.chatEnvelope,
+        payload,
+        adapterContext: options.adapterContext
+    });
+    if (protocol === 'gemini-chat') {
+        // Keep parity: gemini mapper rebuilds toolOutputs after inbound policy adjustments.
+        rebuildGeminiToolOutputsFromMessages(options.chatEnvelope);
+    }
+}
+export function applyHubOperationTableOutboundPreMap(options) {
+    if (options.protocol !== 'anthropic-messages' && options.protocol !== 'gemini-chat') {
+        return Promise.resolve();
+    }
+    // Ensure tool_use/tool_result ordering and per-session history for protocols that depend on it.
+    return (async () => {
+        try {
+            const { applyToolSessionCompat } = await import('../tool-session-compat.js');
+            await applyToolSessionCompat(options.chatEnvelope, options.adapterContext);
+        }
+        catch {
+            // best-effort compat; never block outbound mapping
+        }
+    })();
+}
+export function applyHubOperationTableOutboundPostMap(options) {
+    const protocol = normalizeProviderProtocolTokenWithNative(options.formatEnvelope.protocol)
+        ?? options.formatEnvelope.protocol;
+    if (!isSupportedProtocol(protocol)) {
+        return;
+    }
+    const payload = (options.formatEnvelope.payload ?? {});
+    const spec = OUTBOUND_BRIDGE_SPECS[protocol];
+    applyBridgePolicy(spec, {
+        requestId: options.adapterContext.requestId,
+        chatEnvelope: options.chatEnvelope,
+        payload,
+        adapterContext: options.adapterContext
+    });
+    options.formatEnvelope.payload = payload;
+}

package/vendor/llmswitch-core/dist/conversion/hub/operation-table/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>;
+}