@jsonstudio/rcc 0.90.367 → 0.90.429

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

@@ -1,103 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

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