@jsonstudio/llms 0.6.2172 → 0.6.3214

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

@@ -1,31 +1,8 @@
 import { defaultSseCodecRegistry } from '../../../../../../sse/index.js';
 import { recordStage } from '../../../stages/utils.js';
-import { ProviderProtocolError } from '../../../../../shared/errors.js';
-function extractSseWrapperError(payload) {
-    return findSseWrapperError(payload, 2);
-}
-function findSseWrapperError(record, depth) {
-    if (!record || typeof record !== 'object' || depth < 0) {
-        return undefined;
-    }
-    const mode = record.mode;
-    const errVal = record.error;
-    if (mode === 'sse' && typeof errVal === 'string' && errVal.trim()) {
-        return errVal.trim();
-    }
-    const nestedKeys = ['body', 'data', 'payload', 'response'];
-    for (const key of nestedKeys) {
-        const nested = record[key];
-        if (!nested || typeof nested !== 'object' || Array.isArray(nested)) {
-            continue;
-        }
-        const found = findSseWrapperError(nested, depth - 1);
-        if (found) {
-            return found;
-        }
-    }
-    return undefined;
-}
+import { ProviderProtocolError } from '../../../../../provider-protocol-error.js';
+import { extractContextLengthDiagnosticsWithNative, extractSseWrapperErrorWithNative, isContextLengthExceededSignalWithNative, parseJsonObjectCandidateWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+import { tryDecodeJsonBodyFromStream } from './stream-json-sniffer.js';
 function resolveProviderType(protocol) {
     if (protocol === 'openai-chat')
         return 'openai';
@@ -37,66 +14,12 @@ function resolveProviderType(protocol) {
         return 'gemini';
     return undefined;
 }
-function readFiniteNumber(value) {
-    if (typeof value === 'number' && Number.isFinite(value)) {
-        return Math.floor(value);
-    }
-    if (typeof value === 'string') {
-        const trimmed = value.trim();
-        if (!trimmed.length) {
-            return undefined;
-        }
-        const parsed = Number(trimmed);
-        if (Number.isFinite(parsed)) {
-            return Math.floor(parsed);
-        }
-    }
-    return undefined;
-}
-function readObject(value) {
+function readObjectFallback(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         return undefined;
     }
     return value;
 }
-function extractContextLengthDiagnostics(adapterContext) {
-    const ctx = readObject(adapterContext);
-    if (!ctx) {
-        return {};
-    }
-    const runtimeNode = readObject(ctx.__rt);
-    const targetNode = readObject(ctx.target);
-    const estimatedPromptTokens = readFiniteNumber(ctx.estimatedInputTokens) ??
-        readFiniteNumber(ctx.requestTokens) ??
-        readFiniteNumber(ctx.reqTokens) ??
-        readFiniteNumber(runtimeNode?.estimatedInputTokens) ??
-        readFiniteNumber(runtimeNode?.requestTokens) ??
-        readFiniteNumber(runtimeNode?.reqTokens);
-    const maxContextTokens = readFiniteNumber(targetNode?.maxContextTokens) ??
-        readFiniteNumber(ctx.maxContextTokens) ??
-        readFiniteNumber(runtimeNode?.maxContextTokens);
-    return {
-        ...(typeof estimatedPromptTokens === 'number' ? { estimatedPromptTokens } : {}),
-        ...(typeof maxContextTokens === 'number' ? { maxContextTokens } : {})
-    };
-}
-function isContextLengthExceededSignal(args) {
-    const code = typeof args.code === 'string' ? args.code.trim().toLowerCase() : '';
-    if (code.includes('context_length_exceeded')) {
-        return true;
-    }
-    const message = args.message.toLowerCase();
-    if (message.includes('context_length_exceeded') || message.includes('达到对话长度上限') || message.includes('对话长度上限')) {
-        return true;
-    }
-    const finishReason = typeof args.context?.errorData === 'object' &&
-        args.context.errorData &&
-        !Array.isArray(args.context.errorData) &&
-        typeof args.context.errorData.finish_reason === 'string'
-        ? String(args.context.errorData.finish_reason).trim().toLowerCase()
-        : '';
-    return finishReason === 'context_length_exceeded';
-}
 export async function runRespInboundStage1SseDecode(options) {
     // Transport compatibility: some HTTP clients return JSON bodies as plain strings when the upstream
     // mislabels `Content-Type`. Best-effort parse JSON text early so downstream format adapters and
@@ -111,7 +34,7 @@ export async function runRespInboundStage1SseDecode(options) {
         });
         return { payload: maybeJsonText, decodedFromSse: false };
     }
-    const wrapperError = extractSseWrapperError(options.payload);
+    const wrapperError = extractSseWrapperErrorWithNative(options.payload);
     const stream = extractSseStream(options.payload);
     // 某些 mock-provider / 捕获样本在 SSE 连接被异常终止时会携带 error 标记，
     // 即使仍保留 __sse_responses 流，也应视为上游异常并终止。
@@ -187,13 +110,9 @@ export async function runRespInboundStage1SseDecode(options) {
         const message = error instanceof Error ? error.message : String(error);
         const errRecord = error;
         const upstreamCode = typeof errRecord.code === 'string' ? errRecord.code : undefined;
-        const upstreamContext = readObject(errRecord.context);
-        const contextLengthExceeded = isContextLengthExceededSignal({
-            code: upstreamCode,
-            message,
-            context: upstreamContext
-        });
-        const diagnostics = extractContextLengthDiagnostics(options.adapterContext);
+        const upstreamContext = readObjectFallback(errRecord.context);
+        const contextLengthExceeded = isContextLengthExceededSignalWithNative(upstreamCode, message, upstreamContext);
+        const diagnostics = extractContextLengthDiagnosticsWithNative(options.adapterContext);
         recordStage(options.stageRecorder, 'chat_process.resp.stage1.sse_decode', {
             streamDetected: true,
             decoded: false,
@@ -223,118 +142,11 @@ function supportsSseProtocol(protocol) {
     return protocol === 'openai-chat' || protocol === 'openai-responses' || protocol === 'anthropic-messages' || protocol === 'gemini-chat';
 }
 function tryDecodeJsonBodyFromText(payload) {
-    try {
-        if (typeof payload !== 'string') {
-            return null;
-        }
-        // Normalize common prefixes / wrappers from OpenAI-compatible upstreams.
-        let text = payload.trimStart();
-        // anti-XSSI prefix: ")]}',\n{...}"
-        text = text.replace(/^\)\]\}',?\s*/u, '');
-        // single-line SSE-like wrapper sometimes returned as plain text
-        text = text.replace(/^data:\s*/iu, '');
-        const looksLikeJson = text.startsWith('{') || text.startsWith('[');
-        if (!looksLikeJson) {
-            return null;
-        }
-        // Guard: avoid unbounded parsing for pathological payloads.
-        if (text.length > 10 * 1024 * 1024) {
-            return null;
-        }
-        const parsed = JSON.parse(text);
-        return (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) ? parsed : null;
-    }
-    catch {
-        return null;
-    }
-}
-async function tryDecodeJsonBodyFromStream(stream) {
-    // Peek the first chunk; if it looks like JSON (starts with `{` or `[`), consume full body and parse.
-    const iterator = stream[Symbol.asyncIterator]();
-    const first = await iterator.next();
-    if (first.done || first.value == null) {
+    if (typeof payload !== 'string') {
         return null;
     }
-    const consumedChunks = [first.value];
-    const firstChunk = first.value;
-    let prefix = chunkToUtf8(firstChunk).trimStart();
-    prefix = prefix.replace(/^\)\]\}',?\s*/u, '');
-    prefix = prefix.replace(/^data:\s*/iu, '');
-    const looksLikeJson = prefix.startsWith('{') || prefix.startsWith('[');
-    if (!looksLikeJson) {
-        rewindStreamWithConsumedChunks(stream, consumedChunks, iterator);
-        return null;
-    }
-    let body = chunkToUtf8(firstChunk);
-    while (true) {
-        const next = await iterator.next();
-        if (next.done)
-            break;
-        consumedChunks.push(next.value);
-        body += chunkToUtf8(next.value);
-        // Guard: avoid unbounded buffering if the upstream is actually SSE but starts with whitespace.
-        if (body.length > 1024 * 1024) {
-            rewindStreamWithConsumedChunks(stream, consumedChunks, iterator);
-            return null;
-        }
-    }
-    try {
-        const parsed = JSON.parse(body);
-        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-            return parsed;
-        }
-        rewindStreamWithConsumedChunks(stream, consumedChunks, iterator);
-        return null;
-    }
-    catch {
-        rewindStreamWithConsumedChunks(stream, consumedChunks, iterator);
-        return null;
-    }
-}
-function chunkToUtf8(chunk) {
-    if (typeof chunk === 'string') {
-        return chunk;
-    }
-    if (Buffer.isBuffer(chunk)) {
-        return chunk.toString('utf8');
-    }
-    if (chunk instanceof Uint8Array) {
-        return Buffer.from(chunk).toString('utf8');
-    }
-    if (chunk instanceof ArrayBuffer) {
-        return Buffer.from(new Uint8Array(chunk)).toString('utf8');
-    }
-    return String(chunk ?? '');
-}
-function rewindStreamWithConsumedChunks(stream, consumedChunks, iterator) {
-    // Rewind by re-wrapping the iterator so downstream SSE decoder still sees everything consumed here.
-    // eslint-disable-next-line no-param-reassign
-    stream[Symbol.asyncIterator] = () => replayIterator(consumedChunks, iterator);
-}
-function replayIterator(consumedChunks, iterator) {
-    let replayIndex = 0;
-    return {
-        async next() {
-            if (replayIndex < consumedChunks.length) {
-                const value = consumedChunks[replayIndex];
-                replayIndex += 1;
-                return { done: false, value };
-            }
-            return iterator.next();
-        },
-        async return(value) {
-            if (typeof iterator.return === 'function') {
-                return iterator.return(value);
-            }
-            return { done: true, value };
-        },
-        async throw(err) {
-            if (typeof iterator.throw === 'function') {
-                return iterator.throw(err);
-            }
-            throw err;
-        }
-    };
+    const parsed = parseJsonObjectCandidateWithNative(payload, 10 * 1024 * 1024);
+    return parsed ?? null;
 }
 function extractSseStream(payload) {
     if (!payload || typeof payload !== 'object') {

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage1_sse_decode/stream-json-sniffer.d.ts

@@ -0,0 +1,3 @@
+import { Readable } from 'node:stream';
+import type { JsonObject } from '../../../../types/json.js';
+export declare function tryDecodeJsonBodyFromStream(stream: Readable): Promise<JsonObject | null>;

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage1_sse_decode/stream-json-sniffer.js

@@ -0,0 +1,81 @@
+import { looksLikeJsonStreamPrefixWithNative, parseJsonObjectCandidateWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+const STREAM_JSON_MAX_BYTES = 1024 * 1024;
+export async function tryDecodeJsonBodyFromStream(stream) {
+    // Peek the first chunk; if it looks like JSON (starts with `{` or `[`), consume full body and parse.
+    const iterator = stream[Symbol.asyncIterator]();
+    const first = await iterator.next();
+    if (first.done || first.value == null) {
+        return null;
+    }
+    const consumedChunks = [first.value];
+    const firstChunk = first.value;
+    const looksLikeJson = looksLikeJsonStreamPrefixWithNative(chunkToUtf8(firstChunk));
+    if (!looksLikeJson) {
+        rewindStreamWithConsumedChunks(stream, consumedChunks, iterator);
+        return null;
+    }
+    let body = chunkToUtf8(firstChunk);
+    while (true) {
+        const next = await iterator.next();
+        if (next.done)
+            break;
+        consumedChunks.push(next.value);
+        body += chunkToUtf8(next.value);
+        // Guard: avoid unbounded buffering if the upstream is actually SSE but starts with whitespace.
+        if (body.length > STREAM_JSON_MAX_BYTES) {
+            rewindStreamWithConsumedChunks(stream, consumedChunks, iterator);
+            return null;
+        }
+    }
+    const parsed = parseJsonObjectCandidateWithNative(body, STREAM_JSON_MAX_BYTES);
+    if (!parsed) {
+        rewindStreamWithConsumedChunks(stream, consumedChunks, iterator);
+        return null;
+    }
+    return parsed;
+}
+function chunkToUtf8(chunk) {
+    if (typeof chunk === 'string') {
+        return chunk;
+    }
+    if (Buffer.isBuffer(chunk)) {
+        return chunk.toString('utf8');
+    }
+    if (chunk instanceof Uint8Array) {
+        return Buffer.from(chunk).toString('utf8');
+    }
+    if (chunk instanceof ArrayBuffer) {
+        return Buffer.from(new Uint8Array(chunk)).toString('utf8');
+    }
+    return String(chunk ?? '');
+}
+function rewindStreamWithConsumedChunks(stream, consumedChunks, iterator) {
+    // Rewind by re-wrapping the iterator so downstream SSE decoder still sees everything consumed here.
+    // eslint-disable-next-line no-param-reassign
+    stream[Symbol.asyncIterator] = () => replayIterator(consumedChunks, iterator);
+}
+function replayIterator(consumedChunks, iterator) {
+    let replayIndex = 0;
+    return {
+        async next() {
+            if (replayIndex < consumedChunks.length) {
+                const value = consumedChunks[replayIndex];
+                replayIndex += 1;
+                return { done: false, value };
+            }
+            return iterator.next();
+        },
+        async return(value) {
+            if (typeof iterator.return === 'function') {
+                return iterator.return(value);
+            }
+            return { done: true, value };
+        },
+        async throw(err) {
+            if (typeof iterator.throw === 'function') {
+                return iterator.throw(err);
+            }
+            throw err;
+        }
+    };
+}

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

@@ -1,11 +1,10 @@
 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';
+import type { 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

@@ -1,6 +1,41 @@
 import { recordStage } from '../../../stages/utils.js';
+import { parseRespInboundFormatEnvelopeWithNative, sanitizeFormatEnvelopeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
+import { normalizeReasoningInAnthropicPayload, normalizeReasoningInChatPayload, normalizeReasoningInGeminiPayload, normalizeReasoningInResponsesPayload } from '../../../../../shared/reasoning-normalizer.js';
+function resolveProtocolToken(adapterContext) {
+    const candidate = typeof adapterContext.providerProtocol === 'string' && adapterContext.providerProtocol.trim().length
+        ? adapterContext.providerProtocol.trim().toLowerCase()
+        : '';
+    if (candidate === 'openai-chat' || candidate === 'openai-responses' || candidate === 'anthropic-messages' || candidate === 'gemini-chat') {
+        return candidate;
+    }
+    return 'openai-chat';
+}
+function applyReasoningNormalization(payload, protocol) {
+    if (protocol === 'openai-responses') {
+        normalizeReasoningInResponsesPayload(payload, {
+            includeOutput: true,
+            includeRequiredAction: true
+        });
+        return;
+    }
+    if (protocol === 'anthropic-messages') {
+        normalizeReasoningInAnthropicPayload(payload);
+        return;
+    }
+    if (protocol === 'gemini-chat') {
+        normalizeReasoningInGeminiPayload(payload);
+        return;
+    }
+    normalizeReasoningInChatPayload(payload);
+}
 export async function runRespInboundStage2FormatParse(options) {
-    const envelope = (await options.formatAdapter.parseResponse(options.payload, options.adapterContext));
+    const protocol = resolveProtocolToken(options.adapterContext);
+    applyReasoningNormalization(options.payload, protocol);
+    const envelopeRaw = parseRespInboundFormatEnvelopeWithNative({
+        payload: options.payload,
+        protocol
+    });
+    const envelope = sanitizeFormatEnvelopeWithNative(envelopeRaw);
     recordStage(options.stageRecorder, 'chat_process.resp.stage2.format_parse', envelope);
     return envelope;
 }

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

@@ -1,8 +1,10 @@
 import { recordStage } from '../../../stages/utils.js';
+import { sanitizeChatCompletionLikeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
 export async function runRespInboundStage3SemanticMap(options) {
-    const chatResponse = await options.mapper.toChatCompletion(options.formatEnvelope, options.adapterContext, {
+    const chatResponseRaw = await options.mapper.toChatCompletion(options.formatEnvelope, options.adapterContext, {
         requestSemantics: options.requestSemantics
     });
+    const chatResponse = sanitizeChatCompletionLikeWithNative(chatResponseRaw);
     recordStage(options.stageRecorder, 'chat_process.resp.stage4.semantic_map_to_chat', chatResponse);
     return chatResponse;
 }

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/chat-process-semantics-bridge.d.ts

@@ -0,0 +1,6 @@
+import type { JsonObject } from '../../../../types/json.js';
+import type { BridgeToolDefinition } from '../../../../../types/bridge-message-types.js';
+export declare function resolveAliasMapFromSemantics(semantics?: JsonObject): Record<string, string> | undefined;
+export declare function normalizeAliasMap(candidate: unknown): Record<string, string> | undefined;
+export declare function resolveClientToolsRawFromSemantics(semantics?: JsonObject): BridgeToolDefinition[] | undefined;
+export declare function resolveClientToolsRaw(candidate: unknown): BridgeToolDefinition[] | undefined;

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/chat-process-semantics-bridge.js

@@ -0,0 +1,17 @@
+import { resolveAliasMapFromRespSemanticsWithNative, resolveClientToolsRawFromRespSemanticsWithNative, normalizeAliasMapWithNative, resolveClientToolsRawWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+// Three-stage contract:
+// inbound -> chat_process -> outbound
+// This module is the outbound-side bridge that consumes chat_process semantics
+// and remaps client-facing tool semantics without mutating chat_process internals.
+export function resolveAliasMapFromSemantics(semantics) {
+    return resolveAliasMapFromRespSemanticsWithNative(semantics);
+}
+export function normalizeAliasMap(candidate) {
+    return normalizeAliasMapWithNative(candidate);
+}
+export function resolveClientToolsRawFromSemantics(semantics) {
+    return resolveClientToolsRawFromRespSemanticsWithNative(semantics);
+}
+export function resolveClientToolsRaw(candidate) {
+    return resolveClientToolsRawWithNative(candidate);
+}

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/client-remap-protocol-switch.d.ts

@@ -0,0 +1,9 @@
+import { type JsonObject } from '../../../../types/json.js';
+export type ClientProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages';
+export interface ClientRemapProtocolSwitchOptions {
+    payload: JsonObject;
+    clientProtocol: ClientProtocol;
+    requestId: string;
+    requestSemantics?: JsonObject;
+}
+export declare function buildClientPayloadForProtocol(options: ClientRemapProtocolSwitchOptions): JsonObject;

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/client-remap-protocol-switch.js

@@ -0,0 +1,28 @@
+import { buildAnthropicResponseFromChat } from '../../../../response/response-runtime.js';
+import { normalizeResponsesToolCallIds } from '../../../../../shared/responses-tool-utils.js';
+import { applyClientPassthroughPatchWithNative, buildResponsesPayloadFromChatWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+import { resolveAliasMapFromSemantics, resolveClientToolsRawFromSemantics } from './chat-process-semantics-bridge.js';
+export function buildClientPayloadForProtocol(options) {
+    let clientPayload;
+    if (options.clientProtocol === 'openai-chat') {
+        clientPayload = options.payload;
+    }
+    else if (options.clientProtocol === 'anthropic-messages') {
+        clientPayload = buildAnthropicResponseFromChat(options.payload, {
+            aliasMap: resolveAliasMapFromSemantics(options.requestSemantics)
+        });
+    }
+    else {
+        const toolsRaw = resolveClientToolsRawFromSemantics(options.requestSemantics);
+        clientPayload = buildResponsesPayloadFromChatWithNative(options.payload, {
+            requestId: options.requestId,
+            ...(toolsRaw ? { toolsRaw } : {})
+        });
+    }
+    const patchedPayload = applyClientPassthroughPatchWithNative(clientPayload, options.payload);
+    Object.assign(clientPayload, patchedPayload);
+    if (options.clientProtocol === 'openai-responses') {
+        normalizeResponsesToolCallIds(clientPayload);
+    }
+    return clientPayload;
+}

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

@@ -1,7 +1,7 @@
 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';
+import { type ClientProtocol } from './client-remap-protocol-switch.js';
 export interface RespOutboundStage1ClientRemapOptions {
     payload: JsonObject;
     clientProtocol: ClientProtocol;
@@ -11,4 +11,3 @@ export interface RespOutboundStage1ClientRemapOptions {
     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

@@ -1,107 +1,19 @@
-import { isJsonObject, jsonClone } from '../../../../types/json.js';
-import { buildAnthropicResponseFromChat } from '../../../../response/response-runtime.js';
-import { buildResponsesPayloadFromChat } from '../../../../../responses/responses-openai-bridge.js';
-import { buildAnthropicToolAliasMap } from '../../../../../shared/anthropic-message-utils.js';
 import { recordStage } from '../../../stages/utils.js';
+import { buildClientPayloadForProtocol } from './client-remap-protocol-switch.js';
+import { normalizeProviderProtocolTokenWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.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: resolveAliasMapFromSemantics(options.requestSemantics)
-        });
-    }
-    else {
-        const toolsRaw = resolveClientToolsRawFromSemantics(options.requestSemantics);
-        clientPayload = buildResponsesPayloadFromChat(options.payload, {
-            requestId: options.requestId,
-            ...(toolsRaw ? { toolsRaw } : {})
-        });
-        if (options.payload && typeof options.payload === 'object' && !Array.isArray(options.payload)) {
-            const source = options.payload;
-            const passthrough = ['metadata', 'temperature', 'top_p', 'prompt_cache_key', 'reasoning'];
-            for (const key of passthrough) {
-                if (clientPayload[key] === undefined && source[key] !== undefined) {
-                    clientPayload[key] = jsonClone(source[key]);
-                }
-            }
-        }
-    }
-    // Preserve upstream error envelope when present (used by host status mapping + servertool auto flows).
-    try {
-        const err = options.payload.error;
-        if (isJsonObject(err)) {
-            clientPayload.error = jsonClone(err);
-        }
-    }
-    catch {
-        // best-effort
-    }
+    const normalizedProtocol = normalizeProviderProtocolTokenWithNative(options.clientProtocol);
+    const clientProtocol = normalizedProtocol === 'openai-chat' ||
+        normalizedProtocol === 'openai-responses' ||
+        normalizedProtocol === 'anthropic-messages'
+        ? normalizedProtocol
+        : options.clientProtocol;
+    const clientPayload = buildClientPayloadForProtocol({
+        payload: options.payload,
+        clientProtocol,
+        requestId: options.requestId,
+        requestSemantics: options.requestSemantics
+    });
     recordStage(options.stageRecorder, 'chat_process.resp.stage9.client_remap', clientPayload);
     return clientPayload;
 }
-function resolveAliasMapFromSemantics(semantics) {
-    if (!semantics || typeof semantics !== 'object' || Array.isArray(semantics)) {
-        return undefined;
-    }
-    const toolsNode = semantics.tools;
-    if (!toolsNode || typeof toolsNode !== 'object' || Array.isArray(toolsNode)) {
-        return undefined;
-    }
-    const toolsRecord = toolsNode;
-    // Prefer explicit alias map.
-    const candidate = toolsRecord.toolNameAliasMap;
-    const fromCandidate = normalizeAliasMap(candidate);
-    if (fromCandidate) {
-        return fromCandidate;
-    }
-    // Fallback: derive from captured raw client tools if present.
-    // This covers callers that captured `clientToolsRaw` but did not persist `toolNameAliasMap`.
-    const rawTools = toolsRecord.clientToolsRaw;
-    const derived = buildAnthropicToolAliasMap(rawTools);
-    return normalizeAliasMap(derived);
-}
-function normalizeAliasMap(candidate) {
-    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;
-}
-function resolveClientToolsRawFromSemantics(semantics) {
-    if (!semantics || typeof semantics !== 'object' || Array.isArray(semantics)) {
-        return undefined;
-    }
-    const toolsNode = semantics.tools;
-    if (!toolsNode || typeof toolsNode !== 'object' || Array.isArray(toolsNode)) {
-        return undefined;
-    }
-    const candidate = toolsNode.clientToolsRaw;
-    if (!candidate || !Array.isArray(candidate)) {
-        return undefined;
-    }
-    const filtered = [];
-    for (const entry of candidate) {
-        if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
-            const type = entry.type;
-            if (typeof type !== 'string' || !type.trim()) {
-                continue;
-            }
-            filtered.push(entry);
-        }
-    }
-    return filtered.length ? filtered : undefined;
-}

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

@@ -1,7 +1,9 @@
 import { defaultSseCodecRegistry } from '../../../../../../sse/index.js';
 import { recordStage } from '../../../stages/utils.js';
+import { resolveSseStreamModeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
 export async function runRespOutboundStage2SseStream(options) {
-    if (!options.wantsStream) {
+    const shouldStream = resolveSseStreamModeWithNative(options.wantsStream, options.clientProtocol);
+    if (!shouldStream) {
         recordStage(options.stageRecorder, 'chat_process.resp.stage10.sse_stream', {
             passthrough: false,
             protocol: options.clientProtocol,