@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage2_semantic_map/semantic-lift.js

@@ -0,0 +1,24 @@
+import { isJsonObject } from '../../../../types/json.js';
+import { applyReqInboundSemanticLiftWithNative, mapReqInboundResumeToolOutputsDetailedWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export function liftReqInboundSemantics(options) {
+    const normalizedResponsesResume = options.responsesResume && isJsonObject(options.responsesResume) ? options.responsesResume : undefined;
+    const lifted = applyReqInboundSemanticLiftWithNative({
+        chatEnvelope: options.chatEnvelope,
+        payload: options.formatEnvelope.payload,
+        protocol: options.formatEnvelope.protocol,
+        entryEndpoint: options.adapterContext.entryEndpoint,
+        responsesResume: normalizedResponsesResume
+    });
+    replaceEnvelope(options.chatEnvelope, lifted);
+}
+export function mapResumeToolOutputsDetailed(responsesResume) {
+    return mapReqInboundResumeToolOutputsDetailedWithNative(responsesResume);
+}
+function replaceEnvelope(target, source) {
+    for (const key of Object.keys(target)) {
+        if (!Object.prototype.hasOwnProperty.call(source, key)) {
+            delete target[key];
+        }
+    }
+    Object.assign(target, source);
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/archive/shell-like-tool-call-normalization-fallback.d.ts

@@ -0,0 +1,2 @@
+import type { JsonObject } from '../../../../../types/json.js';
+export declare function normalizeShellLikeToolCallsBeforeGovernanceFallback(payload: JsonObject): void;

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/archive/shell-like-tool-call-normalization-fallback.js

@@ -0,0 +1,157 @@
+import { isShellLikeToolNameTokenWithNative } from '../../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+const SHELL_LIKE_TOOL_NAMES = new Set(['exec_command', 'shell_command', 'shell', 'bash', 'terminal']);
+function readTrimmedString(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function readStringArrayCommand(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const tokens = value
+        .map((item) => (item == null ? '' : String(item).trim()))
+        .filter((item) => item.length > 0);
+    return tokens.length ? tokens.join(' ') : undefined;
+}
+function parseJsonRecord(value) {
+    if (isRecord(value)) {
+        return value;
+    }
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readCommandFromArgs(args) {
+    const input = isRecord(args.input) ? args.input : undefined;
+    const direct = readTrimmedString(args.cmd) ??
+        readTrimmedString(args.command) ??
+        readTrimmedString(args.script) ??
+        readTrimmedString(args.toon) ??
+        readStringArrayCommand(args.cmd) ??
+        readStringArrayCommand(args.command);
+    if (direct) {
+        return direct;
+    }
+    if (!input) {
+        return undefined;
+    }
+    return (readTrimmedString(input.cmd) ??
+        readTrimmedString(input.command) ??
+        readTrimmedString(input.script) ??
+        readStringArrayCommand(input.cmd) ??
+        readStringArrayCommand(input.command));
+}
+function readWorkdirFromArgs(args) {
+    const input = isRecord(args.input) ? args.input : undefined;
+    return (readTrimmedString(args.workdir) ??
+        readTrimmedString(args.cwd) ??
+        readTrimmedString(args.workDir) ??
+        readTrimmedString(input?.workdir) ??
+        readTrimmedString(input?.cwd));
+}
+function collectRequestedToolNames(payload) {
+    const names = new Set();
+    const root = payload;
+    const tools = Array.isArray(root.tools) ? root.tools : [];
+    for (const tool of tools) {
+        if (!isRecord(tool))
+            continue;
+        const fn = isRecord(tool.function) ? tool.function : undefined;
+        const name = readTrimmedString(fn?.name) ?? readTrimmedString(tool.name);
+        if (name) {
+            names.add(name);
+        }
+    }
+    return names;
+}
+function resolveShellLikeToolName(rawName, requestedToolNames) {
+    if (requestedToolNames.size === 0) {
+        return rawName;
+    }
+    if (requestedToolNames.has(rawName)) {
+        return rawName;
+    }
+    if (requestedToolNames.has('exec_command')) {
+        return 'exec_command';
+    }
+    if (requestedToolNames.has('shell_command')) {
+        return 'shell_command';
+    }
+    return rawName;
+}
+export function normalizeShellLikeToolCallsBeforeGovernanceFallback(payload) {
+    const root = payload;
+    const messages = Array.isArray(root.messages) ? root.messages : [];
+    if (!messages.length) {
+        return;
+    }
+    const requestedToolNames = collectRequestedToolNames(payload);
+    for (const message of messages) {
+        if (!isRecord(message))
+            continue;
+        const role = readTrimmedString(message.role)?.toLowerCase();
+        if (role !== 'assistant')
+            continue;
+        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+        if (!toolCalls.length)
+            continue;
+        for (const call of toolCalls) {
+            if (!isRecord(call))
+                continue;
+            const fn = isRecord(call.function) ? call.function : undefined;
+            if (!fn)
+                continue;
+            const rawName = readTrimmedString(fn.name);
+            if (!rawName)
+                continue;
+            const isShellLike = isShellLikeToolNameTokenWithNative(rawName);
+            if (!isShellLike)
+                continue;
+            const resolvedName = resolveShellLikeToolName(rawName, requestedToolNames);
+            if (resolvedName !== rawName) {
+                fn.name = resolvedName;
+            }
+            const parsedArgs = parseJsonRecord(fn.arguments);
+            const args = parsedArgs ?? {};
+            const cmd = readCommandFromArgs(args);
+            if (!cmd) {
+                continue;
+            }
+            const nextArgs = {
+                ...args,
+                cmd,
+                command: cmd
+            };
+            const workdir = readWorkdirFromArgs(args);
+            if (workdir) {
+                nextArgs.workdir = workdir;
+            }
+            if (Object.prototype.hasOwnProperty.call(nextArgs, 'toon')) {
+                delete nextArgs.toon;
+            }
+            try {
+                fn.arguments = JSON.stringify(nextArgs);
+            }
+            catch {
+                fn.arguments = JSON.stringify({ cmd, command: cmd, ...(workdir ? { workdir } : {}) });
+            }
+        }
+    }
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/context-capture-orchestration.d.ts

@@ -0,0 +1,16 @@
+import type { AdapterContext } from '../../../../types/chat-envelope.js';
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+import type { JsonObject } from '../../../../types/json.js';
+export interface ContextCaptureOptions {
+    rawRequest: JsonObject;
+    adapterContext: AdapterContext;
+    stageRecorder?: StageRecorder;
+}
+export type ContextCaptureHandler = (options: ContextCaptureOptions) => Promise<Record<string, unknown> | undefined> | Record<string, unknown> | undefined;
+export interface ReqInboundStage3ContextCaptureOptions {
+    rawRequest: JsonObject;
+    adapterContext: AdapterContext;
+    captureContext?: ContextCaptureHandler;
+    stageRecorder?: StageRecorder;
+}
+export declare function runReqInboundStage3ContextCaptureOrchestration(options: ReqInboundStage3ContextCaptureOptions): Promise<Record<string, unknown> | undefined>;

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/context-capture-orchestration.js

@@ -0,0 +1,29 @@
+import { recordStage } from '../../../stages/utils.js';
+import { buildToolOutputSnapshot } from './tool-output-snapshot.js';
+import { augmentReqInboundContextSnapshotWithNative, resolveReqInboundServerToolFollowupSnapshotWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+const CONTEXT_CAPTURE_STAGE_ID = 'chat_process.req.stage3.context_capture';
+export async function runReqInboundStage3ContextCaptureOrchestration(options) {
+    const followupSnapshot = resolveReqInboundServerToolFollowupSnapshotWithNative(options.adapterContext);
+    if (followupSnapshot) {
+        recordStage(options.stageRecorder, CONTEXT_CAPTURE_STAGE_ID, followupSnapshot);
+        return followupSnapshot;
+    }
+    let context;
+    if (options.captureContext) {
+        try {
+            context = await options.captureContext({
+                rawRequest: options.rawRequest,
+                adapterContext: options.adapterContext
+            });
+        }
+        catch {
+            context = undefined;
+        }
+    }
+    const baseSnapshot = buildToolOutputSnapshot(options.rawRequest, options.adapterContext.providerProtocol);
+    const snapshot = context
+        ? augmentReqInboundContextSnapshotWithNative(context, baseSnapshot)
+        : baseSnapshot;
+    recordStage(options.stageRecorder, CONTEXT_CAPTURE_STAGE_ID, snapshot);
+    return snapshot;
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/context-factories.d.ts

@@ -0,0 +1,5 @@
+import type { ContextCaptureOptions, ContextCaptureHandler } from './index.js';
+export type ContextSnapshot = Record<string, unknown> | undefined;
+export type ContextCaptureFn = (options: ContextCaptureOptions) => Promise<ContextSnapshot> | ContextSnapshot;
+export declare function createResponsesContextCapture(captureImpl: ContextCaptureHandler): ContextCaptureFn;
+export declare function createNoopContextCapture(label: string): ContextCaptureFn;

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/context-factories.js

@@ -0,0 +1,19 @@
+import { runReqInboundStage3ContextCapture } from './index.js';
+import { normalizeContextCaptureLabelWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export function createResponsesContextCapture(captureImpl) {
+    return (options) => runReqInboundStage3ContextCapture({
+        rawRequest: options.rawRequest,
+        adapterContext: options.adapterContext,
+        stageRecorder: options.stageRecorder,
+        captureContext: captureImpl
+    });
+}
+export function createNoopContextCapture(label) {
+    const normalizedLabel = normalizeContextCaptureLabelWithNative(label);
+    return (options) => runReqInboundStage3ContextCapture({
+        rawRequest: options.rawRequest,
+        adapterContext: options.adapterContext,
+        stageRecorder: options.stageRecorder,
+        captureContext: () => ({ stage: normalizedLabel })
+    });
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/index.d.ts

@@ -0,0 +1,6 @@
+import type { ResponsesRequestContext } from '../../../../../responses/responses-openai-bridge.js';
+import type { ContextCaptureOptions, ReqInboundStage3ContextCaptureOptions } from './context-capture-orchestration.js';
+export type { ContextCaptureHandler, ContextCaptureOptions, ReqInboundStage3ContextCaptureOptions } from './context-capture-orchestration.js';
+export declare function runReqInboundStage3ContextCapture(options: ReqInboundStage3ContextCaptureOptions): Promise<Record<string, unknown> | undefined>;
+export declare function runChatContextCapture(options: ContextCaptureOptions): Promise<Record<string, unknown> | undefined>;
+export declare function captureResponsesContextSnapshot(options: ContextCaptureOptions): ResponsesRequestContext;

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/index.js

@@ -0,0 +1,22 @@
+import { buildToolOutputSnapshot } from './tool-output-snapshot.js';
+import { captureResponsesContextSnapshot as captureResponsesContextSnapshotModule } from './responses-context-snapshot.js';
+import { runReqInboundStage3ContextCaptureOrchestration } from './context-capture-orchestration.js';
+import { normalizeProviderProtocolTokenWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export async function runReqInboundStage3ContextCapture(options) {
+    return runReqInboundStage3ContextCaptureOrchestration(options);
+}
+export function runChatContextCapture(options) {
+    return runReqInboundStage3ContextCapture({
+        rawRequest: options.rawRequest,
+        adapterContext: options.adapterContext,
+        stageRecorder: options.stageRecorder,
+        captureContext: captureChatContextSnapshot
+    });
+}
+export function captureResponsesContextSnapshot(options) {
+    return captureResponsesContextSnapshotModule(options);
+}
+function captureChatContextSnapshot(options) {
+    const protocol = normalizeProviderProtocolTokenWithNative(options.adapterContext.providerProtocol);
+    return buildToolOutputSnapshot(options.rawRequest, protocol);
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/responses-context-snapshot.d.ts

@@ -0,0 +1,8 @@
+import type { AdapterContext } from '../../../../types/chat-envelope.js';
+import type { JsonObject } from '../../../../types/json.js';
+import type { ResponsesRequestContext } from '../../../../../responses/responses-openai-bridge.js';
+export interface ResponsesContextCaptureOptions {
+    rawRequest: JsonObject;
+    adapterContext: AdapterContext;
+}
+export declare function captureResponsesContextSnapshot(options: ResponsesContextCaptureOptions): ResponsesRequestContext;

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/responses-context-snapshot.js

@@ -0,0 +1,28 @@
+import { captureResponsesRequestContext } from '../../../../../shared/responses-conversation-store.js';
+import { captureReqInboundResponsesContextSnapshotWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export function captureResponsesContextSnapshot(options) {
+    const context = captureReqInboundResponsesContextSnapshotWithNative({
+        rawRequest: options.rawRequest,
+        requestId: options.adapterContext.requestId,
+        toolCallIdStyle: options.adapterContext.toolCallIdStyle
+    });
+    // OpenAI Responses tool loop: store the request context keyed by requestId so that
+    // `/v1/responses/:id/submit_tool_outputs` can resume the conversation later.
+    //
+    // This must be done on the hub pipeline inbound path (not in host/provider), because:
+    // - the tool loop is a client-protocol behavior (/v1/responses), independent of providerProtocol;
+    // - providers must remain transport-only;
+    // - the host may later enhance requestId with providerKey/model for logging, which is handled via rebind.
+    const requestId = typeof options.adapterContext.requestId === 'string' && options.adapterContext.requestId.trim().length
+        ? options.adapterContext.requestId
+        : undefined;
+    if (requestId) {
+        // captureResponsesRequestContext already best-effort wraps store failures.
+        captureResponsesRequestContext({
+            requestId,
+            payload: options.rawRequest,
+            context: context
+        });
+    }
+    return context;
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/tool-output-diagnostics.d.ts

@@ -0,0 +1,2 @@
+import type { JsonObject } from '../../../../types/json.js';
+export declare function injectApplyPatchDiagnostics(payload: JsonObject): void;

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/tool-output-diagnostics.js

@@ -0,0 +1,4 @@
+import { injectReqInboundToolParseDiagnosticsWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export function injectApplyPatchDiagnostics(payload) {
+    injectReqInboundToolParseDiagnosticsWithNative(payload);
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/tool-output-snapshot.d.ts

@@ -0,0 +1,10 @@
+import type { JsonObject } from '../../../../types/json.js';
+type ToolOutputItem = {
+    tool_call_id: string;
+    call_id: string;
+    output?: string;
+    name?: string;
+};
+export declare function buildToolOutputSnapshot(payload: JsonObject, providerProtocol?: string): Record<string, unknown>;
+export declare function collectToolOutputs(payload: JsonObject): ToolOutputItem[];
+export {};

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/tool-output-snapshot.js

@@ -0,0 +1,12 @@
+import { buildReqInboundToolOutputSnapshotWithNative, collectReqInboundToolOutputsWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export function buildToolOutputSnapshot(payload, providerProtocol) {
+    return buildReqInboundToolOutputSnapshotWithNative(payload, providerProtocol);
+}
+export function collectToolOutputs(payload) {
+    return collectReqInboundToolOutputsWithNative(payload).map((entry) => ({
+        tool_call_id: entry.tool_call_id,
+        call_id: entry.call_id,
+        ...(typeof entry.output === 'string' ? { output: entry.output } : {}),
+        ...(typeof entry.name === 'string' ? { name: entry.name } : {})
+    }));
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/context-merge.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterContext, ChatEnvelope } from '../../../../types/chat-envelope.js';
+export declare function applyToolCallIdStyleMetadata(chatEnvelope: ChatEnvelope, adapterContext: AdapterContext, snapshot?: Record<string, unknown>): void;
+export declare function applyContextSnapshotToChatEnvelope(chatEnvelope: ChatEnvelope, snapshot: Record<string, unknown>): void;

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/context-merge.js

@@ -0,0 +1,30 @@
+import { selectToolCallIdStyleWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-inbound-outbound-semantics.js';
+import { applyReqOutboundContextSnapshotWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
+export function applyToolCallIdStyleMetadata(chatEnvelope, adapterContext, snapshot) {
+    const metadata = chatEnvelope.metadata || (chatEnvelope.metadata = { context: adapterContext });
+    const current = typeof metadata.toolCallIdStyle === 'string'
+        ? String(metadata.toolCallIdStyle).trim()
+        : '';
+    const resolved = selectToolCallIdStyleWithNative(adapterContext, snapshot ?? {}, current || undefined);
+    if (!resolved) {
+        return;
+    }
+    // Always honor the route-selected AdapterContext toolCallIdStyle when present.
+    // This prevents cross-provider leakage (e.g. LM Studio "preserve" contaminating OpenAI "fc").
+    if (!current || current !== resolved) {
+        metadata.toolCallIdStyle = resolved;
+    }
+}
+export function applyContextSnapshotToChatEnvelope(chatEnvelope, snapshot) {
+    const hasExistingTools = Array.isArray(chatEnvelope.tools) && chatEnvelope.tools.length > 0;
+    const patch = applyReqOutboundContextSnapshotWithNative({
+        chatEnvelope: chatEnvelope,
+        snapshot
+    });
+    if (Array.isArray(patch.toolOutputs) && patch.toolOutputs.length) {
+        chatEnvelope.toolOutputs = patch.toolOutputs;
+    }
+    if (!hasExistingTools && Array.isArray(patch.tools) && patch.tools.length) {
+        chatEnvelope.tools = patch.tools;
+    }
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/index.d.ts

@@ -0,0 +1,18 @@
+import type { AdapterContext, ChatEnvelope } from '../../../../types/chat-envelope.js';
+import type { FormatEnvelope } from '../../../../types/format-envelope.js';
+import type { JsonObject } from '../../../../types/json.js';
+import type { StageRecorder, SemanticMapper } from '../../../../format-adapters/index.js';
+import type { ProcessedRequest, StandardizedRequest } from '../../../../types/standardized.js';
+export interface ReqOutboundStage1SemanticMapOptions {
+    request: StandardizedRequest | ProcessedRequest;
+    adapterContext: AdapterContext;
+    semanticMapper: Pick<SemanticMapper, 'fromChat'>;
+    contextSnapshot?: Record<string, unknown>;
+    contextMetadataKey?: string;
+    stageRecorder?: StageRecorder;
+}
+export interface ReqOutboundStage1SemanticMapResult {
+    chatEnvelope: ChatEnvelope;
+    formatEnvelope: FormatEnvelope<JsonObject>;
+}
+export declare function runReqOutboundStage1SemanticMap(options: ReqOutboundStage1SemanticMapOptions): Promise<ReqOutboundStage1SemanticMapResult>;

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/index.js

@@ -0,0 +1,84 @@
+import { applyHubOperationTableOutboundPostMap, applyHubOperationTableOutboundPreMap } from '../../../../operation-table/operation-table-runner.js';
+import { recordStage } from '../../../stages/utils.js';
+import { applyContextSnapshotToChatEnvelope, applyToolCallIdStyleMetadata } from './context-merge.js';
+import { shouldAttachReqOutboundContextSnapshotWithNative, standardizedToChatEnvelopeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
+import { validateChatEnvelopeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
+import { isHubStageTimingDetailEnabled, logHubStageTiming } from '../../../hub-stage-timing.js';
+export async function runReqOutboundStage1SemanticMap(options) {
+    const requestId = options.adapterContext.requestId || 'unknown';
+    const forceDetailLog = isHubStageTimingDetailEnabled();
+    const providerProtocol = options.adapterContext.providerProtocol;
+    const mapperName = options.semanticMapper &&
+        typeof options.semanticMapper === 'object' &&
+        options.semanticMapper.constructor?.name
+        ? String(options.semanticMapper.constructor?.name)
+        : 'unknown';
+    logHubStageTiming(requestId, 'req_outbound.stage1_native_to_chat_envelope', 'start');
+    const toChatStart = Date.now();
+    const chatEnvelope = standardizedToChatEnvelopeWithNative({
+        request: options.request,
+        adapterContext: options.adapterContext
+    });
+    logHubStageTiming(requestId, 'req_outbound.stage1_native_to_chat_envelope', 'completed', {
+        elapsedMs: Date.now() - toChatStart,
+        forceLog: forceDetailLog
+    });
+    applyToolCallIdStyleMetadata(chatEnvelope, options.adapterContext, options.contextSnapshot);
+    const shouldAttachContextSnapshot = shouldAttachReqOutboundContextSnapshotWithNative(Boolean(options.contextSnapshot), options.contextMetadataKey);
+    if (shouldAttachContextSnapshot && options.contextSnapshot && options.contextMetadataKey) {
+        logHubStageTiming(requestId, 'req_outbound.stage1_context_merge', 'start');
+        const contextMergeStart = Date.now();
+        const snapshot = options.contextSnapshot;
+        if (options.contextMetadataKey !== 'responsesContext') {
+            chatEnvelope.metadata[options.contextMetadataKey] = snapshot;
+        }
+        applyContextSnapshotToChatEnvelope(chatEnvelope, snapshot);
+        logHubStageTiming(requestId, 'req_outbound.stage1_context_merge', 'completed', {
+            elapsedMs: Date.now() - contextMergeStart,
+            forceLog: forceDetailLog
+        });
+    }
+    logHubStageTiming(requestId, 'req_outbound.stage1_validate_chat_envelope', 'start');
+    const validateStart = Date.now();
+    validateChatEnvelopeWithNative(chatEnvelope, {
+        stage: 'req_outbound',
+        direction: 'request'
+    });
+    logHubStageTiming(requestId, 'req_outbound.stage1_validate_chat_envelope', 'completed', {
+        elapsedMs: Date.now() - validateStart,
+        forceLog: forceDetailLog
+    });
+    logHubStageTiming(requestId, 'req_outbound.stage1_operation_table_pre_map', 'start');
+    const preMapStart = Date.now();
+    await applyHubOperationTableOutboundPreMap({
+        protocol: options.adapterContext.providerProtocol,
+        chatEnvelope,
+        adapterContext: options.adapterContext
+    });
+    logHubStageTiming(requestId, 'req_outbound.stage1_operation_table_pre_map', 'completed', {
+        elapsedMs: Date.now() - preMapStart,
+        forceLog: forceDetailLog
+    });
+    logHubStageTiming(requestId, 'req_outbound.stage1_mapper_from_chat', 'start');
+    const fromChatStart = Date.now();
+    const formatEnvelope = (await options.semanticMapper.fromChat(chatEnvelope, options.adapterContext));
+    logHubStageTiming(requestId, 'req_outbound.stage1_mapper_from_chat', 'completed', {
+        elapsedMs: Date.now() - fromChatStart,
+        forceLog: forceDetailLog,
+        providerProtocol,
+        mapperName
+    });
+    logHubStageTiming(requestId, 'req_outbound.stage1_operation_table_post_map', 'start');
+    const postMapStart = Date.now();
+    applyHubOperationTableOutboundPostMap({
+        chatEnvelope,
+        formatEnvelope,
+        adapterContext: options.adapterContext
+    });
+    logHubStageTiming(requestId, 'req_outbound.stage1_operation_table_post_map', 'completed', {
+        elapsedMs: Date.now() - postMapStart,
+        forceLog: forceDetailLog
+    });
+    recordStage(options.stageRecorder, 'chat_process.req.stage6.outbound.semantic_map', chatEnvelope);
+    return { chatEnvelope, formatEnvelope };
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage2_format_build/index.d.ts

@@ -0,0 +1,8 @@
+import type { FormatEnvelope } from '../../../../types/format-envelope.js';
+import type { JsonObject } from '../../../../types/json.js';
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+export interface ReqOutboundStage2FormatBuildOptions {
+    formatEnvelope: FormatEnvelope<JsonObject>;
+    stageRecorder?: StageRecorder;
+}
+export declare function runReqOutboundStage2FormatBuild(options: ReqOutboundStage2FormatBuildOptions): Promise<JsonObject>;

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage2_format_build/index.js

@@ -0,0 +1,12 @@
+import { recordStage } from '../../../stages/utils.js';
+import { stripPrivateFieldsWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
+import { buildReqOutboundFormatPayloadWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
+export async function runReqOutboundStage2FormatBuild(options) {
+    const payload = buildReqOutboundFormatPayloadWithNative({
+        formatEnvelope: options.formatEnvelope,
+        protocol: options.formatEnvelope.protocol
+    });
+    const stripped = stripPrivateFieldsWithNative(payload);
+    recordStage(options.stageRecorder, 'chat_process.req.stage7.outbound.format_build', stripped);
+    return stripped;
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage3_compat/index.d.ts

@@ -0,0 +1,14 @@
+import type { AdapterContext } from '../../../../types/chat-envelope.js';
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+import type { JsonObject } from '../../../../types/json.js';
+export type ProviderPayload = JsonObject;
+export declare function runReqOutboundStage3Compat(options: {
+    payload: ProviderPayload;
+    adapterContext: AdapterContext;
+    stageRecorder?: StageRecorder;
+}): Promise<ProviderPayload>;
+export declare function runRespInboundStageCompatResponse(options: {
+    payload: ProviderPayload;
+    adapterContext: AdapterContext;
+    stageRecorder?: StageRecorder;
+}): ProviderPayload;

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage3_compat/index.js

@@ -0,0 +1,45 @@
+import { buildNativeReqOutboundCompatAdapterContext } from '../../../compat/native-adapter-context.js';
+import { resolveCompatProfileWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
+import { runReqOutboundStage3CompatWithNative, runRespInboundStage3CompatWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
+const RATE_LIMIT_ERROR = 'ERR_COMPAT_RATE_LIMIT_DETECTED';
+function pickCompatProfile(adapterContext) {
+    const candidate = adapterContext.compatibilityProfile;
+    const explicit = typeof candidate === 'string' && candidate.trim() ? candidate.trim() : undefined;
+    return resolveCompatProfileWithNative(adapterContext, explicit);
+}
+export async function runReqOutboundStage3Compat(options) {
+    const profile = pickCompatProfile(options.adapterContext);
+    const nativeCompat = runReqOutboundStage3CompatWithNative({
+        payload: options.payload,
+        adapterContext: buildNativeReqOutboundCompatAdapterContext(options.adapterContext),
+        explicitProfile: profile
+    });
+    const effectiveProfile = nativeCompat.appliedProfile ?? profile;
+    const appliedProfile = nativeCompat.appliedProfile;
+    options.stageRecorder?.record('chat_process.req.stage8.outbound.compat', {
+        applied: Boolean(appliedProfile),
+        profile: appliedProfile || effectiveProfile || 'passthrough'
+    });
+    return nativeCompat.payload;
+}
+export function runRespInboundStageCompatResponse(options) {
+    const profile = pickCompatProfile(options.adapterContext);
+    const nativeCompat = runRespInboundStage3CompatWithNative({
+        payload: options.payload,
+        adapterContext: buildNativeReqOutboundCompatAdapterContext(options.adapterContext),
+        explicitProfile: profile
+    });
+    const effectiveProfile = nativeCompat.appliedProfile ?? profile;
+    const appliedProfile = nativeCompat.appliedProfile;
+    if (nativeCompat.nativeApplied === true && nativeCompat.rateLimitDetected === true) {
+        const err = new Error('Provider returned rate limit notice');
+        err.code = RATE_LIMIT_ERROR;
+        err.statusCode = 429;
+        throw err;
+    }
+    options.stageRecorder?.record('chat_process.resp.stage3.compat', {
+        applied: Boolean(appliedProfile),
+        profile: appliedProfile || effectiveProfile || 'passthrough'
+    });
+    return nativeCompat.payload;
+}

package/vendor/llmswitch-core/dist/conversion/hub/pipeline/stages/req_process/req_process_stage1_tool_governance/index.d.ts

@@ -0,0 +1,16 @@
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+import type { ProcessedRequest, StandardizedRequest } from '../../../../types/standardized.js';
+import type { HubProcessNodeResult } from '../../../../process/chat-process.js';
+export interface ReqProcessStage1ToolGovernanceOptions {
+    request: StandardizedRequest;
+    rawPayload: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+    entryEndpoint: string;
+    requestId: string;
+    stageRecorder?: StageRecorder;
+}
+export interface ReqProcessStage1ToolGovernanceResult {
+    processedRequest?: ProcessedRequest;
+    nodeResult?: HubProcessNodeResult;
+}
+export declare function runReqProcessStage1ToolGovernance(options: ReqProcessStage1ToolGovernanceOptions): Promise<ReqProcessStage1ToolGovernanceResult>;