@jsonstudio/rcc 0.90.364 → 0.90.429

package/vendor/@jsonstudio/llms/dist/conversion/hub/format-adapters/anthropic-format-adapter.js

@@ -1,42 +0,0 @@
-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/@jsonstudio/llms/dist/conversion/hub/format-adapters/chat-format-adapter.d.ts

@@ -1,17 +0,0 @@
-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/@jsonstudio/llms/dist/conversion/hub/format-adapters/chat-format-adapter.js

@@ -1,42 +0,0 @@
-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/@jsonstudio/llms/dist/conversion/hub/format-adapters/gemini-format-adapter.d.ts

@@ -1,16 +0,0 @@
-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/@jsonstudio/llms/dist/conversion/hub/format-adapters/gemini-format-adapter.js

@@ -1,42 +0,0 @@
-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/@jsonstudio/llms/dist/conversion/hub/format-adapters/index.d.ts

@@ -1,21 +0,0 @@
-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/@jsonstudio/llms/dist/conversion/hub/format-adapters/index.js

@@ -1,4 +0,0 @@
-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/@jsonstudio/llms/dist/conversion/hub/format-adapters/responses-format-adapter.d.ts

@@ -1,19 +0,0 @@
-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/@jsonstudio/llms/dist/conversion/hub/format-adapters/responses-format-adapter.js

@@ -1,42 +0,0 @@
-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/@jsonstudio/llms/dist/conversion/hub/hub-feature.d.ts

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

package/vendor/@jsonstudio/llms/dist/conversion/hub/hub-feature.js

@@ -1,26 +0,0 @@
-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/@jsonstudio/llms/dist/conversion/hub/node-support.d.ts

@@ -1,19 +0,0 @@
-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/@jsonstudio/llms/dist/conversion/hub/node-support.js

@@ -1,136 +0,0 @@
-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/@jsonstudio/llms/dist/conversion/hub/operation-table/operation-table-runner.d.ts

@@ -1,18 +0,0 @@
-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/@jsonstudio/llms/dist/conversion/hub/operation-table/operation-table-runner.js

@@ -1,162 +0,0 @@
-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/@jsonstudio/llms/dist/conversion/hub/operation-table/semantic-mappers/anthropic-mapper.d.ts

@@ -1,8 +0,0 @@
-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>;
-}