@jsonstudio/llms 0.4.6 → 0.6.2

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.d.ts

@@ -0,0 +1,13 @@
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+import type { JsonObject } from '../../../../types/json.js';
+import type { AdapterContext } from '../../../../types/chat-envelope.js';
+type ClientProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages';
+export interface RespOutboundStage1ClientRemapOptions {
+    payload: JsonObject;
+    clientProtocol: ClientProtocol;
+    requestId: string;
+    adapterContext?: AdapterContext;
+    stageRecorder?: StageRecorder;
+}
+export declare function runRespOutboundStage1ClientRemap(options: RespOutboundStage1ClientRemapOptions): JsonObject;
+export {};

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js

@@ -0,0 +1,43 @@
+import { buildAnthropicResponseFromChat } from '../../../../response/response-runtime.js';
+import { buildResponsesPayloadFromChat } from '../../../../../responses/responses-openai-bridge.js';
+import { recordStage } from '../../../stages/utils.js';
+export function runRespOutboundStage1ClientRemap(options) {
+    let clientPayload;
+    if (options.clientProtocol === 'openai-chat') {
+        clientPayload = options.payload;
+    }
+    else if (options.clientProtocol === 'anthropic-messages') {
+        clientPayload = buildAnthropicResponseFromChat(options.payload, {
+            aliasMap: resolveAliasMapFromContext(options.adapterContext)
+        });
+    }
+    else {
+        clientPayload = buildResponsesPayloadFromChat(options.payload, {
+            requestId: options.requestId
+        });
+    }
+    recordStage(options.stageRecorder, 'resp_outbound_stage1_client_remap', clientPayload);
+    return clientPayload;
+}
+function resolveAliasMapFromContext(adapterContext) {
+    if (!adapterContext) {
+        return undefined;
+    }
+    const candidate = adapterContext.anthropicToolNameMap;
+    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+        return undefined;
+    }
+    const map = {};
+    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;
+        }
+        map[trimmedKey] = trimmedValue;
+    }
+    return Object.keys(map).length ? map : undefined;
+}

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.d.ts

@@ -0,0 +1,17 @@
+import type { Readable } from 'node:stream';
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+import type { JsonObject } from '../../../../types/json.js';
+type ClientProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages';
+export interface RespOutboundStage2SseStreamOptions {
+    clientPayload: JsonObject;
+    clientProtocol: ClientProtocol;
+    requestId: string;
+    wantsStream: boolean;
+    stageRecorder?: StageRecorder;
+}
+export interface RespOutboundStage2SseStreamResult {
+    body?: JsonObject;
+    stream?: Readable;
+}
+export declare function runRespOutboundStage2SseStream(options: RespOutboundStage2SseStreamOptions): Promise<RespOutboundStage2SseStreamResult>;
+export {};

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.js

@@ -0,0 +1,22 @@
+import { defaultSseCodecRegistry } from '../../../../../../sse/index.js';
+import { recordStage } from '../../../stages/utils.js';
+export async function runRespOutboundStage2SseStream(options) {
+    if (!options.wantsStream) {
+        recordStage(options.stageRecorder, 'resp_outbound_stage2_sse_stream', {
+            passthrough: false,
+            protocol: options.clientProtocol,
+            payload: options.clientPayload
+        });
+        return { body: options.clientPayload };
+    }
+    const codec = defaultSseCodecRegistry.get(options.clientProtocol);
+    const stream = await codec.convertJsonToSse(options.clientPayload, {
+        requestId: options.requestId
+    });
+    recordStage(options.stageRecorder, 'resp_outbound_stage2_sse_stream', {
+        passthrough: false,
+        protocol: options.clientProtocol,
+        payload: options.clientPayload
+    });
+    return { stream };
+}

package/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage1_tool_governance/index.d.ts

@@ -0,0 +1,16 @@
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+import type { JsonObject } from '../../../../types/json.js';
+import type { ChatCompletionLike } from '../../../../response/response-mappers.js';
+type ClientProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages';
+export interface RespProcessStage1ToolGovernanceOptions {
+    payload: ChatCompletionLike;
+    entryEndpoint: string;
+    requestId: string;
+    clientProtocol: ClientProtocol;
+    stageRecorder?: StageRecorder;
+}
+export interface RespProcessStage1ToolGovernanceResult {
+    governedPayload: JsonObject;
+}
+export declare function runRespProcessStage1ToolGovernance(options: RespProcessStage1ToolGovernanceOptions): Promise<RespProcessStage1ToolGovernanceResult>;
+export {};

package/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage1_tool_governance/index.js

@@ -0,0 +1,19 @@
+import { runChatResponseToolFilters } from '../../../../../shared/tool-filter-pipeline.js';
+import { ToolGovernanceEngine } from '../../../../tool-governance/index.js';
+import { recordStage } from '../../../stages/utils.js';
+const toolGovernanceEngine = new ToolGovernanceEngine();
+export async function runRespProcessStage1ToolGovernance(options) {
+    const filtered = await runChatResponseToolFilters(options.payload, {
+        entryEndpoint: options.entryEndpoint,
+        requestId: options.requestId,
+        profile: 'openai-chat'
+    });
+    const { payload: governed, summary } = toolGovernanceEngine.governResponse(filtered, options.clientProtocol);
+    recordStage(options.stageRecorder, 'resp_process_stage1_tool_governance', {
+        summary,
+        applied: summary?.applied,
+        filteredPayload: filtered,
+        governedPayload: governed
+    });
+    return { governedPayload: governed };
+}

package/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage2_finalize/index.d.ts

@@ -0,0 +1,17 @@
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+import type { JsonObject } from '../../../../types/json.js';
+import type { ChatReasoningMode } from '../../../../../shared/openai-finalizer.js';
+import type { ProcessedRequest } from '../../../../types/standardized.js';
+export interface RespProcessStage2FinalizeOptions {
+    payload: JsonObject;
+    entryEndpoint: string;
+    requestId: string;
+    wantsStream: boolean;
+    reasoningMode: ChatReasoningMode;
+    stageRecorder?: StageRecorder;
+}
+export interface RespProcessStage2FinalizeResult {
+    finalizedPayload: JsonObject;
+    processedRequest: ProcessedRequest;
+}
+export declare function runRespProcessStage2Finalize(options: RespProcessStage2FinalizeOptions): Promise<RespProcessStage2FinalizeResult>;

package/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage2_finalize/index.js

@@ -0,0 +1,19 @@
+import { finalizeOpenAIChatResponse } from '../../../../../shared/openai-finalizer.js';
+import { buildProcessedRequestFromChatResponse } from '../../../../response/chat-response-utils.js';
+import { recordStage } from '../../../stages/utils.js';
+export async function runRespProcessStage2Finalize(options) {
+    const finalized = (await finalizeOpenAIChatResponse(options.payload, {
+        requestId: options.requestId,
+        endpoint: options.entryEndpoint,
+        stream: options.wantsStream,
+        reasoningMode: options.reasoningMode
+    }));
+    const processedRequest = buildProcessedRequestFromChatResponse(finalized, {
+        stream: options.wantsStream
+    });
+    recordStage(options.stageRecorder, 'resp_process_stage2_finalize', {
+        model: finalized.model,
+        stream: options.wantsStream
+    });
+    return { finalizedPayload: finalized, processedRequest };
+}

package/dist/conversion/hub/pipeline/stages/utils.d.ts

@@ -0,0 +1,2 @@
+import type { StageRecorder } from '../../format-adapters/index.js';
+export declare function recordStage(recorder: StageRecorder | undefined, stageId: string, payload: unknown): void;

package/dist/conversion/hub/pipeline/stages/utils.js

@@ -0,0 +1,11 @@
+export function recordStage(recorder, stageId, payload) {
+    if (!recorder) {
+        return;
+    }
+    try {
+        recorder.record(stageId, (payload ?? {}));
+    }
+    catch {
+        // Snapshot failures should not block the pipeline.
+    }
+}

package/dist/conversion/hub/pipeline/target-utils.d.ts

@@ -0,0 +1,5 @@
+import type { ProcessedRequest, StandardizedRequest } from '../types/standardized.js';
+import type { TargetMetadata } from '../../../router/virtual-router/types.js';
+export declare function applyTargetMetadata(metadata: Record<string, unknown> | undefined, target: TargetMetadata, routeName?: string, originalModel?: string): void;
+export declare function applyTargetToSubject(subject: StandardizedRequest | ProcessedRequest, target: TargetMetadata, originalModel?: string): void;
+export declare function extractModelFromTarget(target: TargetMetadata): string | null;

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

@@ -0,0 +1,87 @@
+export function applyTargetMetadata(metadata, target, routeName, originalModel) {
+    if (!metadata || typeof metadata !== 'object') {
+        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;
+        }
+    }
+    if (typeof target.modelId === 'string' && target.modelId.trim()) {
+        metadata.assignedModelId = target.modelId.trim();
+    }
+}
+export function applyTargetToSubject(subject, target, originalModel) {
+    if (!subject || typeof subject !== 'object') {
+        return;
+    }
+    const newModel = extractModelFromTarget(target);
+    if (!newModel) {
+        return;
+    }
+    subject.model = newModel;
+    if (subject.parameters && typeof subject.parameters === 'object') {
+        subject.parameters = {
+            ...subject.parameters,
+            model: newModel
+        };
+    }
+    else {
+        subject.parameters = { model: newModel };
+    }
+    const metadata = (subject.metadata && typeof subject.metadata === 'object'
+        ? subject.metadata
+        : { originalEndpoint: '/v1/chat/completions' });
+    metadata.providerKey = target.providerKey;
+    metadata.providerType = target.providerType;
+    metadata.processMode = target.processMode || 'chat';
+    subject.metadata = metadata;
+    const subjectMeta = 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;
+        }
+    }
+    subjectMeta.assignedModelId = newModel;
+}
+export function extractModelFromTarget(target) {
+    if (!target || typeof target.providerKey !== 'string') {
+        return null;
+    }
+    if (typeof target.modelId === 'string' && target.modelId.trim()) {
+        return target.modelId.trim();
+    }
+    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 firstDot = target.providerKey.indexOf('.');
+    if (firstDot <= 0 || firstDot === target.providerKey.length - 1) {
+        return null;
+    }
+    const fallback = target.providerKey.slice(firstDot + 1).trim();
+    return fallback.length ? fallback : null;
+}

package/dist/conversion/hub/process/chat-process.js

@@ -29,7 +29,7 @@ async function applyRequestToolGovernance(request, context) {
     const providerProtocol = readString(metadata.providerProtocol) ?? readString(metadata.provider) ?? 'openai-chat';
     const metadataToolHints = metadata.toolFilterHints;
     const metadataStreamFlag = metadata.stream;
-    const metadataStream = typeof metadataStreamFlag === 'boolean' ? metadataStreamFlag : request.parameters?.stream === true;
+    const inboundStreamIntent = typeof metadataStreamFlag === 'boolean' ? metadataStreamFlag : request.parameters?.stream === true;
     const shaped = {
         model: request.model,
         messages: deepClone(request.messages),
@@ -43,10 +43,11 @@ async function applyRequestToolGovernance(request, context) {
         requestId: context.requestId,
         model: request.model,
         profile: providerProtocol,
-        stream: metadataStream,
+        stream: inboundStreamIntent,
         toolFilterHints: metadataToolHints
     });
     const governed = normalizeRecord(governedPayload);
+    const providerStreamIntent = typeof governed.stream === 'boolean' ? governed.stream : undefined;
     const merged = {
         ...request,
         messages: Array.isArray(governed.messages)
@@ -60,14 +61,19 @@ async function applyRequestToolGovernance(request, context) {
         metadata: {
             ...request.metadata,
             toolChoice: readToolChoice(governed.tool_choice),
-            originalStream: request.parameters?.stream === true,
-            stream: typeof governed.stream === 'boolean'
-                ? governed.stream
-                : request.parameters?.stream,
+            originalStream: inboundStreamIntent,
+            stream: inboundStreamIntent,
+            providerStream: providerStreamIntent,
             governedTools: governed.tools !== undefined,
             governanceTimestamp: Date.now()
         }
     };
+    if (typeof inboundStreamIntent === 'boolean') {
+        merged.metadata = {
+            ...merged.metadata,
+            inboundStream: inboundStreamIntent
+        };
+    }
     if (typeof governed.stream === 'boolean') {
         merged.parameters = {
             ...merged.parameters,
@@ -220,17 +226,17 @@ function castCustomTool(tool) {
 }
 function castToolParameters(value) {
     if (isRecord(value)) {
-        const properties = value.properties && typeof value.properties === 'object'
-            ? value.properties
-            : {};
-        const required = Array.isArray(value.required) ? value.required : undefined;
-        const additionalProperties = typeof value.additionalProperties === 'boolean' ? value.additionalProperties : undefined;
-        return {
-            type: 'object',
-            properties,
-            required,
-            additionalProperties
-        };
+        const cloned = deepClone(value);
+        if (cloned && typeof cloned === 'object' && !Array.isArray(cloned)) {
+            const schema = cloned;
+            if (!('type' in schema)) {
+                schema.type = 'object';
+            }
+            if (!isRecord(schema.properties)) {
+                schema.properties = {};
+            }
+            return schema;
+        }
     }
     return {
         type: 'object',

package/dist/conversion/hub/response/provider-response.js

@@ -1,28 +1,31 @@
-import { Readable } from 'node:stream';
-import { runChatResponseToolFilters } from '../../shared/tool-filter-pipeline.js';
-import { finalizeOpenAIChatResponse } from '../../shared/openai-finalizer.js';
-import { buildProcessedRequestFromChatResponse } from './chat-response-utils.js';
-import { buildAnthropicResponseFromChat } from './response-runtime.js';
-import { buildResponsesPayloadFromChat } from '../../responses/responses-openai-bridge.js';
-import { defaultSseCodecRegistry } from '../../../sse/registry/sse-codec-registry.js';
-import { ToolGovernanceEngine } from '../tool-governance/index.js';
 import { ChatFormatAdapter } from '../format-adapters/chat-format-adapter.js';
 import { ResponsesFormatAdapter } from '../format-adapters/responses-format-adapter.js';
 import { AnthropicFormatAdapter } from '../format-adapters/anthropic-format-adapter.js';
 import { GeminiFormatAdapter } from '../format-adapters/gemini-format-adapter.js';
 import { OpenAIChatResponseMapper, ResponsesResponseMapper, AnthropicResponseMapper, GeminiResponseMapper } from './response-mappers.js';
-const STAGES = {
-    formatParse: 'resp_format_parse',
-    semanticMap: 'resp_semantic_map_to_chat',
-    governance: 'resp_tool_governance',
-    finalize: 'resp_finalize',
-    processed: 'resp_processed_request',
-    clientMap: 'resp_client_map',
-    sseDecode: 'resp_sse_decode',
-    ssePre: 'resp_sse_output_pre',
-    ssePost: 'resp_sse_output_post'
-};
-const toolGovernanceEngine = new ToolGovernanceEngine();
+import { runRespInboundStage1SseDecode } from '../pipeline/stages/resp_inbound/resp_inbound_stage1_sse_decode/index.js';
+import { runRespInboundStage2FormatParse } from '../pipeline/stages/resp_inbound/resp_inbound_stage2_format_parse/index.js';
+import { runRespInboundStage3SemanticMap } from '../pipeline/stages/resp_inbound/resp_inbound_stage3_semantic_map/index.js';
+import { runRespProcessStage1ToolGovernance } from '../pipeline/stages/resp_process/resp_process_stage1_tool_governance/index.js';
+import { runRespProcessStage2Finalize } from '../pipeline/stages/resp_process/resp_process_stage2_finalize/index.js';
+import { runRespOutboundStage1ClientRemap } from '../pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js';
+import { runRespOutboundStage2SseStream } from '../pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.js';
+function resolveChatReasoningMode(entryEndpoint) {
+    const envRaw = (process.env.ROUTECODEX_CHAT_REASONING_MODE || process.env.RCC_CHAT_REASONING_MODE || '').trim().toLowerCase();
+    const map = {
+        keep: 'keep',
+        drop: 'drop',
+        discard: 'drop',
+        text: 'append_to_content',
+        append: 'append_to_content',
+        append_text: 'append_to_content',
+        append_to_content: 'append_to_content'
+    };
+    if (envRaw && map[envRaw]) {
+        return map[envRaw];
+    }
+    return 'keep';
+}
 const PROVIDER_RESPONSE_REGISTRY = {
     'openai-chat': {
         protocol: 'openai-chat',
@@ -45,33 +48,6 @@ const PROVIDER_RESPONSE_REGISTRY = {
         createMapper: () => new GeminiResponseMapper()
     }
 };
-function recordStage(recorder, stage, payload) {
-    if (!recorder)
-        return;
-    try {
-        recorder.record(stage, payload);
-    }
-    catch {
-        /* ignore */
-    }
-}
-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;
-}
 function resolveClientProtocol(entryEndpoint) {
     const lowered = (entryEndpoint || '').toLowerCase();
     if (lowered.includes('/v1/responses'))
@@ -80,14 +56,6 @@ function resolveClientProtocol(entryEndpoint) {
         return 'anthropic-messages';
     return 'openai-chat';
 }
-async function maybeCreateSseStream(protocol, payload, requestId) {
-    const codec = defaultSseCodecRegistry.get(protocol);
-    if (!codec) {
-        const stream = new Readable({ read() { this.push(null); } });
-        return stream;
-    }
-    return codec.convertJsonToSse(payload, { requestId });
-}
 function supportsSseProtocol(protocol) {
     return protocol === 'openai-chat' || protocol === 'openai-responses' || protocol === 'anthropic-messages' || protocol === 'gemini-chat';
 }
@@ -117,86 +85,65 @@ function applyModelOverride(payload, model) {
 }
 export async function convertProviderResponse(options) {
     const clientProtocol = resolveClientProtocol(options.entryEndpoint);
-    const passthroughStream = extractSseStream(options.providerResponse);
-    const protocolsMatch = clientProtocol === options.providerProtocol;
-    const modelHint = typeof options.context.modelId === 'string' ? options.context.modelId : undefined;
     const displayModel = extractDisplayModel(options.context);
-    let providerPayload = options.providerResponse;
-    if (passthroughStream) {
-        if (options.wantsStream && protocolsMatch && supportsSseProtocol(clientProtocol)) {
-            recordStage(options.stageRecorder, STAGES.clientMap, { passthrough: true, protocol: clientProtocol });
-            return { __sse_responses: passthroughStream };
-        }
-        if (supportsSseProtocol(options.providerProtocol)) {
-            try {
-                const codec = defaultSseCodecRegistry.get(options.providerProtocol);
-                const decoded = await codec.convertSseToJson(passthroughStream, {
-                    requestId: options.context.requestId,
-                    model: modelHint
-                });
-                if (decoded && typeof decoded === 'object') {
-                    providerPayload = decoded;
-                    recordStage(options.stageRecorder, STAGES.sseDecode, { protocol: options.providerProtocol });
-                }
-            }
-            catch (error) {
-                recordStage(options.stageRecorder, STAGES.sseDecode, {
-                    protocol: options.providerProtocol,
-                    error: error instanceof Error ? error.message : String(error)
-                });
-            }
-        }
-    }
     const plan = PROVIDER_RESPONSE_REGISTRY[options.providerProtocol];
     if (!plan) {
         throw new Error(`Unknown provider protocol: ${options.providerProtocol}`);
     }
+    const inboundStage1 = await runRespInboundStage1SseDecode({
+        providerProtocol: options.providerProtocol,
+        payload: options.providerResponse,
+        adapterContext: options.context,
+        wantsStream: options.wantsStream,
+        stageRecorder: options.stageRecorder
+    });
     const formatAdapter = plan.createFormatAdapter();
     const mapper = plan.createMapper();
-    const formatEnvelope = await formatAdapter.parseResponse(providerPayload, options.context);
-    recordStage(options.stageRecorder, STAGES.formatParse, formatEnvelope);
-    const chatResponse = await mapper.toChatCompletion(formatEnvelope, options.context);
-    recordStage(options.stageRecorder, STAGES.semanticMap, chatResponse);
-    const filtered = await runChatResponseToolFilters(chatResponse, {
+    const formatEnvelope = await runRespInboundStage2FormatParse({
+        adapterContext: options.context,
+        payload: inboundStage1.payload,
+        formatAdapter,
+        stageRecorder: options.stageRecorder
+    });
+    const chatResponse = await runRespInboundStage3SemanticMap({
+        adapterContext: options.context,
+        formatEnvelope,
+        mapper,
+        stageRecorder: options.stageRecorder
+    });
+    const governanceResult = await runRespProcessStage1ToolGovernance({
+        payload: chatResponse,
         entryEndpoint: options.entryEndpoint,
         requestId: options.context.requestId,
-        profile: 'openai-chat'
-    });
-    const { payload: governed, summary: responseGovernance } = toolGovernanceEngine.governResponse(filtered, clientProtocol);
-    recordStage(options.stageRecorder, STAGES.governance, {
-        ...governed,
-        __toolGovernanceSummary: responseGovernance
+        clientProtocol,
+        stageRecorder: options.stageRecorder
     });
-    const finalized = await finalizeOpenAIChatResponse(governed, {
+    const finalizeResult = await runRespProcessStage2Finalize({
+        payload: governanceResult.governedPayload,
+        entryEndpoint: options.entryEndpoint,
         requestId: options.context.requestId,
-        endpoint: options.entryEndpoint,
-        stream: options.wantsStream
+        wantsStream: options.wantsStream,
+        reasoningMode: resolveChatReasoningMode(options.entryEndpoint),
+        stageRecorder: options.stageRecorder
     });
-    applyModelOverride(finalized, displayModel);
-    recordStage(options.stageRecorder, STAGES.finalize, finalized);
-    const processedRequest = buildProcessedRequestFromChatResponse(finalized, {
-        stream: options.wantsStream
+    applyModelOverride(finalizeResult.finalizedPayload, displayModel);
+    const clientPayload = runRespOutboundStage1ClientRemap({
+        payload: finalizeResult.finalizedPayload,
+        clientProtocol,
+        requestId: options.context.requestId,
+        adapterContext: options.context,
+        stageRecorder: options.stageRecorder
     });
-    recordStage(options.stageRecorder, STAGES.processed, processedRequest);
-    let clientPayload;
-    if (clientProtocol === 'openai-chat') {
-        clientPayload = finalized;
-    }
-    else if (clientProtocol === 'anthropic-messages') {
-        clientPayload = buildAnthropicResponseFromChat(finalized);
-    }
-    else {
-        clientPayload = buildResponsesPayloadFromChat(finalized, {
-            requestId: options.context.requestId
-        });
-    }
     applyModelOverride(clientPayload, displayModel);
-    recordStage(options.stageRecorder, STAGES.clientMap, clientPayload);
-    if (!options.wantsStream) {
-        return { body: clientPayload, format: clientProtocol };
+    const outbound = await runRespOutboundStage2SseStream({
+        clientPayload,
+        clientProtocol,
+        requestId: options.context.requestId,
+        wantsStream: options.wantsStream,
+        stageRecorder: options.stageRecorder
+    });
+    if (outbound.stream) {
+        return { __sse_responses: outbound.stream, format: clientProtocol };
     }
-    recordStage(options.stageRecorder, STAGES.ssePre, { protocol: clientProtocol });
-    const sseStream = await maybeCreateSseStream(clientProtocol, clientPayload, options.context.requestId);
-    recordStage(options.stageRecorder, STAGES.ssePost, {});
-    return { __sse_responses: sseStream, format: clientProtocol };
+    return { body: clientPayload, format: clientProtocol };
 }

package/dist/conversion/hub/response/response-mappers.d.ts

@@ -0,0 +1,19 @@
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { JsonObject } from '../types/json.js';
+export type ChatCompletionLike = JsonObject;
+export interface ResponseMapper {
+    toChatCompletion(format: FormatEnvelope, ctx: AdapterContext): Promise<ChatCompletionLike> | ChatCompletionLike;
+}
+export declare class OpenAIChatResponseMapper implements ResponseMapper {
+    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
+}
+export declare class ResponsesResponseMapper implements ResponseMapper {
+    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
+}
+export declare class AnthropicResponseMapper implements ResponseMapper {
+    toChatCompletion(format: FormatEnvelope, ctx: AdapterContext): ChatCompletionLike;
+}
+export declare class GeminiResponseMapper implements ResponseMapper {
+    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
+}

package/dist/conversion/hub/response/response-mappers.js

@@ -12,8 +12,9 @@ export class ResponsesResponseMapper {
     }
 }
 export class AnthropicResponseMapper {
-    toChatCompletion(format, _ctx) {
-        return buildOpenAIChatFromAnthropicMessage(format.payload ?? {});
+    toChatCompletion(format, ctx) {
+        const aliasMap = extractAnthropicAliasMap(ctx);
+        return buildOpenAIChatFromAnthropicMessage(format.payload ?? {}, { aliasMap });
     }
 }
 export class GeminiResponseMapper {
@@ -21,3 +22,22 @@ export class GeminiResponseMapper {
         return buildOpenAIChatFromGeminiResponse(format.payload ?? {});
     }
 }
+function extractAnthropicAliasMap(ctx) {
+    const candidate = ctx?.anthropicToolNameMap;
+    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;
+}