@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/client-remap-protocol-switch.js

@@ -0,0 +1,103 @@
+import { buildAnthropicResponseFromChat } from '../../../../response/response-runtime.js';
+import { normalizeArgsBySchema } from '../../../../../args-mapping.js';
+import { normalizeResponsesToolCallIds } from '../../../../../shared/responses-tool-utils.js';
+import { isShellToolName } from '../../../../../../tools/tool-description-utils.js';
+import { applyClientPassthroughPatchWithNative, buildResponsesPayloadFromChatWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+import { resolveAliasMapFromSemantics, resolveClientToolsRawFromSemantics } from './chat-process-semantics-bridge.js';
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function extractClientToolNameMap(clientToolsRaw) {
+    const map = new Map();
+    for (const tool of clientToolsRaw ?? []) {
+        const functionBag = asRecord(tool.function);
+        const rawName = (typeof functionBag?.name === 'string' ? functionBag.name : undefined)
+            ?? (typeof tool.name === 'string' ? tool.name : undefined);
+        const normalizedName = typeof rawName === 'string' ? rawName.trim() : '';
+        if (!normalizedName) {
+            continue;
+        }
+        map.set(normalizedName.toLowerCase(), tool);
+    }
+    return map;
+}
+function remapChatToolCallsToClientNames(payload, clientToolsRaw) {
+    const toolMap = extractClientToolNameMap(clientToolsRaw);
+    if (!toolMap.size) {
+        return;
+    }
+    const choices = Array.isArray(payload.choices)
+        ? payload.choices
+        : [];
+    for (const choice of choices) {
+        const message = asRecord(asRecord(choice)?.message);
+        const toolCalls = Array.isArray(message?.tool_calls) ? message?.tool_calls : [];
+        for (const toolCall of toolCalls) {
+            const functionBag = asRecord(asRecord(toolCall)?.function);
+            const currentName = typeof functionBag?.name === 'string' ? functionBag.name.trim() : '';
+            if (!currentName) {
+                continue;
+            }
+            const normalizedCurrentName = currentName.toLowerCase();
+            const matchedTool = toolMap.get(normalizedCurrentName)
+                ?? (isShellToolName(normalizedCurrentName)
+                    ? Array.from(toolMap.entries()).find(([toolName]) => isShellToolName(toolName))?.[1]
+                    : undefined);
+            if (!matchedTool) {
+                continue;
+            }
+            const matchedFunction = asRecord(matchedTool.function);
+            const clientName = (typeof matchedFunction?.name === 'string' ? matchedFunction.name : undefined)
+                ?? (typeof matchedTool.name === 'string' ? matchedTool.name : undefined)
+                ?? currentName;
+            functionBag.name = clientName;
+            const schema = matchedFunction?.parameters;
+            const rawArgs = functionBag?.arguments;
+            let parsedArgs = rawArgs;
+            if (typeof rawArgs === 'string') {
+                try {
+                    parsedArgs = JSON.parse(rawArgs);
+                }
+                catch {
+                    parsedArgs = rawArgs;
+                }
+            }
+            const normalized = normalizeArgsBySchema(parsedArgs, schema);
+            if (normalized.ok && normalized.value) {
+                try {
+                    functionBag.arguments = JSON.stringify(normalized.value);
+                }
+                catch {
+                    // keep existing args when client-arg serialization fails
+                }
+            }
+        }
+    }
+}
+export function buildClientPayloadForProtocol(options) {
+    let clientPayload;
+    const toolsRaw = resolveClientToolsRawFromSemantics(options.requestSemantics);
+    if (options.clientProtocol === 'openai-chat') {
+        clientPayload = options.payload;
+        remapChatToolCallsToClientNames(clientPayload, toolsRaw);
+    }
+    else if (options.clientProtocol === 'anthropic-messages') {
+        clientPayload = buildAnthropicResponseFromChat(options.payload, {
+            aliasMap: resolveAliasMapFromSemantics(options.requestSemantics)
+        });
+    }
+    else {
+        clientPayload = buildResponsesPayloadFromChatWithNative(options.payload, {
+            requestId: options.requestId,
+            ...(toolsRaw ? { toolsRaw } : {})
+        });
+    }
+    const patchedPayload = applyClientPassthroughPatchWithNative(clientPayload, options.payload);
+    Object.assign(clientPayload, patchedPayload);
+    if (options.clientProtocol === 'openai-responses') {
+        normalizeResponsesToolCallIds(clientPayload);
+    }
+    return clientPayload;
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.d.ts

@@ -0,0 +1,13 @@
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+import type { JsonObject } from '../../../../types/json.js';
+import type { AdapterContext } from '../../../../types/chat-envelope.js';
+import { type ClientProtocol } from './client-remap-protocol-switch.js';
+export interface RespOutboundStage1ClientRemapOptions {
+    payload: JsonObject;
+    clientProtocol: ClientProtocol;
+    requestId: string;
+    adapterContext?: AdapterContext;
+    requestSemantics?: JsonObject;
+    stageRecorder?: StageRecorder;
+}
+export declare function runRespOutboundStage1ClientRemap(options: RespOutboundStage1ClientRemapOptions): JsonObject;

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js

@@ -0,0 +1,30 @@
+import { recordStage } from '../../../stages/utils.js';
+import { isHubStageTimingDetailEnabled, logHubStageTiming } from '../../../hub-stage-timing.js';
+import { buildClientPayloadForProtocol } from './client-remap-protocol-switch.js';
+import { normalizeProviderProtocolTokenWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export function runRespOutboundStage1ClientRemap(options) {
+    const forceDetailLog = isHubStageTimingDetailEnabled();
+    const normalizedProtocol = normalizeProviderProtocolTokenWithNative(options.clientProtocol);
+    const clientProtocol = normalizedProtocol === 'openai-chat' ||
+        normalizedProtocol === 'openai-responses' ||
+        normalizedProtocol === 'anthropic-messages'
+        ? normalizedProtocol
+        : options.clientProtocol;
+    logHubStageTiming(options.requestId, 'resp_outbound.stage1_build_client_payload', 'start', {
+        clientProtocol
+    });
+    const buildStart = Date.now();
+    const clientPayload = buildClientPayloadForProtocol({
+        payload: options.payload,
+        clientProtocol,
+        requestId: options.requestId,
+        requestSemantics: options.requestSemantics
+    });
+    logHubStageTiming(options.requestId, 'resp_outbound.stage1_build_client_payload', 'completed', {
+        elapsedMs: Date.now() - buildStart,
+        clientProtocol,
+        forceLog: forceDetailLog
+    });
+    recordStage(options.stageRecorder, 'chat_process.resp.stage9.client_remap', clientPayload);
+    return clientPayload;
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.d.ts

@@ -0,0 +1,17 @@
+import type { Readable } from 'node:stream';
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+import type { JsonObject } from '../../../../types/json.js';
+type ClientProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages';
+export interface RespOutboundStage2SseStreamOptions {
+    clientPayload: JsonObject;
+    clientProtocol: ClientProtocol;
+    requestId: string;
+    wantsStream: boolean;
+    stageRecorder?: StageRecorder;
+}
+export interface RespOutboundStage2SseStreamResult {
+    body?: JsonObject;
+    stream?: Readable;
+}
+export declare function runRespOutboundStage2SseStream(options: RespOutboundStage2SseStreamOptions): Promise<RespOutboundStage2SseStreamResult>;
+export {};

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.js

@@ -0,0 +1,35 @@
+import { defaultSseCodecRegistry } from '../../../../../../sse/index.js';
+import { recordStage } from '../../../stages/utils.js';
+import { isHubStageTimingDetailEnabled, logHubStageTiming } from '../../../hub-stage-timing.js';
+import { resolveSseStreamModeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
+export async function runRespOutboundStage2SseStream(options) {
+    const forceDetailLog = isHubStageTimingDetailEnabled();
+    const shouldStream = resolveSseStreamModeWithNative(options.wantsStream, options.clientProtocol);
+    if (!shouldStream) {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage10.sse_stream', {
+            passthrough: false,
+            protocol: options.clientProtocol,
+            payload: options.clientPayload
+        });
+        return { body: options.clientPayload };
+    }
+    const codec = defaultSseCodecRegistry.get(options.clientProtocol);
+    logHubStageTiming(options.requestId, 'resp_outbound.stage2_codec_stream', 'start', {
+        clientProtocol: options.clientProtocol
+    });
+    const codecStart = Date.now();
+    const stream = await codec.convertJsonToSse(options.clientPayload, {
+        requestId: options.requestId
+    });
+    logHubStageTiming(options.requestId, 'resp_outbound.stage2_codec_stream', 'completed', {
+        elapsedMs: Date.now() - codecStart,
+        clientProtocol: options.clientProtocol,
+        forceLog: forceDetailLog
+    });
+    recordStage(options.stageRecorder, 'chat_process.resp.stage10.sse_stream', {
+        passthrough: false,
+        protocol: options.clientProtocol,
+        payload: options.clientPayload
+    });
+    return { stream };
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage1_tool_governance/index.d.ts

@@ -0,0 +1,16 @@
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+import type { JsonObject } from '../../../../types/json.js';
+import type { ChatCompletionLike } from '../../../../response/response-mappers.js';
+type ClientProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages';
+export interface RespProcessStage1ToolGovernanceOptions {
+    payload: ChatCompletionLike;
+    entryEndpoint: string;
+    requestId: string;
+    clientProtocol: ClientProtocol;
+    stageRecorder?: StageRecorder;
+}
+export interface RespProcessStage1ToolGovernanceResult {
+    governedPayload: JsonObject;
+}
+export declare function runRespProcessStage1ToolGovernance(options: RespProcessStage1ToolGovernanceOptions): Promise<RespProcessStage1ToolGovernanceResult>;
+export {};

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage1_tool_governance/index.js

@@ -0,0 +1,52 @@
+import { runChatResponseToolFilters } from '../../../../../shared/tool-filter-pipeline.js';
+import { recordStage } from '../../../stages/utils.js';
+import { isHubStageTimingDetailEnabled, logHubStageTiming } from '../../../hub-stage-timing.js';
+import { applyRespProcessToolGovernanceWithNative, prepareRespProcessToolGovernancePayloadWithNative } from '../../../../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
+export async function runRespProcessStage1ToolGovernance(options) {
+    const forceDetailLog = isHubStageTimingDetailEnabled();
+    logHubStageTiming(options.requestId, 'resp_process.stage1_prepare_native', 'start');
+    const prepareStart = Date.now();
+    const preparedNative = prepareRespProcessToolGovernancePayloadWithNative(options.payload);
+    const preparedPayload = preparedNative.preparedPayload;
+    logHubStageTiming(options.requestId, 'resp_process.stage1_prepare_native', 'completed', {
+        elapsedMs: Date.now() - prepareStart,
+        forceLog: forceDetailLog
+    });
+    recordStage(options.stageRecorder, 'chat_process.resp.stage6.canonicalize_chat_completion', {
+        converted: preparedNative.summary.converted,
+        shapeSanitized: preparedNative.summary.shapeSanitized,
+        harvestedToolCalls: preparedNative.summary.harvestedToolCalls,
+        canonicalPayload: preparedPayload
+    });
+    logHubStageTiming(options.requestId, 'resp_process.stage1_tool_filters', 'start');
+    const filterStart = Date.now();
+    const filtered = await runChatResponseToolFilters(preparedPayload, {
+        entryEndpoint: options.entryEndpoint,
+        requestId: options.requestId,
+        profile: 'openai-chat'
+    });
+    logHubStageTiming(options.requestId, 'resp_process.stage1_tool_filters', 'completed', {
+        elapsedMs: Date.now() - filterStart,
+        forceLog: forceDetailLog
+    });
+    logHubStageTiming(options.requestId, 'resp_process.stage1_apply_native', 'start');
+    const applyStart = Date.now();
+    const patchedNative = applyRespProcessToolGovernanceWithNative({
+        payload: filtered,
+        clientProtocol: options.clientProtocol,
+        entryEndpoint: options.entryEndpoint,
+        requestId: options.requestId
+    });
+    logHubStageTiming(options.requestId, 'resp_process.stage1_apply_native', 'completed', {
+        elapsedMs: Date.now() - applyStart,
+        forceLog: forceDetailLog
+    });
+    const governed = patchedNative.governedPayload;
+    recordStage(options.stageRecorder, 'chat_process.resp.stage7.tool_governance', {
+        summary: patchedNative.summary,
+        applied: patchedNative.summary?.applied === true,
+        filteredPayload: filtered,
+        governedPayload: governed
+    });
+    return { governedPayload: governed };
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage2_finalize/index.d.ts

@@ -0,0 +1,19 @@
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+import type { JsonObject } from '../../../../types/json.js';
+import type { ChatReasoningMode } from '../../../../../shared/openai-finalizer.js';
+import type { ProcessedRequest } from '../../../../types/standardized.js';
+export interface RespProcessStage2FinalizeOptions {
+    payload: JsonObject;
+    originalPayload?: JsonObject;
+    skipServerToolStrip?: boolean;
+    entryEndpoint: string;
+    requestId: string;
+    wantsStream: boolean;
+    reasoningMode: ChatReasoningMode;
+    stageRecorder?: StageRecorder;
+}
+export interface RespProcessStage2FinalizeResult {
+    finalizedPayload: JsonObject;
+    processedRequest: ProcessedRequest;
+}
+export declare function runRespProcessStage2Finalize(options: RespProcessStage2FinalizeOptions): Promise<RespProcessStage2FinalizeResult>;

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage2_finalize/index.js

@@ -0,0 +1,40 @@
+import { buildProcessedRequestFromChatResponse } from '../../../../response/chat-response-utils.js';
+import { recordStage } from '../../../stages/utils.js';
+import { isHubStageTimingDetailEnabled, logHubStageTiming } from '../../../hub-stage-timing.js';
+import { finalizeRespProcessChatResponseWithNative } from '../../../../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
+import { filterOutExecutedServerToolCalls } from '../../../../../../servertool/strip-servertool-calls.js';
+export async function runRespProcessStage2Finalize(options) {
+    const forceDetailLog = isHubStageTimingDetailEnabled();
+    logHubStageTiming(options.requestId, 'resp_process.stage2_native_finalize', 'start');
+    const nativeFinalizeStart = Date.now();
+    let finalized = (await finalizeRespProcessChatResponseWithNative({
+        payload: options.payload,
+        stream: options.wantsStream,
+        reasoningMode: options.reasoningMode,
+        endpoint: options.entryEndpoint,
+        requestId: options.requestId
+    }));
+    // Strip executed servertool calls before returning to client (single source of truth).
+    const stripSource = options.originalPayload ?? options.payload;
+    if (!options.skipServerToolStrip && stripSource && typeof stripSource === 'object') {
+        finalized = filterOutExecutedServerToolCalls(finalized, stripSource);
+    }
+    logHubStageTiming(options.requestId, 'resp_process.stage2_native_finalize', 'completed', {
+        elapsedMs: Date.now() - nativeFinalizeStart,
+        forceLog: forceDetailLog
+    });
+    logHubStageTiming(options.requestId, 'resp_process.stage2_build_processed_request', 'start');
+    const buildProcessedRequestStart = Date.now();
+    const processedRequest = buildProcessedRequestFromChatResponse(finalized, {
+        stream: options.wantsStream
+    });
+    logHubStageTiming(options.requestId, 'resp_process.stage2_build_processed_request', 'completed', {
+        elapsedMs: Date.now() - buildProcessedRequestStart,
+        forceLog: forceDetailLog
+    });
+    recordStage(options.stageRecorder, 'chat_process.resp.stage8.finalize', {
+        model: finalized.model,
+        stream: options.wantsStream
+    });
+    return { finalizedPayload: finalized, processedRequest };
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage3_servertool_orchestration/index.d.ts

@@ -0,0 +1,44 @@
+import type { AdapterContext } from '../../../../types/chat-envelope.js';
+import type { JsonObject } from '../../../../types/json.js';
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+import type { ChatCompletionLike } from '../../../../response/response-mappers.js';
+import type { ProviderInvoker } from '../../../../../../servertool/types.js';
+type ProviderProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages' | 'gemini-chat';
+type ReenterPipeline = (options: {
+    entryEndpoint: string;
+    requestId: string;
+    body: JsonObject;
+    metadata?: JsonObject;
+}) => Promise<{
+    body?: JsonObject;
+    __sse_responses?: NodeJS.ReadableStream;
+    format?: string;
+}>;
+type ClientInjectDispatch = (options: {
+    entryEndpoint: string;
+    requestId: string;
+    body?: JsonObject;
+    metadata?: JsonObject;
+}) => Promise<{
+    ok: boolean;
+    reason?: string;
+}>;
+export interface RespProcessStage3ServerToolOrchestrationOptions {
+    payload: ChatCompletionLike;
+    adapterContext: AdapterContext;
+    requestId: string;
+    entryEndpoint: string;
+    providerProtocol: ProviderProtocol;
+    stageRecorder?: StageRecorder;
+    providerInvoker?: ProviderInvoker;
+    reenterPipeline?: ReenterPipeline;
+    clientInjectDispatch?: ClientInjectDispatch;
+}
+export interface RespProcessStage3ServerToolOrchestrationResult {
+    payload: ChatCompletionLike;
+    executed: boolean;
+    flowId?: string;
+    skipReason?: 'no_servertool_support' | 'servertool_followup';
+}
+export declare function runRespProcessStage3ServerToolOrchestration(options: RespProcessStage3ServerToolOrchestrationOptions): Promise<RespProcessStage3ServerToolOrchestrationResult>;
+export {};

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage3_servertool_orchestration/index.js

@@ -0,0 +1,88 @@
+import { runServerToolOrchestration } from '../../../../../../servertool/engine.js';
+import { detectProviderResponseShapeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';
+import { readRuntimeMetadata } from '../../../../../../conversion/runtime-metadata.js';
+import { recordStage } from '../../../stages/utils.js';
+import { isHubStageTimingDetailEnabled, logHubStageTiming } from '../../../hub-stage-timing.js';
+function isServerToolFollowup(adapterContext) {
+    const runtime = readRuntimeMetadata(adapterContext);
+    const raw = runtime?.serverToolFollowup;
+    if (raw === true) {
+        return true;
+    }
+    if (typeof raw === 'string') {
+        const normalized = raw.trim().toLowerCase();
+        return normalized === '1' || normalized === 'true';
+    }
+    return false;
+}
+export async function runRespProcessStage3ServerToolOrchestration(options) {
+    const forceDetailLog = isHubStageTimingDetailEnabled();
+    const hasServerToolSupport = Boolean(options.providerInvoker) || Boolean(options.reenterPipeline) || Boolean(options.clientInjectDispatch);
+    const inputShape = detectProviderResponseShapeWithNative(options.payload);
+    if (isServerToolFollowup(options.adapterContext)) {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage5.servertool_orchestration', {
+            executed: false,
+            skipReason: 'servertool_followup',
+            inputShape
+        });
+        return {
+            payload: options.payload,
+            executed: false,
+            skipReason: 'servertool_followup'
+        };
+    }
+    if (!hasServerToolSupport) {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage5.servertool_orchestration', {
+            executed: false,
+            skipReason: 'no_servertool_support',
+            inputShape
+        });
+        return {
+            payload: options.payload,
+            executed: false,
+            skipReason: 'no_servertool_support'
+        };
+    }
+    logHubStageTiming(options.requestId, 'resp_process.stage3_orchestration_engine', 'start');
+    const orchestrationStart = Date.now();
+    const orchestration = await runServerToolOrchestration({
+        chat: options.payload,
+        adapterContext: options.adapterContext,
+        requestId: options.requestId,
+        entryEndpoint: options.entryEndpoint,
+        providerProtocol: options.providerProtocol,
+        stageRecorder: options.stageRecorder,
+        providerInvoker: options.providerInvoker,
+        reenterPipeline: options.reenterPipeline,
+        clientInjectDispatch: options.clientInjectDispatch
+    });
+    logHubStageTiming(options.requestId, 'resp_process.stage3_orchestration_engine', 'completed', {
+        elapsedMs: Date.now() - orchestrationStart,
+        executed: orchestration.executed,
+        flowId: orchestration.flowId,
+        forceLog: forceDetailLog
+    });
+    if (orchestration.executed) {
+        const outputPayload = orchestration.chat;
+        const outputShape = detectProviderResponseShapeWithNative(outputPayload);
+        recordStage(options.stageRecorder, 'chat_process.resp.stage5.servertool_orchestration', {
+            executed: true,
+            flowId: orchestration.flowId,
+            inputShape,
+            outputShape
+        });
+        return {
+            payload: outputPayload,
+            executed: true,
+            flowId: orchestration.flowId
+        };
+    }
+    recordStage(options.stageRecorder, 'chat_process.resp.stage5.servertool_orchestration', {
+        executed: false,
+        inputShape
+    });
+    return {
+        payload: options.payload,
+        executed: false
+    };
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/utils.d.ts

@@ -0,0 +1,2 @@
+import type { StageRecorder } from '../../format-adapters/index.js';
+export declare function recordStage(recorder: StageRecorder | undefined, stageId: string, payload: unknown): void;

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/utils.js

@@ -0,0 +1,27 @@
+import { parseLenientJsonishWithNative } from '../../../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+function normalizeRecordPayload(payload) {
+    if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
+        return payload;
+    }
+    try {
+        const nativeParsed = parseLenientJsonishWithNative(payload);
+        if (nativeParsed && typeof nativeParsed === 'object' && !Array.isArray(nativeParsed)) {
+            return nativeParsed;
+        }
+    }
+    catch {
+        // native normalization is best-effort
+    }
+    return {};
+}
+export function recordStage(recorder, stageId, payload) {
+    if (!recorder) {
+        return;
+    }
+    try {
+        recorder.record(stageId, normalizeRecordPayload(payload));
+    }
+    catch {
+        // Snapshot failures should not block the pipeline.
+    }
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/target-utils.d.ts

@@ -0,0 +1,5 @@
+import type { ProcessedRequest, StandardizedRequest } from '../types/standardized.js';
+import type { TargetMetadata } from '../../../router/virtual-router/types.js';
+export declare function applyTargetMetadata(metadata: Record<string, unknown> | undefined, target: TargetMetadata, routeName?: string, originalModel?: string): void;
+export declare function applyTargetToSubject(subject: StandardizedRequest | ProcessedRequest, target: TargetMetadata, originalModel?: string): void;
+export declare function extractModelFromTarget(target: TargetMetadata): string | null;

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/target-utils.js

@@ -0,0 +1,26 @@
+import { applyTargetMetadataWithNative, applyTargetToSubjectWithNative, extractTargetModelIdWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-target-semantics.js';
+function replaceRecord(target, source) {
+    for (const key of Object.keys(target)) {
+        if (!Object.prototype.hasOwnProperty.call(source, key)) {
+            delete target[key];
+        }
+    }
+    Object.assign(target, source);
+}
+export function applyTargetMetadata(metadata, target, routeName, originalModel) {
+    if (!metadata || typeof metadata !== 'object') {
+        return;
+    }
+    const updated = applyTargetMetadataWithNative(metadata, target, routeName, originalModel);
+    replaceRecord(metadata, updated);
+}
+export function applyTargetToSubject(subject, target, originalModel) {
+    if (!subject || typeof subject !== 'object') {
+        return;
+    }
+    const updated = applyTargetToSubjectWithNative(subject, target, originalModel);
+    replaceRecord(subject, updated);
+}
+export function extractModelFromTarget(target) {
+    return extractTargetModelIdWithNative(target);
+}

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

@@ -0,0 +1,22 @@
+import type { ChatEnvelope, AdapterContext } from '../types/chat-envelope.js';
+import type { FormatAdapter, SemanticMapper, StageRecorder } from '../format-adapters/index.js';
+import type { JsonObject } from '../types/json.js';
+export type InboundStage = 'format_parse' | 'semantic_map_to_chat' | 'inbound_passthrough';
+export interface InboundPassthroughConfig {
+    mode: 'chat';
+    factory: (raw: JsonObject, ctx: AdapterContext) => Promise<ChatEnvelope> | ChatEnvelope;
+}
+export interface InboundPlan {
+    protocol?: string;
+    stages: InboundStage[];
+    formatAdapter?: Pick<FormatAdapter, 'parseRequest'>;
+    semanticMapper?: Pick<SemanticMapper, 'toChat'>;
+    passthrough?: InboundPassthroughConfig;
+}
+export interface InboundPipelineOptions {
+    rawRequest: JsonObject;
+    context: AdapterContext;
+    plan: InboundPlan;
+    stageRecorder?: StageRecorder;
+}
+export declare function runInboundPipeline(options: InboundPipelineOptions): Promise<ChatEnvelope>;

package/vendor/llmswitch-core/dist/conversion/hub/pipelines/inbound.js

@@ -0,0 +1,66 @@
+import { normalizeProviderProtocolTokenWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+function recordStage(recorder, stage, payload) {
+    if (!recorder)
+        return;
+    try {
+        recorder.record(stage, payload);
+    }
+    catch {
+        /* snapshot failures ignored */
+    }
+}
+function ensureFormatEnvelope(envelope, rawRequest, plan, context) {
+    if (envelope)
+        return envelope;
+    const normalizedProtocol = normalizeProviderProtocolTokenWithNative(plan.protocol || context.providerProtocol);
+    return {
+        protocol: normalizedProtocol ?? plan.protocol ?? context.providerProtocol,
+        direction: 'request',
+        payload: rawRequest
+    };
+}
+export async function runInboundPipeline(options) {
+    const { rawRequest, context, plan, stageRecorder } = options;
+    if (!plan)
+        throw new Error('Inbound plan is required');
+    if (plan.passthrough?.mode === 'chat') {
+        if (!plan.passthrough.factory) {
+            throw new Error('Inbound passthrough requires factory');
+        }
+        const envelope = await plan.passthrough.factory(rawRequest, context);
+        recordStage(stageRecorder, 'inbound_passthrough', envelope);
+        return envelope;
+    }
+    if (!Array.isArray(plan.stages) || plan.stages.length === 0) {
+        throw new Error('Inbound plan must declare stages or passthrough');
+    }
+    let lastFormat;
+    let lastChat;
+    for (const stage of plan.stages) {
+        switch (stage) {
+            case 'format_parse': {
+                if (!plan.formatAdapter) {
+                    throw new Error('format_parse stage requires format adapter');
+                }
+                lastFormat = await plan.formatAdapter.parseRequest(rawRequest, context);
+                recordStage(stageRecorder, 'format_parse', lastFormat);
+                break;
+            }
+            case 'semantic_map_to_chat': {
+                if (!plan.semanticMapper) {
+                    throw new Error('semantic_map_to_chat stage requires semantic mapper');
+                }
+                const formatEnvelope = ensureFormatEnvelope(lastFormat, rawRequest, plan, context);
+                lastChat = await plan.semanticMapper.toChat(formatEnvelope, context);
+                recordStage(stageRecorder, 'semantic_map_to_chat', lastChat);
+                break;
+            }
+            default:
+                throw new Error(`Unknown inbound stage: ${stage}`);
+        }
+    }
+    if (!lastChat) {
+        throw new Error('Inbound pipeline did not produce ChatEnvelope');
+    }
+    return lastChat;
+}

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

@@ -0,0 +1,22 @@
+import type { ChatEnvelope, AdapterContext } from '../types/chat-envelope.js';
+import type { FormatAdapter, SemanticMapper, StageRecorder } from '../format-adapters/index.js';
+import type { JsonObject } from '../types/json.js';
+export type OutboundStage = 'semantic_map_from_chat' | 'format_build' | 'outbound_passthrough';
+export interface OutboundPassthroughConfig {
+    mode: 'protocol';
+    factory: (chat: ChatEnvelope, ctx: AdapterContext) => Promise<JsonObject> | JsonObject;
+}
+export interface OutboundPlan {
+    protocol?: string;
+    stages: OutboundStage[];
+    formatAdapter?: Pick<FormatAdapter, 'buildResponse'>;
+    semanticMapper?: Pick<SemanticMapper, 'fromChat'>;
+    passthrough?: OutboundPassthroughConfig;
+}
+export interface OutboundPipelineOptions {
+    chat: ChatEnvelope;
+    context: AdapterContext;
+    plan: OutboundPlan;
+    stageRecorder?: StageRecorder;
+}
+export declare function runOutboundPipeline(options: OutboundPipelineOptions): Promise<JsonObject>;