@jsonstudio/rcc 0.85.9 → 0.89.3

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/hub-pipeline.js

@@ -0,0 +1,516 @@
+import { Readable } from 'node:stream';
+import { VirtualRouterEngine } from '../../../router/virtual-router/engine.js';
+import { defaultSseCodecRegistry } from '../../../sse/index.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;
+    constructor(config) {
+        this.config = config;
+        this.routerEngine = new VirtualRouterEngine();
+        this.routerEngine.initialize(config.virtualRouter);
+    }
+    updateVirtualRouterConfig(nextConfig) {
+        if (!nextConfig || typeof nextConfig !== 'object') {
+            throw new Error('HubPipeline updateVirtualRouterConfig requires VirtualRouterConfig payload');
+        }
+        this.config.virtualRouter = nextConfig;
+        this.routerEngine.initialize(nextConfig);
+    }
+    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 = [];
+        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 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: outboundProtocol,
+            stream: normalized.stream,
+            processMode: normalized.processMode,
+            routeHint: normalized.routeHint,
+            target: routing.target
+        };
+        return {
+            requestId: normalized.id,
+            providerPayload,
+            standardizedRequest,
+            processedRequest,
+            routingDecision: routing.decision,
+            routingDiagnostics: routing.diagnostics,
+            target: routing.target,
+            metadata,
+            nodeResults
+        };
+    }
+    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}`);
+        }
+        return await this.executeRequestStagePipeline(normalized, hooks);
+    }
+    captureAnthropicAliasMap(normalized, adapterContext, chatEnvelope) {
+        if (!this.shouldCaptureAnthropicAlias(normalized.entryEndpoint)) {
+            return;
+        }
+        const aliasMap = this.resolveAliasMapFromSources(adapterContext, chatEnvelope);
+        if (!aliasMap) {
+            return;
+        }
+        normalized.metadata = normalized.metadata || {};
+        if (!normalized.metadata.anthropicToolNameMap) {
+            normalized.metadata.anthropicToolNameMap = aliasMap;
+        }
+    }
+    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;
+        }
+        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;
+        }
+    }
+    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 (typeof metadata.originalModelId === 'string') {
+            adapterContext.originalModelId = metadata.originalModelId;
+        }
+        if (typeof metadata.clientModelId === 'string') {
+            adapterContext.clientModelId = metadata.clientModelId;
+        }
+        if (typeof metadata.assignedModelId === 'string') {
+            adapterContext.modelId = metadata.assignedModelId;
+        }
+        return adapterContext;
+    }
+    maybeCreateStageRecorder(context, endpoint) {
+        const flag = (process.env.ROUTECODEX_HUB_SNAPSHOTS || '').trim();
+        if (flag === '0') {
+            return undefined;
+        }
+        const effectiveEndpoint = endpoint || context.entryEndpoint || '/v1/chat/completions';
+        try {
+            return createSnapshotRecorder(context, effectiveEndpoint);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    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') {
+            throw new Error('HubPipeline requires request payload');
+        }
+        const id = request.id || `req_${Date.now()}`;
+        const endpoint = normalizeEndpoint(request.endpoint);
+        const metadataRecord = {
+            ...(request.metadata ?? {})
+        };
+        const entryEndpoint = typeof metadataRecord.entryEndpoint === 'string'
+            ? normalizeEndpoint(metadataRecord.entryEndpoint)
+            : endpoint;
+        const providerProtocol = resolveProviderProtocol(metadataRecord.providerProtocol);
+        const processMode = metadataRecord.processMode === 'passthrough' ? 'passthrough' : 'chat';
+        const direction = metadataRecord.direction === 'response' ? 'response' : 'request';
+        const stage = metadataRecord.stage === 'outbound' ? 'outbound' : 'inbound';
+        const resolvedReadable = this.unwrapReadable(request.payload);
+        const stream = Boolean(metadataRecord.stream ||
+            resolvedReadable ||
+            (request.payload && typeof request.payload === 'object' && request.payload.stream));
+        const payload = await this.materializePayload(request.payload, {
+            requestId: id,
+            entryEndpoint,
+            providerProtocol,
+            metadata: metadataRecord
+        }, resolvedReadable);
+        const normalizedMetadata = {
+            ...metadataRecord,
+            entryEndpoint,
+            providerProtocol,
+            processMode,
+            direction,
+            stage,
+            stream
+        };
+        const routeHint = typeof metadataRecord.routeHint === 'string' ? metadataRecord.routeHint : undefined;
+        if (routeHint) {
+            normalizedMetadata.routeHint = routeHint;
+        }
+        return {
+            id,
+            endpoint,
+            entryEndpoint,
+            providerProtocol,
+            payload,
+            metadata: normalizedMetadata,
+            processMode,
+            direction,
+            stage,
+            stream,
+            routeHint
+        };
+    }
+    convertProcessNodeResult(id, result) {
+        return {
+            id,
+            success: result.success,
+            metadata: result.metadata,
+            error: result.error
+                ? {
+                    code: result.error.code ?? 'hub_chat_process_error',
+                    message: result.error.message,
+                    details: result.error.details
+                }
+                : undefined
+        };
+    }
+    async materializePayload(payload, context, resolvedStream) {
+        const stream = resolvedStream ?? this.unwrapReadable(payload);
+        if (stream) {
+            return await this.convertSsePayload(stream, context);
+        }
+        if (!payload || typeof payload !== 'object') {
+            throw new Error('HubPipeline requires JSON object payload');
+        }
+        return payload;
+    }
+    unwrapReadable(payload) {
+        if (!payload) {
+            return null;
+        }
+        if (payload instanceof Readable) {
+            return payload;
+        }
+        if (payload && typeof payload === 'object' && 'readable' in payload) {
+            const candidate = payload.readable;
+            if (candidate instanceof Readable) {
+                return candidate;
+            }
+        }
+        return null;
+    }
+    async convertSsePayload(stream, context) {
+        const protocol = this.resolveSseProtocol(context);
+        const codec = defaultSseCodecRegistry.get(protocol);
+        try {
+            const result = await codec.convertSseToJson(stream, {
+                requestId: context.requestId,
+                model: this.extractModelHint(context.metadata),
+                direction: 'request'
+            });
+            if (!result || typeof result !== 'object') {
+                throw new Error('SSE conversion returned empty payload');
+            }
+            return result;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error ?? 'Unknown error');
+            throw new Error(`Failed to convert SSE payload for protocol ${protocol}: ${message}`);
+        }
+    }
+    resolveSseProtocol(context) {
+        const explicitProtocol = resolveSseProtocolFromMetadata(context.metadata);
+        if (explicitProtocol) {
+            return explicitProtocol;
+        }
+        return context.providerProtocol;
+    }
+    extractModelHint(metadata) {
+        if (typeof metadata.model === 'string' && metadata.model.trim()) {
+            return metadata.model;
+        }
+        const provider = metadata.provider;
+        const candidates = [
+            provider?.model,
+            provider?.modelId,
+            provider?.defaultModel
+        ];
+        for (const candidate of candidates) {
+            if (typeof candidate === 'string' && candidate.trim()) {
+                return candidate;
+            }
+        }
+        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';
+    const trimmed = endpoint.trim();
+    if (!trimmed)
+        return '/v1/chat/completions';
+    const normalized = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+    return normalized.replace(/\/{2,}/g, '/');
+}
+function resolveProviderProtocol(value) {
+    if (typeof value !== 'string' || !value.trim()) {
+        return 'openai-chat';
+    }
+    const normalized = value.trim().toLowerCase();
+    const mapped = PROVIDER_PROTOCOL_ALIASES[normalized];
+    if (mapped) {
+        return mapped;
+    }
+    throw new Error(`[HubPipeline] Unsupported providerProtocol "${value}". Configure a valid protocol (openai-chat|openai-responses|anthropic-messages|gemini-chat).`);
+}
+const PROVIDER_PROTOCOL_ALIASES = {
+    'openai-chat': 'openai-chat',
+    openai: 'openai-chat',
+    chat: 'openai-chat',
+    'responses': 'openai-responses',
+    'openai-responses': 'openai-responses',
+    'anthropic': 'anthropic-messages',
+    'anthropic-messages': 'anthropic-messages',
+    'messages': 'anthropic-messages',
+    'gemini': 'gemini-chat',
+    '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()) {
+        return undefined;
+    }
+    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/node_modules/@jsonstudio/llms/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/node_modules/@jsonstudio/llms/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/node_modules/@jsonstudio/llms/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/node_modules/@jsonstudio/llms/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/node_modules/@jsonstudio/llms/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/node_modules/@jsonstudio/llms/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/node_modules/@jsonstudio/llms/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;