@jsonstudio/llms 0.4.6 → 0.6.2

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

@@ -0,0 +1,269 @@
+import { captureResponsesContext, buildChatRequestFromResponses } from '../../../../../responses/responses-openai-bridge.js';
+import { recordStage } from '../../../stages/utils.js';
+export async function runReqInboundStage3ContextCapture(options) {
+    let context;
+    if (options.captureContext) {
+        try {
+            context = await options.captureContext({
+                rawRequest: options.rawRequest,
+                adapterContext: options.adapterContext
+            });
+        }
+        catch {
+            context = undefined;
+        }
+    }
+    const fallbackSnapshot = buildToolOutputSnapshot(options.rawRequest, options.adapterContext.providerProtocol);
+    const snapshot = context
+        ? augmentContextSnapshot(context, fallbackSnapshot)
+        : fallbackSnapshot;
+    recordStage(options.stageRecorder, 'req_inbound_stage3_context_capture', snapshot);
+    return context ?? snapshot;
+}
+export function runChatContextCapture(options) {
+    return runReqInboundStage3ContextCapture({
+        rawRequest: options.rawRequest,
+        adapterContext: options.adapterContext,
+        stageRecorder: options.stageRecorder,
+        captureContext: captureChatContextSnapshot
+    });
+}
+export function captureResponsesContextSnapshot(options) {
+    const context = captureResponsesContext(options.rawRequest, {
+        route: { requestId: options.adapterContext.requestId }
+    });
+    const style = normalizeToolCallIdStyleCandidate(options.adapterContext.toolCallIdStyle);
+    if (style) {
+        context.toolCallIdStyle = style;
+        if (!context.metadata || typeof context.metadata !== 'object') {
+            context.metadata = {};
+        }
+        context.metadata.toolCallIdStyle = style;
+    }
+    try {
+        const built = buildChatRequestFromResponses(options.rawRequest, context);
+        if (built.toolsNormalized) {
+            context.toolsNormalized = built.toolsNormalized;
+        }
+        const captured = collectToolOutputs(options.rawRequest);
+        if (captured.length) {
+            context.__captured_tool_results = captured;
+        }
+    }
+    catch {
+        // best-effort context capture
+    }
+    return context;
+}
+function captureChatContextSnapshot(options) {
+    return buildToolOutputSnapshot(options.rawRequest, options.adapterContext.providerProtocol);
+}
+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 augmentContextSnapshot(context, fallback) {
+    if (!fallback.tool_outputs || Array.isArray(context.tool_outputs)) {
+        return context;
+    }
+    if (!Array.isArray(context.tool_outputs) && Array.isArray(fallback.tool_outputs)) {
+        context.tool_outputs = fallback.tool_outputs;
+    }
+    return context;
+}
+function buildToolOutputSnapshot(payload, providerProtocol) {
+    const snapshot = {
+        providerProtocol: providerProtocol ?? 'unknown'
+    };
+    const toolOutputs = collectToolOutputs(payload);
+    if (toolOutputs.length) {
+        snapshot.tool_outputs = toolOutputs;
+    }
+    return snapshot;
+}
+function collectToolOutputs(payload) {
+    const aggregated = [];
+    const seen = new Set();
+    const append = (entry) => {
+        const id = (entry.tool_call_id || entry.call_id || '').trim();
+        if (!id) {
+            return;
+        }
+        if (seen.has(id)) {
+            return;
+        }
+        seen.add(id);
+        aggregated.push({
+            tool_call_id: entry.tool_call_id ?? entry.call_id,
+            call_id: entry.call_id ?? entry.tool_call_id,
+            output: entry.output,
+            name: entry.name
+        });
+    };
+    for (const record of readArray(payload, 'tool_outputs')) {
+        append(record);
+    }
+    for (const record of readRequiredActionOutputs(payload)) {
+        append(record);
+    }
+    for (const record of readMessageToolOutputs(payload)) {
+        append(record);
+    }
+    for (const record of readMessageContentToolOutputs(payload)) {
+        append(record);
+    }
+    for (const record of readResponsesInputToolOutputs(payload)) {
+        append(record);
+    }
+    return aggregated;
+}
+function readArray(payload, field) {
+    const raw = payload[field];
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    return raw
+        .map((entry) => normalizeToolOutputEntry(entry))
+        .filter((entry) => Boolean(entry));
+}
+function readRequiredActionOutputs(payload) {
+    const required = payload.required_action;
+    if (!required || typeof required !== 'object') {
+        return [];
+    }
+    const submit = required.submit_tool_outputs;
+    if (!submit || typeof submit !== 'object') {
+        return [];
+    }
+    return readArray(submit, 'tool_outputs');
+}
+function readMessageToolOutputs(payload) {
+    const messages = payload.messages;
+    if (!Array.isArray(messages)) {
+        return [];
+    }
+    return messages
+        .map((entry) => {
+        if (!entry || typeof entry !== 'object') {
+            return undefined;
+        }
+        const record = entry;
+        const role = String(record.role || '').toLowerCase();
+        if (role !== 'tool') {
+            return undefined;
+        }
+        return normalizeToolOutputEntry({
+            tool_call_id: record.tool_call_id ?? record.call_id ?? record.id,
+            call_id: record.call_id ?? record.tool_call_id ?? record.id,
+            name: typeof record.name === 'string' ? record.name : undefined,
+            output: record.content ?? record.output
+        });
+    })
+        .filter((entry) => Boolean(entry));
+}
+function readMessageContentToolOutputs(payload) {
+    const messages = payload.messages;
+    if (!Array.isArray(messages)) {
+        return [];
+    }
+    const outputs = [];
+    for (const entry of messages) {
+        if (!entry || typeof entry !== 'object') {
+            continue;
+        }
+        const record = entry;
+        const contentList = record.content;
+        if (!Array.isArray(contentList)) {
+            continue;
+        }
+        for (const block of contentList) {
+            if (!block || typeof block !== 'object') {
+                continue;
+            }
+            const blockRecord = block;
+            const type = typeof blockRecord.type === 'string' ? blockRecord.type.toLowerCase() : '';
+            if (type !== 'tool_result' && type !== 'function_call_output' && type !== 'tool_message') {
+                continue;
+            }
+            const normalized = normalizeToolOutputEntry({
+                tool_call_id: blockRecord.tool_use_id ?? blockRecord.tool_call_id ?? blockRecord.call_id ?? blockRecord.id,
+                call_id: blockRecord.tool_use_id ?? blockRecord.tool_call_id ?? blockRecord.call_id ?? blockRecord.id,
+                name: typeof blockRecord.name === 'string' ? blockRecord.name : undefined,
+                output: blockRecord.content ?? blockRecord.output
+            });
+            if (normalized) {
+                outputs.push(normalized);
+            }
+        }
+    }
+    return outputs;
+}
+function readResponsesInputToolOutputs(payload) {
+    const input = payload.input;
+    if (!Array.isArray(input)) {
+        return [];
+    }
+    return input
+        .map((entry) => {
+        if (!entry || typeof entry !== 'object') {
+            return undefined;
+        }
+        const record = entry;
+        const type = String(record.type || '').toLowerCase();
+        if (type !== 'tool_result' && type !== 'tool_message' && type !== 'function_call_output') {
+            return undefined;
+        }
+        return normalizeToolOutputEntry({
+            tool_call_id: record.tool_call_id ?? record.call_id ?? record.tool_use_id,
+            call_id: record.call_id ?? record.tool_call_id ?? record.tool_use_id,
+            name: typeof record.name === 'string' ? record.name : undefined,
+            output: record.output
+        });
+    })
+        .filter((entry) => Boolean(entry));
+}
+function normalizeToolOutputEntry(entry) {
+    if (!entry || typeof entry !== 'object') {
+        return undefined;
+    }
+    const record = entry;
+    const tool_call_id = typeof record.tool_call_id === 'string' && record.tool_call_id.trim().length
+        ? record.tool_call_id.trim()
+        : undefined;
+    const call_id = typeof record.call_id === 'string' && record.call_id.trim().length
+        ? record.call_id.trim()
+        : undefined;
+    const id = tool_call_id ?? call_id;
+    if (!id) {
+        return undefined;
+    }
+    let output;
+    const rawOutput = 'output' in record ? record.output : record.content;
+    if (typeof rawOutput === 'string') {
+        output = rawOutput;
+    }
+    else if (rawOutput !== undefined) {
+        try {
+            output = JSON.stringify(rawOutput);
+        }
+        catch {
+            output = String(rawOutput);
+        }
+    }
+    const name = typeof record.name === 'string' && record.name.trim().length ? record.name.trim() : undefined;
+    return {
+        tool_call_id,
+        call_id,
+        output,
+        name
+    };
+}

package/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/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/index.js

@@ -0,0 +1,141 @@
+import { standardizedToChatEnvelope } from '../../../../standardized-bridge.js';
+import { validateChatEnvelope } from '../../../../../shared/chat-envelope-validator.js';
+import { recordStage } from '../../../stages/utils.js';
+export async function runReqOutboundStage1SemanticMap(options) {
+    const chatEnvelope = standardizedToChatEnvelope(options.request, {
+        adapterContext: options.adapterContext
+    });
+    applyToolCallIdStyleMetadata(chatEnvelope, options.adapterContext, options.contextSnapshot);
+    if (options.contextSnapshot && options.contextMetadataKey) {
+        const snapshot = options.contextSnapshot;
+        chatEnvelope.metadata[options.contextMetadataKey] = snapshot;
+        attachToolOutputsFromContext(chatEnvelope, snapshot);
+        attachToolsFromContext(chatEnvelope, snapshot);
+    }
+    validateChatEnvelope(chatEnvelope, {
+        stage: 'req_outbound',
+        direction: 'request'
+    });
+    const formatEnvelope = (await options.semanticMapper.fromChat(chatEnvelope, options.adapterContext));
+    recordStage(options.stageRecorder, 'req_outbound_stage1_semantic_map', chatEnvelope);
+    return { chatEnvelope, formatEnvelope };
+}
+function attachToolOutputsFromContext(chatEnvelope, snapshot) {
+    const outputsRaw = snapshot?.tool_outputs;
+    if (!Array.isArray(outputsRaw) || !outputsRaw.length) {
+        return;
+    }
+    const normalized = outputsRaw
+        .map((entry) => normalizeToolOutput(entry))
+        .filter((entry) => Boolean(entry));
+    if (!normalized.length) {
+        return;
+    }
+    const existing = Array.isArray(chatEnvelope.toolOutputs) ? chatEnvelope.toolOutputs.slice() : [];
+    const known = new Set(existing.map((entry) => entry.tool_call_id).filter(Boolean));
+    for (const entry of normalized) {
+        if (entry.tool_call_id && !known.has(entry.tool_call_id)) {
+            existing.push(entry);
+            known.add(entry.tool_call_id);
+        }
+    }
+    if (existing.length) {
+        chatEnvelope.toolOutputs = existing;
+    }
+}
+function attachToolsFromContext(chatEnvelope, snapshot) {
+    if (Array.isArray(chatEnvelope.tools) && chatEnvelope.tools.length) {
+        return;
+    }
+    const normalized = snapshot?.toolsNormalized ?? snapshot?.tools;
+    if (!Array.isArray(normalized) || !normalized.length) {
+        return;
+    }
+    const tools = normalized
+        .map((entry) => normalizeToolDefinition(entry))
+        .filter((entry) => Boolean(entry));
+    if (tools.length) {
+        chatEnvelope.tools = tools;
+    }
+}
+function normalizeToolDefinition(entry) {
+    if (!entry || typeof entry !== 'object') {
+        return undefined;
+    }
+    const record = entry;
+    if (record.type !== 'function') {
+        return undefined;
+    }
+    const fn = record.function;
+    if (!fn || typeof fn !== 'object') {
+        return undefined;
+    }
+    const fnRecord = fn;
+    const name = typeof fnRecord.name === 'string' && fnRecord.name.trim().length ? fnRecord.name.trim() : undefined;
+    if (!name) {
+        return undefined;
+    }
+    return {
+        type: 'function',
+        function: {
+            name,
+            description: typeof fnRecord.description === 'string' ? fnRecord.description : undefined,
+            parameters: (fnRecord.parameters ?? { type: 'object', properties: {} }),
+            strict: typeof fnRecord.strict === 'boolean' ? fnRecord.strict : undefined
+        }
+    };
+}
+function normalizeToolOutput(entry) {
+    if (!entry || typeof entry !== 'object') {
+        return undefined;
+    }
+    const record = entry;
+    const toolCallId = typeof record.tool_call_id === 'string' && record.tool_call_id.trim().length
+        ? record.tool_call_id.trim()
+        : typeof record.call_id === 'string' && record.call_id.trim().length
+            ? record.call_id.trim()
+            : undefined;
+    if (!toolCallId) {
+        return undefined;
+    }
+    let content = '';
+    const rawOutput = 'output' in record ? record.output : record.content;
+    if (typeof rawOutput === 'string') {
+        content = rawOutput;
+    }
+    else if (rawOutput !== undefined) {
+        try {
+            content = JSON.stringify(rawOutput);
+        }
+        catch {
+            content = String(rawOutput);
+        }
+    }
+    const name = typeof record.name === 'string' && record.name.trim().length ? record.name.trim() : undefined;
+    return {
+        tool_call_id: toolCallId,
+        content,
+        name
+    };
+}
+function applyToolCallIdStyleMetadata(chatEnvelope, adapterContext, snapshot) {
+    const metadata = chatEnvelope.metadata || (chatEnvelope.metadata = { context: adapterContext });
+    const hasStyle = typeof metadata.toolCallIdStyle === 'string'
+        && String(metadata.toolCallIdStyle).trim().length > 0;
+    if (hasStyle) {
+        return;
+    }
+    const resolved = selectToolCallIdStyle(adapterContext, snapshot);
+    if (resolved) {
+        metadata.toolCallIdStyle = resolved;
+    }
+}
+function selectToolCallIdStyle(adapterContext, snapshot) {
+    if (adapterContext && typeof adapterContext.toolCallIdStyle === 'string' && adapterContext.toolCallIdStyle.trim().length) {
+        return adapterContext.toolCallIdStyle;
+    }
+    if (snapshot && typeof snapshot.toolCallIdStyle === 'string' && snapshot.toolCallIdStyle.trim().length) {
+        return String(snapshot.toolCallIdStyle);
+    }
+    return undefined;
+}

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage2_format_build/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 ReqOutboundStage2FormatBuildOptions {
+    formatEnvelope: FormatEnvelope<JsonObject>;
+    adapterContext: AdapterContext;
+    formatAdapter: Pick<FormatAdapter, 'buildResponse'>;
+    stageRecorder?: StageRecorder;
+}
+export declare function runReqOutboundStage2FormatBuild(options: ReqOutboundStage2FormatBuildOptions): Promise<JsonObject>;

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage2_format_build/index.js

@@ -0,0 +1,29 @@
+import { recordStage } from '../../../stages/utils.js';
+const PRIVATE_FIELD_PREFIX = '__rcc_';
+export async function runReqOutboundStage2FormatBuild(options) {
+    const payload = (await options.formatAdapter.buildResponse(options.formatEnvelope, options.adapterContext));
+    stripPrivateFields(payload);
+    recordStage(options.stageRecorder, 'req_outbound_stage2_format_build', payload);
+    return payload;
+}
+function stripPrivateFields(value) {
+    if (!value) {
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((entry) => stripPrivateFields(entry));
+        return;
+    }
+    if (typeof value !== 'object') {
+        return;
+    }
+    const record = value;
+    for (const key of Object.keys(record)) {
+        const child = record[key];
+        if (typeof key === 'string' && key.startsWith(PRIVATE_FIELD_PREFIX)) {
+            delete record[key];
+            continue;
+        }
+        stripPrivateFields(child);
+    }
+}

package/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 { runHubChatProcess } 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?: Awaited<ReturnType<typeof runHubChatProcess>>['nodeResult'];
+}
+export declare function runReqProcessStage1ToolGovernance(options: ReqProcessStage1ToolGovernanceOptions): Promise<ReqProcessStage1ToolGovernanceResult>;

package/dist/conversion/hub/pipeline/stages/req_process/req_process_stage1_tool_governance/index.js

@@ -0,0 +1,15 @@
+import { runHubChatProcess } from '../../../../process/chat-process.js';
+import { recordStage } from '../../../stages/utils.js';
+export async function runReqProcessStage1ToolGovernance(options) {
+    const result = await runHubChatProcess({
+        request: options.request,
+        rawPayload: options.rawPayload,
+        metadata: options.metadata,
+        entryEndpoint: options.entryEndpoint,
+        requestId: options.requestId
+    });
+    if (result.processedRequest) {
+        recordStage(options.stageRecorder, 'req_process_stage1_tool_governance', result.processedRequest);
+    }
+    return result;
+}

package/dist/conversion/hub/pipeline/stages/req_process/req_process_stage2_route_select/index.d.ts

@@ -0,0 +1,17 @@
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+import type { ProcessedRequest, StandardizedRequest } from '../../../../types/standardized.js';
+import type { RouterMetadataInput, RoutingDecision, RoutingDiagnostics, TargetMetadata } from '../../../../../../router/virtual-router/types.js';
+import { VirtualRouterEngine } from '../../../../../../router/virtual-router/engine.js';
+export interface ReqProcessStage2RouteSelectOptions {
+    routerEngine: VirtualRouterEngine;
+    request: StandardizedRequest | ProcessedRequest;
+    metadataInput: RouterMetadataInput;
+    normalizedMetadata: Record<string, unknown>;
+    stageRecorder?: StageRecorder;
+}
+export interface ReqProcessStage2RouteSelectResult {
+    target: TargetMetadata;
+    decision: RoutingDecision;
+    diagnostics: RoutingDiagnostics;
+}
+export declare function runReqProcessStage2RouteSelect(options: ReqProcessStage2RouteSelectOptions): ReqProcessStage2RouteSelectResult;

package/dist/conversion/hub/pipeline/stages/req_process/req_process_stage2_route_select/index.js

@@ -0,0 +1,18 @@
+import { recordStage } from '../../../stages/utils.js';
+import { applyTargetMetadata, applyTargetToSubject } from '../../../target-utils.js';
+export function runReqProcessStage2RouteSelect(options) {
+    const previousModel = typeof options.request.model === 'string' ? options.request.model : undefined;
+    const result = options.routerEngine.route(options.request, options.metadataInput);
+    applyTargetMetadata(options.normalizedMetadata, result.target, result.decision.routeName, previousModel);
+    applyTargetToSubject(options.request, result.target, previousModel);
+    recordStage(options.stageRecorder, 'req_process_stage2_route_select', {
+        target: result.target,
+        decision: result.decision,
+        diagnostics: result.diagnostics
+    });
+    return {
+        target: result.target,
+        decision: result.decision,
+        diagnostics: result.diagnostics
+    };
+}

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage1_sse_decode/index.d.ts

@@ -0,0 +1,17 @@
+import type { AdapterContext } from '../../../../types/chat-envelope.js';
+import type { JsonObject } from '../../../../types/json.js';
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+type ProviderProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages' | 'gemini-chat';
+export interface RespInboundStage1SseDecodeOptions {
+    providerProtocol: ProviderProtocol;
+    payload: JsonObject;
+    adapterContext: AdapterContext;
+    wantsStream: boolean;
+    stageRecorder?: StageRecorder;
+}
+export interface RespInboundStage1SseDecodeResult {
+    payload: JsonObject;
+    decodedFromSse: boolean;
+}
+export declare function runRespInboundStage1SseDecode(options: RespInboundStage1SseDecodeOptions): Promise<RespInboundStage1SseDecodeResult>;
+export {};

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage1_sse_decode/index.js

@@ -0,0 +1,63 @@
+import { defaultSseCodecRegistry } from '../../../../../../sse/index.js';
+import { recordStage } from '../../../stages/utils.js';
+export async function runRespInboundStage1SseDecode(options) {
+    const stream = extractSseStream(options.payload);
+    if (!stream) {
+        recordStage(options.stageRecorder, 'resp_inbound_stage1_sse_decode', {
+            streamDetected: false
+        });
+        return { payload: options.payload, decodedFromSse: false };
+    }
+    if (!supportsSseProtocol(options.providerProtocol)) {
+        recordStage(options.stageRecorder, 'resp_inbound_stage1_sse_decode', {
+            streamDetected: true,
+            decoded: false,
+            reason: 'protocol_unsupported',
+            protocol: options.providerProtocol
+        });
+        throw new Error(`[resp_inbound_stage1_sse_decode] Protocol ${options.providerProtocol} does not support SSE decoding`);
+    }
+    try {
+        const codec = defaultSseCodecRegistry.get(options.providerProtocol);
+        const decoded = (await codec.convertSseToJson(stream, {
+            requestId: options.adapterContext.requestId,
+            model: options.adapterContext.modelId
+        }));
+        recordStage(options.stageRecorder, 'resp_inbound_stage1_sse_decode', {
+            streamDetected: true,
+            decoded: true,
+            protocol: options.providerProtocol
+        });
+        return { payload: decoded, decodedFromSse: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        recordStage(options.stageRecorder, 'resp_inbound_stage1_sse_decode', {
+            streamDetected: true,
+            decoded: false,
+            protocol: options.providerProtocol,
+            error: message
+        });
+        throw new Error(`[resp_inbound_stage1_sse_decode] Failed to decode SSE payload for protocol ${options.providerProtocol}: ${message}`);
+    }
+}
+function supportsSseProtocol(protocol) {
+    return protocol === 'openai-chat' || protocol === 'openai-responses' || protocol === 'anthropic-messages' || protocol === 'gemini-chat';
+}
+function extractSseStream(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return undefined;
+    }
+    const direct = payload.__sse_responses || payload.__sse_stream;
+    if (direct && typeof direct.pipe === 'function') {
+        return direct;
+    }
+    const nested = payload.data;
+    if (nested && typeof nested === 'object') {
+        const inner = nested.__sse_responses || nested.__sse_stream;
+        if (inner && typeof inner.pipe === 'function') {
+            return inner;
+        }
+    }
+    return undefined;
+}

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage2_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 RespInboundStage2FormatParseOptions {
+    adapterContext: AdapterContext;
+    payload: JsonObject;
+    formatAdapter: Pick<FormatAdapter, 'parseResponse'>;
+    stageRecorder?: StageRecorder;
+}
+export declare function runRespInboundStage2FormatParse(options: RespInboundStage2FormatParseOptions): Promise<FormatEnvelope<JsonObject>>;

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage2_format_parse/index.js

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

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage3_semantic_map/index.d.ts

@@ -0,0 +1,12 @@
+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 { StageRecorder } from '../../../../format-adapters/index.js';
+import type { ResponseMapper, ChatCompletionLike } from '../../../../response/response-mappers.js';
+export interface RespInboundStage3SemanticMapOptions {
+    adapterContext: AdapterContext;
+    formatEnvelope: FormatEnvelope<JsonObject>;
+    mapper: ResponseMapper;
+    stageRecorder?: StageRecorder;
+}
+export declare function runRespInboundStage3SemanticMap(options: RespInboundStage3SemanticMapOptions): Promise<ChatCompletionLike>;

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage3_semantic_map/index.js

@@ -0,0 +1,6 @@
+import { recordStage } from '../../../stages/utils.js';
+export async function runRespInboundStage3SemanticMap(options) {
+    const chatResponse = await options.mapper.toChatCompletion(options.formatEnvelope, options.adapterContext);
+    recordStage(options.stageRecorder, 'resp_inbound_stage3_semantic_map', chatResponse);
+    return chatResponse;
+}