@jsonstudio/llms 0.4.6 → 0.6.2

package/dist/conversion/hub/pipeline/hub-pipeline.js

@@ -1,8 +1,23 @@
 import { Readable } from 'node:stream';
-import { runHubInboundConversion, runHubOutboundConversion } from '../node-support.js';
 import { VirtualRouterEngine } from '../../../router/virtual-router/engine.js';
 import { defaultSseCodecRegistry } from '../../../sse/index.js';
-import { runHubChatProcess } from '../process/chat-process.js';
+import { ResponsesFormatAdapter } from '../format-adapters/responses-format-adapter.js';
+import { ResponsesSemanticMapper } from '../semantic-mappers/responses-mapper.js';
+import { AnthropicFormatAdapter } from '../format-adapters/anthropic-format-adapter.js';
+import { AnthropicSemanticMapper } from '../semantic-mappers/anthropic-mapper.js';
+import { GeminiFormatAdapter } from '../format-adapters/gemini-format-adapter.js';
+import { GeminiSemanticMapper } from '../semantic-mappers/gemini-mapper.js';
+import { ChatFormatAdapter } from '../format-adapters/chat-format-adapter.js';
+import { ChatSemanticMapper } from '../semantic-mappers/chat-mapper.js';
+import { createSnapshotRecorder } from '../snapshot-recorder.js';
+import { runReqInboundStage1FormatParse } from './stages/req_inbound/req_inbound_stage1_format_parse/index.js';
+import { runReqInboundStage2SemanticMap } from './stages/req_inbound/req_inbound_stage2_semantic_map/index.js';
+import { runChatContextCapture, captureResponsesContextSnapshot } from './stages/req_inbound/req_inbound_stage3_context_capture/index.js';
+import { createResponsesContextCapture, createNoopContextCapture } from './stages/req_inbound/req_inbound_stage3_context_capture/context-factories.js';
+import { runReqProcessStage1ToolGovernance } from './stages/req_process/req_process_stage1_tool_governance/index.js';
+import { runReqProcessStage2RouteSelect } from './stages/req_process/req_process_stage2_route_select/index.js';
+import { runReqOutboundStage1SemanticMap } from './stages/req_outbound/req_outbound_stage1_semantic_map/index.js';
+import { runReqOutboundStage2FormatBuild } from './stages/req_outbound/req_outbound_stage2_format_build/index.js';
 export class HubPipeline {
     routerEngine;
     config;
@@ -18,23 +33,128 @@ export class HubPipeline {
         this.config.virtualRouter = nextConfig;
         this.routerEngine.initialize(nextConfig);
     }
-    async execute(request) {
-        const normalized = await this.normalizeRequest(request);
+    async executeRequestStagePipeline(normalized, hooks) {
+        const formatAdapter = hooks.createFormatAdapter();
+        const semanticMapper = hooks.createSemanticMapper();
+        const inboundAdapterContext = this.buildAdapterContext(normalized);
+        const inboundRecorder = this.maybeCreateStageRecorder(inboundAdapterContext, normalized.entryEndpoint);
+        const rawRequest = this.asJsonObject(normalized.payload);
+        const inboundStart = Date.now();
+        const formatEnvelope = await runReqInboundStage1FormatParse({
+            rawRequest,
+            adapterContext: inboundAdapterContext,
+            formatAdapter,
+            stageRecorder: inboundRecorder
+        });
+        const inboundStage2 = await runReqInboundStage2SemanticMap({
+            adapterContext: inboundAdapterContext,
+            formatEnvelope,
+            semanticMapper,
+            stageRecorder: inboundRecorder
+        });
+        this.captureAnthropicAliasMap(normalized, inboundAdapterContext, inboundStage2.chatEnvelope);
+        const contextSnapshot = await hooks.captureContext({
+            rawRequest,
+            adapterContext: inboundAdapterContext,
+            stageRecorder: inboundRecorder
+        });
+        const standardizedRequest = inboundStage2.standardizedRequest;
+        const inboundEnd = Date.now();
         const nodeResults = [];
-        const inbound = await this.runInboundStage(normalized);
-        nodeResults.push(inbound.nodeResult);
-        const process = await this.runProcessStage(normalized, inbound.standardizedRequest);
-        if (process.nodeResult) {
-            nodeResults.push(process.nodeResult);
+        nodeResults.push({
+            id: 'req_inbound',
+            success: true,
+            metadata: {
+                node: 'req_inbound',
+                executionTime: inboundEnd - inboundStart,
+                startTime: inboundStart,
+                endTime: inboundEnd,
+                dataProcessed: {
+                    messages: standardizedRequest.messages.length,
+                    tools: standardizedRequest.tools?.length ?? 0
+                }
+            }
+        });
+        let processedRequest;
+        if (normalized.processMode !== 'passthrough') {
+            const processResult = await runReqProcessStage1ToolGovernance({
+                request: standardizedRequest,
+                rawPayload: rawRequest,
+                metadata: normalized.metadata,
+                entryEndpoint: normalized.entryEndpoint,
+                requestId: normalized.id,
+                stageRecorder: inboundRecorder
+            });
+            processedRequest = processResult.processedRequest;
+            if (processResult.nodeResult) {
+                nodeResults.push(this.convertProcessNodeResult('req_process_stage1_tool_governance', processResult.nodeResult));
+            }
+        }
+        const workingRequest = processedRequest ?? standardizedRequest;
+        const metadataInput = {
+            requestId: normalized.id,
+            entryEndpoint: normalized.entryEndpoint,
+            processMode: normalized.processMode,
+            stream: normalized.stream,
+            direction: normalized.direction,
+            providerProtocol: normalized.providerProtocol,
+            routeHint: normalized.routeHint,
+            stage: normalized.stage
+        };
+        const routing = runReqProcessStage2RouteSelect({
+            routerEngine: this.routerEngine,
+            request: workingRequest,
+            metadataInput,
+            normalizedMetadata: normalized.metadata,
+            stageRecorder: inboundRecorder
+        });
+        const outboundAdapterContext = this.buildAdapterContext(normalized, routing.target);
+        const outboundProtocol = outboundAdapterContext.providerProtocol;
+        const protocolSwitch = outboundProtocol !== normalized.providerProtocol;
+        const outboundHooks = protocolSwitch ? this.resolveProtocolHooks(outboundProtocol) : hooks;
+        if (!outboundHooks) {
+            throw new Error(`[HubPipeline] Unsupported provider protocol for hub pipeline: ${outboundProtocol}`);
         }
-        const processedRequest = process.processedRequest;
-        const routing = this.routeRequest(processedRequest ?? inbound.standardizedRequest, normalized);
-        const outbound = await this.runOutboundStage(processedRequest ?? inbound.standardizedRequest, normalized, routing.target);
-        nodeResults.push(outbound.nodeResult);
+        const outboundSemanticMapper = protocolSwitch ? outboundHooks.createSemanticMapper() : semanticMapper;
+        const outboundFormatAdapter = protocolSwitch ? outboundHooks.createFormatAdapter() : formatAdapter;
+        const outboundContextMetadataKey = protocolSwitch ? outboundHooks.contextMetadataKey : hooks.contextMetadataKey;
+        const outboundContextSnapshot = protocolSwitch ? undefined : contextSnapshot;
+        const outboundEndpoint = resolveEndpointForProviderProtocol(outboundAdapterContext.providerProtocol);
+        const outboundRecorder = this.maybeCreateStageRecorder(outboundAdapterContext, outboundEndpoint);
+        const outboundStart = Date.now();
+        const outboundStage1 = await runReqOutboundStage1SemanticMap({
+            request: workingRequest,
+            adapterContext: outboundAdapterContext,
+            semanticMapper: outboundSemanticMapper,
+            contextSnapshot: outboundContextSnapshot,
+            contextMetadataKey: outboundContextMetadataKey,
+            stageRecorder: outboundRecorder
+        });
+        const providerPayload = await runReqOutboundStage2FormatBuild({
+            formatEnvelope: outboundStage1.formatEnvelope,
+            adapterContext: outboundAdapterContext,
+            formatAdapter: outboundFormatAdapter,
+            stageRecorder: outboundRecorder
+        });
+        const outboundEnd = Date.now();
+        nodeResults.push({
+            id: 'req_outbound',
+            success: true,
+            metadata: {
+                node: 'req_outbound',
+                executionTime: outboundEnd - outboundStart,
+                startTime: outboundStart,
+                endTime: outboundEnd,
+                dataProcessed: {
+                    messages: workingRequest.messages.length,
+                    tools: workingRequest.tools?.length ?? 0
+                }
+            }
+        });
         const metadata = {
             ...normalized.metadata,
             entryEndpoint: normalized.entryEndpoint,
-            providerProtocol: normalized.providerProtocol,
+            providerProtocol: outboundProtocol,
             stream: normalized.stream,
             processMode: normalized.processMode,
             routeHint: normalized.routeHint,
@@ -42,8 +162,8 @@ export class HubPipeline {
         };
         return {
             requestId: normalized.id,
-            providerPayload: outbound.payload,
-            standardizedRequest: inbound.standardizedRequest,
+            providerPayload,
+            standardizedRequest,
             processedRequest,
             routingDecision: routing.decision,
             routingDiagnostics: routing.diagnostics,
@@ -52,181 +172,125 @@ export class HubPipeline {
             nodeResults
         };
     }
-    async runInboundStage(normalized) {
-        const hubContext = this.createHubNodeContext(normalized);
-        const inbound = await runHubInboundConversion({
-            protocol: normalized.providerProtocol,
-            rawRequest: normalized.payload,
-            nodeContext: hubContext,
-            nodeId: 'hub-inbound',
-            inputFormat: normalized.entryEndpoint,
-            outputFormat: 'standardized-request',
-            startTime: Date.now()
-        });
-        const standardized = inbound.data?.standardizedRequest;
-        if (!standardized) {
-            throw new Error('Hub inbound pipeline did not return a standardized request');
-        }
-        return {
-            standardizedRequest: standardized,
-            nodeResult: this.convertHubNodeResult('hub-inbound', inbound)
-        };
-    }
-    async runProcessStage(normalized, standardizedRequest) {
-        if (normalized.processMode === 'passthrough') {
-            return {};
+    async execute(request) {
+        const normalized = await this.normalizeRequest(request);
+        const hooks = this.resolveProtocolHooks(normalized.providerProtocol);
+        if (!hooks) {
+            throw new Error(`Unsupported provider protocol for hub pipeline: ${normalized.providerProtocol}`);
         }
-        const processResult = await runHubChatProcess({
-            request: standardizedRequest,
-            requestId: normalized.id,
-            entryEndpoint: normalized.entryEndpoint,
-            rawPayload: normalized.payload,
-            metadata: normalized.metadata
-        });
-        return {
-            processedRequest: processResult.processedRequest,
-            nodeResult: this.convertProcessNodeResult('hub-chat-process', processResult.nodeResult)
-        };
+        return await this.executeRequestStagePipeline(normalized, hooks);
     }
-    routeRequest(request, normalized) {
-        const metadata = {
-            requestId: normalized.id,
-            entryEndpoint: normalized.entryEndpoint,
-            processMode: normalized.processMode,
-            stream: normalized.stream,
-            direction: normalized.direction,
-            providerProtocol: normalized.providerProtocol,
-            routeHint: normalized.routeHint,
-            stage: normalized.stage
-        };
-        const previousModel = typeof request?.model === 'string'
-            ? request.model
-            : undefined;
-        const result = this.routerEngine.route(request, metadata);
-        this.applyTargetMetadata(normalized.metadata, result.target, result.decision.routeName, previousModel);
-        this.applyTargetToSubject(request, result.target, previousModel);
-        return {
-            target: result.target,
-            decision: result.decision,
-            diagnostics: result.diagnostics
-        };
-    }
-    applyTargetMetadata(metadata, target, routeName, originalModel) {
-        if (!metadata || typeof metadata !== 'object')
+    captureAnthropicAliasMap(normalized, adapterContext, chatEnvelope) {
+        if (!this.shouldCaptureAnthropicAlias(normalized.entryEndpoint)) {
             return;
-        metadata.routeName = routeName;
-        metadata.pipelineId = target.providerKey;
-        metadata.target = target;
-        metadata.providerKey = target.providerKey;
-        metadata.providerType = target.providerType;
-        metadata.modelId = target.modelId;
-        metadata.processMode = target.processMode || 'chat';
-        if (target.responsesConfig?.toolCallIdStyle) {
-            metadata.toolCallIdStyle = target.responsesConfig.toolCallIdStyle;
         }
-        if (originalModel && typeof originalModel === 'string' && originalModel.trim()) {
-            const trimmed = originalModel.trim();
-            if (typeof metadata.originalModelId !== 'string' || !metadata.originalModelId) {
-                metadata.originalModelId = trimmed;
-            }
-            if (typeof metadata.clientModelId !== 'string' || !metadata.clientModelId) {
-                metadata.clientModelId = trimmed;
-            }
+        const aliasMap = this.resolveAliasMapFromSources(adapterContext, chatEnvelope);
+        if (!aliasMap) {
+            return;
         }
-        if (typeof target.modelId === 'string' && target.modelId.trim()) {
-            metadata.assignedModelId = target.modelId.trim();
+        normalized.metadata = normalized.metadata || {};
+        if (!normalized.metadata.anthropicToolNameMap) {
+            normalized.metadata.anthropicToolNameMap = aliasMap;
         }
     }
-    applyTargetToSubject(subject, target, originalModel) {
-        if (!subject || typeof subject !== 'object')
-            return;
-        const newModel = this.extractModelFromTarget(target);
-        if (!newModel)
-            return;
-        subject.model = newModel;
-        if (subject.parameters && typeof subject.parameters === 'object') {
-            subject.parameters = {
-                ...subject.parameters,
-                model: newModel
-            };
+    shouldCaptureAnthropicAlias(endpoint) {
+        return typeof endpoint === 'string' && endpoint.toLowerCase().includes('/v1/messages');
+    }
+    resolveAliasMapFromSources(adapterContext, chatEnvelope) {
+        const fromContext = coerceAliasMap(adapterContext.anthropicToolNameMap);
+        if (fromContext) {
+            return fromContext;
+        }
+        const metadataNode = chatEnvelope.metadata;
+        const direct = metadataNode ? coerceAliasMap(metadataNode.anthropicToolNameMap) : undefined;
+        if (direct) {
+            return direct;
         }
-        else {
-            subject.parameters = { model: newModel };
+        const contextNode = metadataNode && metadataNode.context && typeof metadataNode.context === 'object'
+            ? metadataNode.context
+            : undefined;
+        return coerceAliasMap(contextNode?.anthropicToolNameMap);
+    }
+    resolveProtocolHooks(protocol) {
+        switch (protocol) {
+            case 'openai-chat':
+                return {
+                    createFormatAdapter: () => new ChatFormatAdapter(),
+                    createSemanticMapper: () => new ChatSemanticMapper(),
+                    captureContext: (options) => runChatContextCapture(options),
+                    contextMetadataKey: 'chatContext'
+                };
+            case 'openai-responses':
+                return {
+                    createFormatAdapter: () => new ResponsesFormatAdapter(),
+                    createSemanticMapper: () => new ResponsesSemanticMapper(),
+                    captureContext: createResponsesContextCapture(captureResponsesContextSnapshot),
+                    contextMetadataKey: 'responsesContext'
+                };
+            case 'anthropic-messages':
+                return {
+                    createFormatAdapter: () => new AnthropicFormatAdapter(),
+                    createSemanticMapper: () => new AnthropicSemanticMapper(),
+                    captureContext: (options) => runChatContextCapture(options),
+                    contextMetadataKey: 'anthropicContext'
+                };
+            case 'gemini-chat':
+                return {
+                    createFormatAdapter: () => new GeminiFormatAdapter(),
+                    createSemanticMapper: () => new GeminiSemanticMapper(),
+                    captureContext: createNoopContextCapture('gemini-chat')
+                };
+            default:
+                return undefined;
         }
-        subject.metadata = {
-            ...subject.metadata,
-            providerKey: target.providerKey,
-            providerType: target.providerType,
-            processMode: target.processMode || 'chat'
+    }
+    buildAdapterContext(normalized, target) {
+        const metadata = normalized.metadata || {};
+        const providerProtocol = target?.outboundProfile || normalized.providerProtocol;
+        const providerId = (target?.providerKey || metadata.providerKey);
+        const routeId = metadata.routeName;
+        const profileId = (target?.providerKey || metadata.pipelineId);
+        const streamingHint = normalized.stream === true ? 'force' : normalized.stream === false ? 'disable' : 'auto';
+        const toolCallIdStyle = normalizeToolCallIdStyleCandidate(metadata.toolCallIdStyle);
+        const adapterContext = {
+            requestId: normalized.id,
+            entryEndpoint: normalized.entryEndpoint || '/v1/chat/completions',
+            providerProtocol,
+            providerId,
+            routeId,
+            profileId,
+            streamingHint,
+            toolCallIdStyle
         };
-        if (!subject.metadata || typeof subject.metadata !== 'object') {
-            subject.metadata = {};
+        if (typeof metadata.originalModelId === 'string') {
+            adapterContext.originalModelId = metadata.originalModelId;
         }
-        const subjectMeta = subject.metadata;
-        if (originalModel && typeof originalModel === 'string' && originalModel.trim()) {
-            const trimmed = originalModel.trim();
-            if (typeof subjectMeta.originalModelId !== 'string' || !subjectMeta.originalModelId) {
-                subjectMeta.originalModelId = trimmed;
-            }
-            if (typeof subjectMeta.clientModelId !== 'string' || !subjectMeta.clientModelId) {
-                subjectMeta.clientModelId = trimmed;
-            }
+        if (typeof metadata.clientModelId === 'string') {
+            adapterContext.clientModelId = metadata.clientModelId;
         }
-        subjectMeta.assignedModelId = newModel;
-    }
-    extractModelFromTarget(target) {
-        if (!target || typeof target.providerKey !== 'string') {
-            return null;
+        if (typeof metadata.assignedModelId === 'string') {
+            adapterContext.modelId = metadata.assignedModelId;
         }
-        if (typeof target.modelId === 'string' && target.modelId.trim()) {
-            return target.modelId.trim();
+        return adapterContext;
+    }
+    maybeCreateStageRecorder(context, endpoint) {
+        const flag = (process.env.ROUTECODEX_HUB_SNAPSHOTS || '').trim();
+        if (flag === '0') {
+            return undefined;
         }
-        if (typeof target.runtimeKey === 'string' && target.runtimeKey.length) {
-            const prefix = `${target.runtimeKey}.`;
-            if (target.providerKey.startsWith(prefix)) {
-                const candidate = target.providerKey.slice(prefix.length).trim();
-                if (candidate.length) {
-                    return candidate;
-                }
-            }
+        const effectiveEndpoint = endpoint || context.entryEndpoint || '/v1/chat/completions';
+        try {
+            return createSnapshotRecorder(context, effectiveEndpoint);
         }
-        const firstDot = target.providerKey.indexOf('.');
-        if (firstDot <= 0 || firstDot === target.providerKey.length - 1) {
-            return null;
+        catch {
+            return undefined;
         }
-        const fallback = target.providerKey.slice(firstDot + 1).trim();
-        return fallback.length ? fallback : null;
     }
-    async runOutboundStage(request, normalized, target) {
-        const outboundProtocol = target?.outboundProfile || normalized.providerProtocol;
-        const outboundContext = this.createHubNodeContext({
-            ...normalized,
-            metadata: {
-                ...normalized.metadata,
-                target
-            }
-        });
-        const start = Date.now();
-        const payload = await runHubOutboundConversion({
-            protocol: outboundProtocol,
-            request,
-            nodeContext: outboundContext
-        });
-        const nodeResult = {
-            id: 'hub-outbound',
-            success: true,
-            metadata: {
-                node: 'hub-outbound',
-                executionTime: Date.now() - start,
-                startTime: start,
-                endTime: Date.now(),
-                dataProcessed: {
-                    messages: request.messages.length,
-                    tools: request.tools?.length ?? 0
-                }
-            }
-        };
-        return { payload, nodeResult };
+    asJsonObject(value) {
+        if (!value || typeof value !== 'object') {
+            throw new Error('Responses pipeline requires JSON object payload');
+        }
+        return value;
     }
     async normalizeRequest(request) {
         if (!request || typeof request !== 'object') {
@@ -281,25 +345,6 @@ export class HubPipeline {
             routeHint
         };
     }
-    createHubNodeContext(normalized) {
-        return {
-            request: {
-                id: normalized.id,
-                endpoint: normalized.entryEndpoint,
-                context: {
-                    metadata: normalized.metadata
-                }
-            }
-        };
-    }
-    convertHubNodeResult(id, result) {
-        return {
-            id,
-            success: result.success,
-            metadata: result.metadata,
-            error: result.error
-        };
-    }
     convertProcessNodeResult(id, result) {
         return {
             id,
@@ -383,6 +428,19 @@ export class HubPipeline {
         return undefined;
     }
 }
+function normalizeToolCallIdStyleCandidate(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'fc') {
+        return 'fc';
+    }
+    if (normalized === 'preserve') {
+        return 'preserve';
+    }
+    return undefined;
+}
 function normalizeEndpoint(endpoint) {
     if (!endpoint)
         return '/v1/chat/completions';
@@ -416,6 +474,21 @@ const PROVIDER_PROTOCOL_ALIASES = {
     'google-gemini': 'gemini-chat',
     'gemini-chat': 'gemini-chat'
 };
+function resolveEndpointForProviderProtocol(protocol) {
+    if (!protocol) {
+        return undefined;
+    }
+    const value = protocol.toLowerCase();
+    if (value === 'openai-responses')
+        return '/v1/responses';
+    if (value === 'openai-chat')
+        return '/v1/chat/completions';
+    if (value === 'anthropic-messages' || value === 'anthropic')
+        return '/v1/messages';
+    if (value === 'gemini-chat' || value === 'gemini' || value === 'google-gemini')
+        return '/v1/responses';
+    return undefined;
+}
 function resolveSseProtocolFromMetadata(metadata) {
     const candidate = metadata.sseProtocol ?? metadata.clientSseProtocol ?? metadata.routeSseProtocol;
     if (typeof candidate !== 'string' || !candidate.trim()) {
@@ -423,3 +496,21 @@ function resolveSseProtocolFromMetadata(metadata) {
     }
     return resolveProviderProtocol(candidate);
 }
+function coerceAliasMap(candidate) {
+    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+        return undefined;
+    }
+    const normalized = {};
+    for (const [key, value] of Object.entries(candidate)) {
+        if (typeof key !== 'string' || typeof value !== 'string') {
+            continue;
+        }
+        const trimmedKey = key.trim();
+        const trimmedValue = value.trim();
+        if (!trimmedKey.length || !trimmedValue.length) {
+            continue;
+        }
+        normalized[trimmedKey] = trimmedValue;
+    }
+    return Object.keys(normalized).length ? normalized : undefined;
+}

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage1_format_parse/index.d.ts

@@ -0,0 +1,11 @@
+import type { AdapterContext } from '../../../../types/chat-envelope.js';
+import type { FormatEnvelope } from '../../../../types/format-envelope.js';
+import type { JsonObject } from '../../../../types/json.js';
+import type { FormatAdapter, StageRecorder } from '../../../../format-adapters/index.js';
+export interface ReqInboundStage1FormatParseOptions {
+    rawRequest: JsonObject;
+    adapterContext: AdapterContext;
+    formatAdapter: Pick<FormatAdapter, 'parseRequest'>;
+    stageRecorder?: StageRecorder;
+}
+export declare function runReqInboundStage1FormatParse(options: ReqInboundStage1FormatParseOptions): Promise<FormatEnvelope<JsonObject>>;

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage1_format_parse/index.js

@@ -0,0 +1,6 @@
+import { recordStage } from '../../../stages/utils.js';
+export async function runReqInboundStage1FormatParse(options) {
+    const envelope = (await options.formatAdapter.parseRequest(options.rawRequest, options.adapterContext));
+    recordStage(options.stageRecorder, 'req_inbound_stage1_format_parse', envelope);
+    return envelope;
+}

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage2_semantic_map/index.d.ts

@@ -0,0 +1,16 @@
+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 { SemanticMapper, StageRecorder } from '../../../../format-adapters/index.js';
+import type { StandardizedRequest } from '../../../../types/standardized.js';
+export interface ReqInboundStage2SemanticMapOptions {
+    adapterContext: AdapterContext;
+    formatEnvelope: FormatEnvelope<JsonObject>;
+    semanticMapper: Pick<SemanticMapper, 'toChat'>;
+    stageRecorder?: StageRecorder;
+}
+export interface ReqInboundStage2SemanticMapResult {
+    chatEnvelope: ChatEnvelope;
+    standardizedRequest: StandardizedRequest;
+}
+export declare function runReqInboundStage2SemanticMap(options: ReqInboundStage2SemanticMapOptions): Promise<ReqInboundStage2SemanticMapResult>;

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage2_semantic_map/index.js

@@ -0,0 +1,17 @@
+import { chatEnvelopeToStandardized } from '../../../../standardized-bridge.js';
+import { validateChatEnvelope } from '../../../../../shared/chat-envelope-validator.js';
+import { recordStage } from '../../../stages/utils.js';
+export async function runReqInboundStage2SemanticMap(options) {
+    const chatEnvelope = await options.semanticMapper.toChat(options.formatEnvelope, options.adapterContext);
+    validateChatEnvelope(chatEnvelope, {
+        stage: 'req_inbound',
+        direction: 'request'
+    });
+    recordStage(options.stageRecorder, 'req_inbound_stage2_semantic_map', chatEnvelope);
+    const standardizedRequest = chatEnvelopeToStandardized(chatEnvelope, {
+        adapterContext: options.adapterContext,
+        endpoint: options.adapterContext.entryEndpoint,
+        requestId: options.adapterContext.requestId
+    });
+    return { chatEnvelope, standardizedRequest };
+}

package/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/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/context-factories.js

@@ -0,0 +1,17 @@
+import { runReqInboundStage3ContextCapture } from './index.js';
+export function createResponsesContextCapture(captureImpl) {
+    return (options) => runReqInboundStage3ContextCapture({
+        rawRequest: options.rawRequest,
+        adapterContext: options.adapterContext,
+        stageRecorder: options.stageRecorder,
+        captureContext: captureImpl
+    });
+}
+export function createNoopContextCapture(label) {
+    return (options) => runReqInboundStage3ContextCapture({
+        rawRequest: options.rawRequest,
+        adapterContext: options.adapterContext,
+        stageRecorder: options.stageRecorder,
+        captureContext: () => ({ stage: label })
+    });
+}

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/index.d.ts

@@ -0,0 +1,19 @@
+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 { ResponsesRequestContext } from '../../../../../responses/responses-openai-bridge.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 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;