@jsonstudio/llms 0.6.2979 → 0.6.3238

package/dist/conversion/hub/operation-table/semantic-mappers/chat-mapper.js

@@ -1,82 +1,4 @@
-import { isJsonObject, jsonClone } from '../../types/json.js';
-import { normalizeChatMessageContentWithNative } from '../../../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
-import { ensureProtocolState } from '../../../shared/protocol-state.js';
-import { mapReqInboundBridgeToolsToChatWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
-const CHAT_PARAMETER_KEYS = [
-    'model',
-    'temperature',
-    'top_p',
-    'top_k',
-    'max_tokens',
-    'frequency_penalty',
-    'presence_penalty',
-    'logit_bias',
-    'response_format',
-    'parallel_tool_calls',
-    'tool_choice',
-    'seed',
-    'user',
-    'metadata',
-    'stop',
-    'stop_sequences',
-    'stream'
-];
-const KNOWN_TOP_LEVEL_FIELDS = new Set([
-    'messages',
-    'tools',
-    'tool_outputs',
-    ...CHAT_PARAMETER_KEYS,
-    'stageExpectations',
-    'stages'
-]);
-function flattenSystemContent(content) {
-    if (typeof content === 'string')
-        return content;
-    if (Array.isArray(content)) {
-        return content.map(flattenSystemContent).filter(Boolean).join('\n');
-    }
-    if (content && typeof content === 'object') {
-        const obj = content;
-        if (typeof obj.text === 'string')
-            return obj.text;
-        if (typeof obj.content === 'string')
-            return obj.content;
-        if (Array.isArray(obj.content))
-            return obj.content.map(flattenSystemContent).join('\n');
-    }
-    return '';
-}
-function normalizeToolContent(content) {
-    if (typeof content === 'string')
-        return content;
-    if (content === null || content === undefined)
-        return '';
-    try {
-        return JSON.stringify(content);
-    }
-    catch {
-        return String(content ?? '');
-    }
-}
-function maybeAugmentRouteCodexApplyPatchPrecheck(content) {
-    if (!content || typeof content !== 'string') {
-        return content;
-    }
-    if (content.includes('[RouteCodex precheck]')) {
-        return content;
-    }
-    const lower = content.toLowerCase();
-    if (!lower.includes('failed to parse function arguments')) {
-        return content;
-    }
-    if (content.includes('missing field `input`')) {
-        return `${content}\n\n[RouteCodex precheck] apply_patch 参数解析失败：缺少字段 "input"。当前 RouteCodex 期望 { input, patch } 形态，并且两个字段都应包含完整统一 diff 文本。`;
-    }
-    if (content.includes('invalid type: map, expected a string')) {
-        return `${content}\n\n[RouteCodex precheck] apply_patch 参数类型错误：检测到 JSON 对象（map），但客户端期望字符串。请先对参数做 JSON.stringify 再写入 arguments，或直接提供 { patch: "<统一 diff>" } 形式。`;
-    }
-    return content;
-}
+import { mapOpenaiChatFromChatWithNative, mapOpenaiChatToChatWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-semantic-mappers.js';
 export function maybeAugmentApplyPatchErrorContent(content, toolName) {
     if (!content)
         return content;
@@ -86,316 +8,18 @@ export function maybeAugmentApplyPatchErrorContent(content, toolName) {
     if (!isApplyPatch) {
         return content;
     }
-    // 避免重复追加提示。
+    // Avoid duplicate hints.
     if (content.includes('[apply_patch hint]')) {
         return content;
     }
-    const hint = '\n\n[apply_patch hint] 在使用 apply_patch 之前，请先读取目标文件的最新内容，并基于该内容生成补丁；同时确保补丁格式符合工具规范（统一补丁格式或结构化参数），避免上下文不匹配或语法错误。';
+    const hint = '\n\n[apply_patch hint] \u5728\u4f7f\u7528 apply_patch \u4e4b\u524d\uff0c\u8bf7\u5148\u8bfb\u53d6\u76ee\u6807\u6587\u4ef6\u7684\u6700\u65b0\u5185\u5bb9\uff0c\u5e76\u57fa\u4e8e\u8be5\u5185\u5bb9\u751f\u6210\u8865\u4e01\uff1b\u540c\u65f6\u786e\u4fdd\u8865\u4e01\u683c\u5f0f\u7b26\u5408\u5de5\u5177\u89c4\u8303\uff08\u7edf\u4e00\u8865\u4e01\u683c\u5f0f\u6216\u7ed3\u6784\u5316\u53c2\u6570\uff09\uff0c\u907f\u514d\u4e0a\u4e0b\u6587\u4e0d\u5339\u914d\u6216\u8bed\u6cd5\u9519\u8bef\u3002';
     return content + hint;
 }
-function recordToolCallIssues(message, messageIndex, missing) {
-    const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : undefined;
-    if (!toolCalls?.length)
-        return;
-    toolCalls.forEach((entry, callIndex) => {
-        if (!isJsonObject(entry)) {
-            missing.push({
-                path: `messages[${messageIndex}].tool_calls[${callIndex}]`,
-                reason: 'invalid_tool_call_entry',
-                originalValue: jsonClone(entry)
-            });
-            return;
-        }
-        const fnBlock = entry.function;
-        if (!isJsonObject(fnBlock)) {
-            missing.push({
-                path: `messages[${messageIndex}].tool_calls[${callIndex}].function`,
-                reason: 'missing_tool_function',
-                originalValue: jsonClone(fnBlock)
-            });
-            return;
-        }
-        const fnName = fnBlock.name;
-        if (typeof fnName !== 'string' || !fnName.trim().length) {
-            missing.push({
-                path: `messages[${messageIndex}].tool_calls[${callIndex}].function.name`,
-                reason: 'missing_tool_name'
-            });
-        }
-    });
-}
-function collectSystemRawBlocks(raw) {
-    if (!Array.isArray(raw))
-        return undefined;
-    const blocks = [];
-    raw.forEach((entry) => {
-        if (!isJsonObject(entry))
-            return;
-        if (String(entry.role ?? '').toLowerCase() !== 'system')
-            return;
-        blocks.push(jsonClone(entry));
-    });
-    return blocks.length ? blocks : undefined;
-}
-function normalizeChatMessages(raw) {
-    const norm = {
-        messages: [],
-        systemSegments: [],
-        toolOutputs: [],
-        missingFields: []
-    };
-    if (raw === undefined) {
-        norm.missingFields.push({ path: 'messages', reason: 'absent' });
-        return norm;
-    }
-    if (!Array.isArray(raw)) {
-        norm.missingFields.push({ path: 'messages', reason: 'invalid_type', originalValue: jsonClone(raw) });
-        return norm;
-    }
-    raw.forEach((value, index) => {
-        if (!isJsonObject(value)) {
-            norm.missingFields.push({ path: `messages[${index}]`, reason: 'invalid_entry', originalValue: jsonClone(value) });
-            return;
-        }
-        const roleValue = value.role;
-        if (typeof roleValue !== 'string') {
-            norm.missingFields.push({ path: `messages[${index}].role`, reason: 'missing_role' });
-            return;
-        }
-        const chatMessage = value;
-        if (roleValue !== 'system' && roleValue !== 'tool') {
-            const normalizedContent = normalizeChatMessageContentWithNative(chatMessage.content);
-            const shouldOverwriteContent = !Array.isArray(chatMessage.content);
-            if (shouldOverwriteContent && normalizedContent.contentText !== undefined) {
-                chatMessage.content = normalizedContent.contentText;
-            }
-            if (typeof normalizedContent.reasoningText === 'string' && normalizedContent.reasoningText.trim().length) {
-                chatMessage.reasoning_content = normalizedContent.reasoningText.trim();
-            }
-        }
-        norm.messages.push(chatMessage);
-        const toolCallCandidate = value.tool_calls;
-        if (Array.isArray(toolCallCandidate) && toolCallCandidate.length) {
-            recordToolCallIssues(value, index, norm.missingFields);
-        }
-        if (roleValue === 'system') {
-            const segment = flattenSystemContent(chatMessage.content);
-            if (segment.trim().length) {
-                norm.systemSegments.push(segment);
-            }
-            return;
-        }
-        if (roleValue === 'tool') {
-            const rawCallId = (value.tool_call_id ?? value.call_id ?? value.id);
-            const toolCallId = typeof rawCallId === 'string' && rawCallId.trim().length ? rawCallId.trim() : undefined;
-            if (!toolCallId) {
-                norm.missingFields.push({ path: `messages[${index}].tool_call_id`, reason: 'missing_tool_call_id' });
-                return;
-            }
-            const nameValue = typeof value.name === 'string' && value.name.trim().length ? value.name : undefined;
-            const normalizedToolOutput = normalizeToolContent(value.content ?? value.output);
-            const routeCodexPrechecked = maybeAugmentRouteCodexApplyPatchPrecheck(normalizedToolOutput);
-            if (routeCodexPrechecked !== normalizedToolOutput) {
-                // Keep tool role message content aligned with outbound provider requests (e.g. Chat→Responses),
-                // while avoiding double-injection.
-                if (typeof chatMessage.content === 'string' || chatMessage.content === undefined || chatMessage.content === null) {
-                    chatMessage.content = routeCodexPrechecked;
-                }
-                else if (typeof chatMessage.output === 'string') {
-                    chatMessage.output = routeCodexPrechecked;
-                }
-            }
-            const outputEntry = {
-                tool_call_id: toolCallId,
-                content: routeCodexPrechecked,
-                name: nameValue
-            };
-            outputEntry.content = maybeAugmentApplyPatchErrorContent(outputEntry.content, outputEntry.name);
-            norm.toolOutputs.push(outputEntry);
-        }
-    });
-    return norm;
-}
-function normalizeStandaloneToolOutputs(raw, missing) {
-    if (!Array.isArray(raw) || raw.length === 0)
-        return [];
-    const outputs = [];
-    raw.forEach((entry, index) => {
-        if (!isJsonObject(entry)) {
-            missing.push({ path: `tool_outputs[${index}]`, reason: 'invalid_entry', originalValue: jsonClone(entry) });
-            return;
-        }
-        const rawCallId = entry.tool_call_id ?? entry.call_id ?? entry.id;
-        const toolCallId = typeof rawCallId === 'string' && rawCallId.trim().length ? rawCallId.trim() : undefined;
-        if (!toolCallId) {
-            missing.push({ path: `tool_outputs[${index}].tool_call_id`, reason: 'missing_tool_call_id' });
-            return;
-        }
-        const nameValue = typeof entry.name === 'string' && entry.name.trim().length ? entry.name : undefined;
-        const rawContent = normalizeToolContent(entry.content ?? entry.output);
-        const content = maybeAugmentApplyPatchErrorContent(rawContent, nameValue);
-        outputs.push({
-            tool_call_id: toolCallId,
-            content,
-            name: nameValue
-        });
-    });
-    return outputs;
-}
-function normalizeTools(raw, missing) {
-    if (!Array.isArray(raw) || raw.length === 0) {
-        return undefined;
-    }
-    const tools = mapReqInboundBridgeToolsToChatWithNative(raw);
-    if (tools.length === 0) {
-        raw.forEach((entry, index) => {
-            missing.push({ path: `tools[${index}]`, reason: 'invalid_entry', originalValue: jsonClone(entry) });
-        });
-    }
-    return tools.length ? tools : undefined;
-}
-function extractParameters(body) {
-    const params = {};
-    for (const key of CHAT_PARAMETER_KEYS) {
-        if (body[key] !== undefined) {
-            params[key] = body[key];
-        }
-    }
-    return Object.keys(params).length ? params : undefined;
-}
-function collectExtraFields(body) {
-    const extras = {};
-    for (const [key, value] of Object.entries(body)) {
-        if (KNOWN_TOP_LEVEL_FIELDS.has(key)) {
-            continue;
-        }
-        if (value !== undefined) {
-            extras[key] = jsonClone(value);
-        }
-    }
-    return Object.keys(extras).length ? extras : undefined;
-}
-function extractOpenAIExtraFieldsFromSemantics(semantics) {
-    if (!semantics || !semantics.providerExtras || !isJsonObject(semantics.providerExtras)) {
-        return undefined;
-    }
-    const openaiExtras = semantics.providerExtras.openaiChat;
-    if (!openaiExtras || !isJsonObject(openaiExtras)) {
-        return undefined;
-    }
-    const stored = openaiExtras.extraFields;
-    if (!stored || !isJsonObject(stored)) {
-        return undefined;
-    }
-    return stored;
-}
-function hasExplicitEmptyToolsSemantics(semantics) {
-    if (!semantics || !semantics.tools || !isJsonObject(semantics.tools)) {
-        return false;
-    }
-    const flag = semantics.tools.explicitEmpty;
-    return flag === true;
-}
-function buildOpenAISemantics(options) {
-    const semantics = {};
-    if (options.systemSegments && options.systemSegments.length) {
-        semantics.system = {
-            textBlocks: options.systemSegments.map((segment) => segment)
-        };
-    }
-    if (options.extraFields && Object.keys(options.extraFields).length) {
-        semantics.providerExtras = {
-            openaiChat: {
-                extraFields: jsonClone(options.extraFields)
-            }
-        };
-    }
-    if (options.explicitEmptyTools) {
-        semantics.tools = {
-            explicitEmpty: true
-        };
-    }
-    return Object.keys(semantics).length ? semantics : undefined;
-}
-function applyExtraFields(body, metadata, semantics) {
-    const sources = [];
-    const semanticsExtras = extractOpenAIExtraFieldsFromSemantics(semantics);
-    if (semanticsExtras) {
-        sources.push(semanticsExtras);
-    }
-    if (!sources.length) {
-        return;
-    }
-    for (const source of sources) {
-        for (const [key, value] of Object.entries(source)) {
-            if (body[key] !== undefined) {
-                continue;
-            }
-            body[key] = jsonClone(value);
-        }
-    }
-}
 export class ChatSemanticMapper {
     async toChat(format, ctx) {
-        const payload = (format.payload ?? {});
-        const normalized = normalizeChatMessages(payload.messages);
-        const topLevelOutputs = normalizeStandaloneToolOutputs(payload.tool_outputs, normalized.missingFields);
-        const toolOutputs = [...normalized.toolOutputs];
-        for (const entry of topLevelOutputs) {
-            if (!toolOutputs.find(item => item.tool_call_id === entry.tool_call_id)) {
-                toolOutputs.push(entry);
-            }
-        }
-        const metadata = { context: ctx };
-        const rawSystemBlocks = collectSystemRawBlocks(payload.messages);
-        if (rawSystemBlocks) {
-            const protocolState = ensureProtocolState(metadata, 'openai');
-            protocolState.systemMessages = jsonClone(rawSystemBlocks);
-        }
-        if (normalized.missingFields.length) {
-            metadata.missingFields = normalized.missingFields;
-        }
-        const extraFields = collectExtraFields(payload);
-        const explicitEmptyTools = Array.isArray(payload.tools) && payload.tools.length === 0;
-        const semantics = buildOpenAISemantics({
-            systemSegments: normalized.systemSegments,
-            extraFields,
-            explicitEmptyTools
-        });
-        return {
-            messages: normalized.messages,
-            tools: normalizeTools(payload.tools, normalized.missingFields),
-            toolOutputs: toolOutputs.length ? toolOutputs : undefined,
-            parameters: extractParameters(payload),
-            semantics,
-            metadata
-        };
+        return mapOpenaiChatToChatWithNative((format.payload ?? {}), ctx);
     }
     async fromChat(chat, ctx) {
-        const shouldEmitEmptyTools = hasExplicitEmptyToolsSemantics(chat.semantics);
-        const payload = {
-            messages: chat.messages,
-            tools: chat.tools ?? (shouldEmitEmptyTools ? [] : undefined),
-            ...(chat.parameters || {})
-        };
-        applyExtraFields(payload, chat.metadata, chat.semantics);
-        // Do not forward tool_outputs to provider wire formats. OpenAI Chat
-        // endpoints expect tool results to appear as tool role messages, and
-        // sending the legacy top-level field causes upstream HTTP 400 responses.
-        // Concrete translation happens earlier when responses input is unfolded
-        // into ChatEnvelope.messages, so the provider request only needs the
-        // canonical message list.
-        if (payload.max_tokens === undefined && typeof payload.max_output_tokens === 'number') {
-            payload.max_tokens = payload.max_output_tokens;
-            delete payload.max_output_tokens;
-        }
-        return {
-            protocol: 'openai-chat',
-            direction: 'response',
-            payload,
-            meta: {
-                context: ctx
-            }
-        };
+        return mapOpenaiChatFromChatWithNative(chat, ctx);
     }
 }

package/dist/conversion/hub/operation-table/semantic-mappers/gemini-mapper.js

@@ -1,9 +1,9 @@
 import { isJsonObject, jsonClone } from '../../types/json.js';
 import { buildOpenAIChatFromGeminiRequest } from '../../../codecs/gemini-openai-codec.js';
-import { encodeMetadataPassthrough, extractMetadataPassthrough } from '../../../shared/metadata-passthrough.js';
+import { encodeMetadataPassthrough, extractMetadataPassthrough } from '../../../metadata-passthrough.js';
 import { mapBridgeToolsToChat, mapChatToolsToBridge } from '../../../shared/tool-mapping.js';
 import { prepareGeminiToolsForBridge, buildGeminiToolsFromBridge } from '../../../shared/gemini-tool-utils.js';
-import { ensureProtocolState, getProtocolState } from '../../../shared/protocol-state.js';
+import { ensureProtocolState, getProtocolState } from '../../../protocol-state.js';
 import { sanitizeReasoningTaggedText } from '../../../shared/reasoning-utils.js';
 import { applyClaudeThinkingToolSchemaCompatWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
 import { extractAntigravityGeminiSessionIdWithNative } from '../../../../router/virtual-router/engine-selection/native-router-hotpath.js';

package/dist/conversion/hub/operation-table/semantic-mappers/responses-mapper.js

@@ -471,14 +471,8 @@ export class ResponsesSemanticMapper {
                 context: ctx
             }
         };
-        // Some responses providers (e.g. TAB) reject sampling knobs with HTTP 400.
-        // Filter these at mapper outbound so they never reach openai-responses providers.
-        const unsupportedParams = ['temperature', 'top_p', 'seed', 'logit_bias'];
-        for (const key of unsupportedParams) {
-            if (key in result.payload) {
-                delete result.payload[key];
-            }
-        }
+        // Sampling knobs should remain intact for OpenAI Responses protocol.
+        // Provider-specific removal belongs in compatibility profiles, not here.
         return result;
     }
 }

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

@@ -95,6 +95,7 @@ export declare class HubPipeline {
     private resolveAliasMapFromSources;
     private resolveProtocolHooks;
     private buildAdapterContext;
+    private applyMaxTokensPolicy;
     private maybeCreateStageRecorder;
     private asJsonObject;
     private normalizeRequest;

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

@@ -13,7 +13,7 @@ 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 { shouldRecordSnapshots } from '../../shared/snapshot-utils.js';
+import { shouldRecordSnapshots } from '../../snapshot-utils.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';
@@ -28,10 +28,10 @@ import { extractSessionIdentifiersFromMetadata } from './session-identifiers.js'
 import { computeRequestTokens } from '../../../router/virtual-router/token-estimator.js';
 import { annotatePassthroughGovernanceSkipWithNative, attachPassthroughProviderInputAuditWithNative, buildPassthroughAuditWithNative, applyOutboundStreamPreferenceWithNative, normalizeHubEndpointWithNative, extractAdapterContextMetadataFieldsWithNative, resolveApplyPatchToolModeFromToolsWithNative, resolveHubClientProtocolWithNative, resolveHubPolicyOverrideFromMetadataWithNative, resolveHubProviderProtocolWithNative, resolveOutboundStreamIntentWithNative, resolveHubShadowCompareConfigWithNative, resolveActiveProcessModeWithNative, findMappableSemanticsKeysWithNative, resolveHubSseProtocolFromMetadataWithNative, resolveStopMessageRouterMetadataWithNative, runHubPipelineOrchestrationWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-orchestration-semantics.js';
 import { normalizeAliasMapWithNative, resolveAliasMapFromRespSemanticsWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
-import { isCompactionRequest } from '../../shared/compaction-detect.js';
+import { isCompactionRequest } from '../../compaction-detect.js';
 import { applyHubProviderOutboundPolicy, recordHubPolicyObservation, setHubPolicyRuntimePolicy } from '../policy/policy-engine.js';
 import { applyProviderOutboundToolSurface } from '../tool-surface/tool-surface-engine.js';
-import { cloneRuntimeMetadata, ensureRuntimeMetadata, readRuntimeMetadata } from '../../shared/runtime-metadata.js';
+import { cloneRuntimeMetadata, ensureRuntimeMetadata, readRuntimeMetadata } from '../../runtime-metadata.js';
 function isTruthyEnv(value) {
     const v = typeof value === 'string' ? value.trim().toLowerCase() : '';
     return v === '1' || v === 'true' || v === 'yes' || v === 'on';
@@ -392,6 +392,10 @@ export class HubPipeline {
         }
         const disableStickyRoutes = readRuntimeMetadata(normalized.metadata)?.disableStickyRoutes === true;
         const stopMessageRouterMetadata = resolveStopMessageRouterMetadata(normalized.metadata);
+        const estimatedInputTokens = (() => {
+            const value = normalized.metadata?.estimatedInputTokens;
+            return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+        })();
         const metadataInput = {
             requestId: normalized.id,
             entryEndpoint: normalized.entryEndpoint,
@@ -402,6 +406,7 @@ export class HubPipeline {
             routeHint: normalized.routeHint,
             stage: normalized.stage,
             responsesResume: responsesResume,
+            ...(estimatedInputTokens !== undefined ? { estimatedInputTokens } : {}),
             ...(disableStickyRoutes ? { disableStickyRoutes: true } : {}),
             ...(serverToolRequired ? { serverToolRequired: true } : {}),
             ...(sessionIdentifiers.sessionId ? { sessionId: sessionIdentifiers.sessionId } : {}),
@@ -441,6 +446,7 @@ export class HubPipeline {
         }
         const outboundStream = this.resolveOutboundStreamIntent(routing.target?.streaming);
         workingRequest = this.applyOutboundStreamPreference(workingRequest, outboundStream, activeProcessMode);
+        this.applyMaxTokensPolicy(workingRequest, routing.target);
         const outboundAdapterContext = this.buildAdapterContext(normalized, routing.target);
         if (routing.target?.compatibilityProfile) {
             outboundAdapterContext.compatibilityProfile = routing.target.compatibilityProfile;
@@ -1278,6 +1284,47 @@ export class HubPipeline {
         }
         return adapterContext;
     }
+    applyMaxTokensPolicy(request, target) {
+        if (!target) {
+            return;
+        }
+        const params = request.parameters || (request.parameters = {});
+        const direct = typeof params.max_tokens === 'number' && Number.isFinite(params.max_tokens)
+            ? Math.floor(params.max_tokens)
+            : undefined;
+        const maxOutputRaw = typeof params.max_output_tokens === 'number' &&
+            Number.isFinite(params.max_output_tokens)
+            ? Math.floor(params.max_output_tokens)
+            : undefined;
+        let desired = direct ?? maxOutputRaw;
+        // Default max tokens = 8k when client does not set.
+        if (!desired || desired <= 0) {
+            desired = 8192;
+        }
+        let providerCap = typeof target.maxOutputTokens === 'number' && Number.isFinite(target.maxOutputTokens)
+            ? Math.floor(target.maxOutputTokens)
+            : undefined;
+        if (!providerCap) {
+            const registry = this.routerEngine
+                .providerRegistry;
+            const profile = registry?.get?.(target.providerKey);
+            const candidate = typeof profile?.maxOutputTokens === 'number' && Number.isFinite(profile.maxOutputTokens)
+                ? Math.floor(profile.maxOutputTokens)
+                : undefined;
+            if (candidate && candidate > 0) {
+                providerCap = candidate;
+            }
+        }
+        if (providerCap && providerCap > 0) {
+            desired = Math.min(desired, providerCap);
+        }
+        if (desired && desired > 0) {
+            params.max_tokens = desired;
+            if (params.max_output_tokens !== undefined) {
+                params.max_output_tokens = desired;
+            }
+        }
+    }
     maybeCreateStageRecorder(context, endpoint, options) {
         if (options?.disableSnapshots === true) {
             return undefined;

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

@@ -1,6 +1,6 @@
 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 JsonObject } from '../../../../types/json.js';
 import type { SemanticMapper, StageRecorder } from '../../../../format-adapters/index.js';
 import type { StandardizedRequest } from '../../../../types/standardized.js';
 export interface ReqInboundStage2SemanticMapOptions {

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

@@ -1,3 +1,4 @@
+import { isJsonObject, jsonClone } from '../../../../types/json.js';
 import { applyHubOperationTableInbound } from '../../../../operation-table/operation-table-runner.js';
 import { recordStage } from '../../../stages/utils.js';
 import { liftReqInboundSemantics } from './semantic-lift.js';
@@ -5,6 +6,19 @@ import { validateChatEnvelopeWithNative } from '../../../../../../router/virtual
 import { chatEnvelopeToStandardizedWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 export async function runReqInboundStage2SemanticMap(options) {
     const chatEnvelope = await options.semanticMapper.toChat(options.formatEnvelope, options.adapterContext);
+    const preservedResponsesContext = (() => {
+        if (!chatEnvelope.semantics || typeof chatEnvelope.semantics !== 'object') {
+            return undefined;
+        }
+        const semantics = chatEnvelope.semantics;
+        const responsesNode = isJsonObject(semantics.responses)
+            ? semantics.responses
+            : undefined;
+        const contextNode = responsesNode && isJsonObject(responsesNode.context)
+            ? responsesNode.context
+            : undefined;
+        return contextNode ? jsonClone(contextNode) : undefined;
+    })();
     applyHubOperationTableInbound({
         formatEnvelope: options.formatEnvelope,
         chatEnvelope,
@@ -18,6 +32,27 @@ export async function runReqInboundStage2SemanticMap(options) {
         adapterContext: options.adapterContext,
         responsesResume: options.responsesResume
     });
+    if (preservedResponsesContext) {
+        const currentSemantics = chatEnvelope.semantics;
+        if (!currentSemantics || typeof currentSemantics !== 'object') {
+            chatEnvelope.semantics = { responses: { context: jsonClone(preservedResponsesContext) } };
+        }
+        else {
+            const semantics = currentSemantics;
+            const responsesNode = isJsonObject(semantics.responses)
+                ? semantics.responses
+                : {};
+            if (!isJsonObject(responsesNode.context)) {
+                chatEnvelope.semantics = {
+                    ...semantics,
+                    responses: {
+                        ...responsesNode,
+                        context: jsonClone(preservedResponsesContext)
+                    }
+                };
+            }
+        }
+    }
     validateChatEnvelopeWithNative(chatEnvelope, {
         stage: 'req_inbound',
         direction: 'request'
@@ -29,5 +64,32 @@ export async function runReqInboundStage2SemanticMap(options) {
         endpoint: options.adapterContext.entryEndpoint,
         requestId: options.adapterContext.requestId
     });
+    // Ensure responses semantics (context) survive into standardized request for VirtualRouter parsing.
+    if (chatEnvelope.semantics && typeof chatEnvelope.semantics === 'object') {
+        const envelopeSemantics = chatEnvelope.semantics;
+        const existing = standardizedRequest.semantics;
+        if (!existing || typeof existing !== 'object') {
+            standardizedRequest.semantics = jsonClone(envelopeSemantics);
+        }
+        else {
+            const existingObj = existing;
+            const envelopeResponses = isJsonObject(envelopeSemantics.responses)
+                ? envelopeSemantics.responses
+                : undefined;
+            const envelopeContext = envelopeResponses && isJsonObject(envelopeResponses.context)
+                ? envelopeResponses.context
+                : undefined;
+            if (envelopeContext) {
+                const nextResponses = {
+                    ...(isJsonObject(existingObj.responses) ? existingObj.responses : {}),
+                    context: jsonClone(envelopeContext)
+                };
+                standardizedRequest.semantics = {
+                    ...existingObj,
+                    responses: nextResponses
+                };
+            }
+        }
+    }
     return { chatEnvelope, standardizedRequest };
 }

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

@@ -1,5 +1,6 @@
 import { recordStage } from '../../../stages/utils.js';
 import { applyReqProcessRouteSelectionWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-process-semantics.js';
+import { cleanRoutingInstructionMarkersWithNative } from '../../../../../../router/virtual-router/engine-selection/native-virtual-router-routing-instructions-semantics.js';
 function replaceRecordInPlace(target, source) {
     for (const key of Object.keys(target)) {
         if (!Object.prototype.hasOwnProperty.call(source, key)) {
@@ -18,7 +19,8 @@ export function runReqProcessStage2RouteSelect(options) {
         routeName: result.decision.routeName,
         originalModel: previousModel
     });
-    replaceRecordInPlace(options.request, nativeApplied.request);
+    const cleanedRequest = cleanRoutingInstructionMarkersWithNative(nativeApplied.request);
+    replaceRecordInPlace(options.request, cleanedRequest);
     replaceRecordInPlace(options.normalizedMetadata, nativeApplied.normalizedMetadata);
     recordStage(options.stageRecorder, 'chat_process.req.stage5.route_select', {
         target: result.target,

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

@@ -1,6 +1,6 @@
 import { defaultSseCodecRegistry } from '../../../../../../sse/index.js';
 import { recordStage } from '../../../stages/utils.js';
-import { ProviderProtocolError } from '../../../../../shared/errors.js';
+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) {

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

@@ -1,5 +1,5 @@
 import type { JsonObject } from '../../../../types/json.js';
-import type { BridgeToolDefinition } from '../../../../../shared/bridge-message-types.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;