@jsonstudio/llms 0.6.2979 → 0.6.3214

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;

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

@@ -3,13 +3,28 @@ import { buildChatResponseFromResponses } from '../../../../../shared/responses-
 import { normalizeAssistantTextToToolCalls } from '../../../../../shared/text-markup-normalizer.js';
 import { recordStage } from '../../../stages/utils.js';
 import { applyRespProcessToolGovernanceWithNative, stripOrphanFunctionCallsTagWithNative } from '../../../../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
-const TOOL_CALL_JSON_MARKER = /["']tool_calls["']\s*:/i;
 const SHELL_TOOL_NAME_ALIASES = {
     shell_command: 'exec_command',
     shell: 'exec_command',
     bash: 'exec_command',
     terminal: 'exec_command'
 };
+/**
+ * Unified text-to-tool-calls harvest config.
+ * Shared across all providers via chat process tool governance.
+ */
+const DEFAULT_TEXT_NORMALIZER_CONFIG = {
+    jsonToolRepair: {
+        toolNameAliases: SHELL_TOOL_NAME_ALIASES,
+        argumentAliases: {
+            exec_command: {
+                cmd: ['cmd', 'command', 'input.command', 'script'],
+                command: ['cmd', 'command', 'input.command', 'script'],
+                workdir: ['workdir', 'cwd', 'input.cwd']
+            }
+        }
+    }
+};
 function isCanonicalChatCompletion(payload) {
     if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
         return false;
@@ -42,7 +57,11 @@ function coerceToCanonicalChatCompletion(payload) {
     }
     return payload;
 }
-function maybeHarvestEmptyToolCallsFromJsonContent(payload) {
+/**
+ * Harvest tool calls from assistant text content when native tool_calls are missing or empty.
+ * This is the single entry point for text-based tool call extraction across all providers.
+ */
+function harvestToolCallsFromText(payload) {
     if (!payload || typeof payload !== 'object') {
         return payload;
     }
@@ -50,6 +69,7 @@ function maybeHarvestEmptyToolCallsFromJsonContent(payload) {
     if (!choices.length) {
         return payload;
     }
+    let changed = false;
     for (const choice of choices) {
         if (!choice || typeof choice !== 'object' || Array.isArray(choice)) {
             continue;
@@ -58,37 +78,29 @@ function maybeHarvestEmptyToolCallsFromJsonContent(payload) {
         if (!message || typeof message !== 'object' || Array.isArray(message)) {
             continue;
         }
-        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : undefined;
-        if (!toolCalls || toolCalls.length !== 0) {
+        // Skip if already has native tool_calls
+        const existingToolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : undefined;
+        if (existingToolCalls && existingToolCalls.length > 0) {
             continue;
         }
-        const content = typeof message.content === 'string' ? String(message.content).trim() : '';
-        if (!content || !TOOL_CALL_JSON_MARKER.test(content)) {
-            continue;
-        }
-        const normalized = normalizeAssistantTextToToolCalls(message, {
-            jsonToolRepair: {
-                toolNameAliases: SHELL_TOOL_NAME_ALIASES,
-                argumentAliases: {
-                    exec_command: {
-                        cmd: ['cmd', 'command', 'input.command', 'script'],
-                        command: ['cmd', 'command', 'input.command', 'script'],
-                        workdir: ['workdir', 'cwd', 'input.cwd']
-                    }
-                }
+        // Try to harvest from text content
+        const normalized = normalizeAssistantTextToToolCalls(message, DEFAULT_TEXT_NORMALIZER_CONFIG);
+        const harvestedCalls = Array.isArray(normalized.tool_calls)
+            ? normalized.tool_calls
+            : [];
+        if (harvestedCalls.length > 0) {
+            choice.message = normalized;
+            changed = true;
+            // Update finish_reason if needed
+            const finish = typeof choice.finish_reason === 'string'
+                ? String(choice.finish_reason).trim().toLowerCase()
+                : '';
+            if (!finish || finish === 'stop') {
+                choice.finish_reason = 'tool_calls';
             }
-        });
-        const repairedCalls = Array.isArray(normalized.tool_calls) ? normalized.tool_calls : [];
-        if (!repairedCalls.length) {
-            continue;
-        }
-        choice.message = normalized;
-        const finish = typeof choice.finish_reason === 'string' ? String(choice.finish_reason).trim().toLowerCase() : '';
-        if (!finish || finish === 'stop') {
-            choice.finish_reason = 'tool_calls';
         }
     }
-    return payload;
+    return changed ? payload : payload;
 }
 function sanitizeResponseShapeBeforeGovernance(payload) {
     return stripOrphanFunctionCallsTagWithNative(payload);
@@ -96,7 +108,8 @@ function sanitizeResponseShapeBeforeGovernance(payload) {
 export async function runRespProcessStage1ToolGovernance(options) {
     const canonicalInput = coerceToCanonicalChatCompletion(options.payload);
     const shapeSanitizedInput = sanitizeResponseShapeBeforeGovernance(canonicalInput);
-    maybeHarvestEmptyToolCallsFromJsonContent(shapeSanitizedInput);
+    // Single entry point for text-to-tool-calls harvest across all providers
+    harvestToolCallsFromText(shapeSanitizedInput);
     recordStage(options.stageRecorder, 'chat_process.resp.stage6.canonicalize_chat_completion', {
         converted: canonicalInput !== options.payload,
         shapeSanitized: shapeSanitizedInput !== canonicalInput,

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

@@ -1,7 +1,19 @@
 import { buildProcessedRequestFromChatResponse } from '../../../../response/chat-response-utils.js';
 import { recordStage } from '../../../stages/utils.js';
 import { finalizeRespProcessChatResponseWithNative } from '../../../../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
+import { normalizeReasoningInChatPayload } from '../../../../../shared/reasoning-normalizer.js';
 export async function runRespProcessStage2Finalize(options) {
+    const endpoint = (options.entryEndpoint || '').toLowerCase();
+    const wantsAnthropicReasoning = endpoint.includes('/v1/messages');
+    const shouldNormalize = (options.reasoningMode && options.reasoningMode !== 'keep') || wantsAnthropicReasoning;
+    if (shouldNormalize) {
+        try {
+            normalizeReasoningInChatPayload(options.payload);
+        }
+        catch {
+            // best-effort inline reasoning extraction
+        }
+    }
     const finalized = (await finalizeRespProcessChatResponseWithNative({
         payload: options.payload,
         stream: options.wantsStream,

package/dist/conversion/hub/policy/protocol-spec.js

@@ -1,4 +1,4 @@
-import { ANTHROPIC_ALLOWED_FIELDS, ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS, GEMINI_ALLOWED_FIELDS, OPENAI_CHAT_ALLOWED_FIELDS, OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS, OPENAI_RESPONSES_ALLOWED_FIELDS, OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS } from '../../shared/protocol-field-allowlists.js';
+import { ANTHROPIC_ALLOWED_FIELDS, ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS, GEMINI_ALLOWED_FIELDS, OPENAI_CHAT_ALLOWED_FIELDS, OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS, OPENAI_RESPONSES_ALLOWED_FIELDS, OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS } from '../../protocol-field-allowlists.js';
 import { resolveHubProtocolSpecWithNative } from '../../../router/virtual-router/engine-selection/native-hub-bridge-policy-semantics.js';
 const ALLOWLISTS = {
     openaiChatAllowedFields: OPENAI_CHAT_ALLOWED_FIELDS,

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

@@ -1,4 +1,4 @@
-import { readRuntimeMetadata } from '../../shared/runtime-metadata.js';
+import { readRuntimeMetadata } from '../../runtime-metadata.js';
 import { clearClockSession, resolveClockConfig, startClockDaemonIfNeeded } from '../../../servertool/clock/task-store.js';
 import { logClock } from '../../../servertool/clock/log.js';
 import { resolveClockSessionScope } from '../../../servertool/clock/session-scope.js';

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

@@ -1,4 +1,4 @@
-import { readRuntimeMetadata } from '../../shared/runtime-metadata.js';
+import { readRuntimeMetadata } from '../../runtime-metadata.js';
 import { logClock } from '../../../servertool/clock/log.js';
 import { buildClockStandardToolAppendOperations, buildClockToolAppendOperations } from './chat-process-clock-tool-schemas.js';
 import { planChatClockOperationsWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';

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

@@ -1,4 +1,4 @@
-import { readRuntimeMetadata } from '../../shared/runtime-metadata.js';
+import { readRuntimeMetadata } from '../../runtime-metadata.js';
 import { loadRoutingInstructionStateSync } from '../../../router/virtual-router/sticky-session-store.js';
 import { logContinueExecution } from '../../../servertool/continue-execution/log.js';
 import { buildContinueExecutionOperationsWithNative, injectContinueExecutionDirectiveWithNative, planContinueExecutionOperationsWithNative, resolveHasActiveStopMessageForContinueExecutionWithNative, resolveStopMessageSessionScopeWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';

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

@@ -4,7 +4,7 @@ import { buildWebSearchOperations } from './chat-process-web-search.js';
 import { buildClockOperationsWithPlan } from './chat-process-clock-tools.js';
 import { buildReviewOperations } from './chat-process-review.js';
 import { maybeInjectClockRemindersAndApplyDirectives } from './chat-process-clock-reminders.js';
-import { readRuntimeMetadata } from '../../shared/runtime-metadata.js';
+import { readRuntimeMetadata } from '../../runtime-metadata.js';
 import { tryPlanChatServerToolBundleWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';
 export async function applyServerToolOrchestration(options) {
     let request = options.request;

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

@@ -1,4 +1,4 @@
-import { readRuntimeMetadata } from '../../shared/runtime-metadata.js';
+import { readRuntimeMetadata } from '../../runtime-metadata.js';
 import { buildWebSearchToolAppendOperations } from './chat-process-web-search-tool-schema.js';
 import { planChatWebSearchOperationsWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';
 export function buildWebSearchOperations(request, metadata, precomputedPlan) {

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

@@ -15,8 +15,8 @@ import { runRespProcessStage3ServerToolOrchestration } from '../pipeline/stages/
 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';
 import { recordResponsesResponse } from '../../shared/responses-conversation-store.js';
-import { ProviderProtocolError } from '../../shared/errors.js';
-import { readRuntimeMetadata } from '../../shared/runtime-metadata.js';
+import { ProviderProtocolError } from '../../provider-protocol-error.js';
+import { readRuntimeMetadata } from '../../runtime-metadata.js';
 import { commitClockReservation, resolveClockConfig } from '../../../servertool/clock/task-store.js';
 import { detectProviderResponseShapeWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';
 const PROVIDER_RESPONSE_REGISTRY = {
@@ -260,8 +260,11 @@ function applyModelOverride(payload, model) {
         /* ignore */
     }
 }
-function resolveChatReasoningMode(_entryEndpoint) {
-    // 当前保持默认策略：保留 reasoning_content 字段，不做额外拼接或删除。
+function resolveChatReasoningMode(entryEndpoint) {
+    const lowered = (entryEndpoint || '').toLowerCase();
+    if (lowered.includes('/v1/chat/completions')) {
+        return 'keep';
+    }
     return 'keep';
 }
 export async function convertProviderResponse(options) {
@@ -449,7 +452,13 @@ export async function convertProviderResponse(options) {
     // Commit scheduled-task delivery only after a successful client payload/stream is prepared.
     await maybeCommitClockReservationFromContext(options.context);
     if (outbound.stream) {
-        return { __sse_responses: outbound.stream, format: clientProtocol };
+        const usage = clientPayload && typeof clientPayload === 'object' && !Array.isArray(clientPayload)
+            ? clientPayload.usage
+            : undefined;
+        const body = usage !== undefined
+            ? { usage }
+            : undefined;
+        return { __sse_responses: outbound.stream, body, format: clientProtocol };
     }
     return { body: clientPayload, format: clientProtocol };
 }

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

@@ -2,9 +2,31 @@ import { buildOpenAIChatFromGeminiResponse } from '../../codecs/gemini-openai-co
 import { buildChatResponseFromResponses } from '../../shared/responses-response-utils.js';
 import { buildOpenAIChatFromAnthropicMessage } from './response-runtime.js';
 import { resolveAliasMapFromRespSemanticsWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+function injectResponsesReasoningExtension(payload) {
+    if (payload.__responses_reasoning) {
+        return;
+    }
+    const choices = Array.isArray(payload.choices) ? payload.choices : [];
+    const primary = choices[0] && typeof choices[0] === 'object' ? choices[0] : undefined;
+    const message = primary && typeof primary.message === 'object' ? primary.message : undefined;
+    if (!message)
+        return;
+    const reasoningText = typeof message.reasoning_content === 'string' && message.reasoning_content.trim().length
+        ? String(message.reasoning_content).trim()
+        : undefined;
+    if (!reasoningText)
+        return;
+    payload.__responses_reasoning = {
+        content: [{ type: 'reasoning_text', text: reasoningText }]
+    };
+}
 export class OpenAIChatResponseMapper {
     toChatCompletion(format, _ctx) {
-        return (format.payload ?? {});
+        const payload = (format.payload ?? {});
+        if (payload && typeof payload === 'object') {
+            injectResponsesReasoningExtension(payload);
+        }
+        return payload;
     }
 }
 export class ResponsesResponseMapper {

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

@@ -1,7 +1,7 @@
 import { extractToolCallsFromReasoningText } from '../../shared/reasoning-tool-parser.js';
 import { deriveToolCallKey } from '../../shared/tool-call-utils.js';
-import { createBridgeActionState, runBridgeActionPipeline } from '../../shared/bridge-actions.js';
-import { resolveBridgePolicy, resolvePolicyActions } from '../../shared/bridge-policies.js';
+import { createBridgeActionState, runBridgeActionPipeline } from '../../bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from '../../bridge-policies.js';
 import { normalizeAnthropicToolName } from '../../shared/anthropic-message-utils.js';
 import { buildAnthropicResponseFromChatWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
 import { registerResponsesReasoning, consumeResponsesReasoning, registerResponsesOutputTextMeta, consumeResponsesOutputTextMeta, consumeResponsesPayloadSnapshot, registerResponsesPayloadSnapshot, consumeResponsesPassthrough, registerResponsesPassthrough } from '../../shared/responses-reasoning-registry.js';
@@ -153,7 +153,20 @@ export function buildOpenAIChatFromAnthropicMessage(payload, options) {
             continue;
         const kind = String(part.type || '').toLowerCase();
         if (kind === 'text' && typeof part.text === 'string') {
-            textParts.push(part.text);
+            const rawText = part.text;
+            if (/<\s*(tool_call|function_call)\b|\[\s*(tool_call|function_call)\b/i.test(rawText)) {
+                const { cleanedText, toolCalls: inferred } = extractToolCallsFromReasoningText(rawText, { idPrefix: 'anthropic_text' });
+                const trimmed = cleanedText.trim();
+                if (trimmed.length) {
+                    textParts.push(trimmed);
+                }
+                if (Array.isArray(inferred) && inferred.length) {
+                    inferredToolCalls.push(...inferred);
+                }
+            }
+            else {
+                textParts.push(rawText);
+            }
         }
         else if (kind === 'tool_use') {
             const rawName = typeof part.name === 'string'
@@ -278,10 +291,18 @@ export function buildOpenAIChatFromAnthropicMessage(payload, options) {
             ? payload['usage']
             : undefined
     };
+    const localReasoning = reasoningParts.length
+        ? {
+            content: reasoningParts.map((text) => ({ type: 'reasoning_text', text }))
+        }
+        : undefined;
     const preserved = consumeResponsesReasoning(chatResponse.id);
-    if (preserved && preserved.length) {
+    if (preserved) {
         chatResponse.__responses_reasoning = preserved;
     }
+    else if (localReasoning) {
+        chatResponse.__responses_reasoning = localReasoning;
+    }
     const preservedOutputMeta = consumeResponsesOutputTextMeta(chatResponse.id);
     if (preservedOutputMeta) {
         chatResponse.__responses_output_text_meta = preservedOutputMeta;
@@ -289,6 +310,7 @@ export function buildOpenAIChatFromAnthropicMessage(payload, options) {
     const payloadSnapshot = consumeResponsesPayloadSnapshot(chatResponse.id);
     if (payloadSnapshot) {
         registerResponsesPayloadSnapshot(chatResponse.id, payloadSnapshot);
+        chatResponse.__responses_payload_snapshot = payloadSnapshot;
         if (typeof chatResponse.request_id !== 'string') {
             chatResponse.request_id = chatResponse.id;
         }
@@ -296,6 +318,7 @@ export function buildOpenAIChatFromAnthropicMessage(payload, options) {
     const passthroughPayload = consumeResponsesPassthrough(chatResponse.id);
     if (passthroughPayload) {
         registerResponsesPassthrough(chatResponse.id, passthroughPayload);
+        chatResponse.__responses_passthrough = passthroughPayload;
         if (typeof chatResponse.request_id !== 'string') {
             chatResponse.request_id = chatResponse.id;
         }
@@ -372,7 +395,7 @@ export function buildAnthropicResponseFromChat(chatResponse, options) {
         }
     }
     const sanitized = buildAnthropicResponseFromChatWithNative(chatResponse, aliasMap);
-    if (Array.isArray(chatResponse?.__responses_reasoning)) {
+    if (chatResponse?.__responses_reasoning) {
         registerResponsesReasoning(sanitized.id, chatResponse.__responses_reasoning);
     }
     if (chatResponse?.__responses_output_text_meta) {

package/dist/conversion/hub/snapshot-recorder.js

@@ -1,4 +1,4 @@
-import { createSnapshotWriter } from '../shared/snapshot-utils.js';
+import { createSnapshotWriter } from '../snapshot-utils.js';
 import { jsonClone } from './types/json.js';
 import { parseLenientJsonishWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export class SnapshotStageRecorder {

package/dist/conversion/hub/tool-governance/engine.d.ts

@@ -1,6 +1,14 @@
 import type { JsonObject } from '../types/json.js';
 import type { StandardizedRequest } from '../types/standardized.js';
 import type { GovernedChatCompletionPayload, GovernedStandardizedRequest, ToolGovernanceProtocol, ToolGovernanceRegistry } from './types.js';
+/**
+ * Hybrid governance engine:
+ * - request path: native-primary
+ * - response path: legacy TS rules (until native response-governance export is available)
+ *
+ * Legacy-only snapshot retained at:
+ * - src/conversion/hub/tool-governance/archive/engine.legacy.ts
+ */
 export declare class ToolGovernanceError extends Error {
     readonly protocol: ToolGovernanceProtocol;
     readonly direction: 'request' | 'response';

package/dist/conversion/hub/tool-governance/engine.js

@@ -1,5 +1,13 @@
 import { DEFAULT_TOOL_GOVERNANCE_RULES } from './rules.js';
-import { sanitizeResponsesFunctionNameWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+import { governRequestWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-governance-semantics.js';
+/**
+ * Hybrid governance engine:
+ * - request path: native-primary
+ * - response path: legacy TS rules (until native response-governance export is available)
+ *
+ * Legacy-only snapshot retained at:
+ * - src/conversion/hub/tool-governance/archive/engine.legacy.ts
+ */
 export class ToolGovernanceError extends Error {
     protocol;
     direction;
@@ -43,24 +51,24 @@ export class ToolGovernanceEngine {
                 summary: buildSummary(protocol, 'request', false)
             };
         }
-        const stats = createStats(protocol, 'request');
-        const sanitizedMessages = request.messages.map((msg) => sanitizeStandardizedMessage(msg, rules, stats));
-        const sanitizedTools = request.tools?.map((tool) => sanitizeStandardizedTool(tool, rules, stats));
-        const governed = {
-            ...request,
-            messages: sanitizedMessages,
-            tools: sanitizedTools,
-            metadata: {
-                ...request.metadata,
-                toolGovernance: {
-                    ...request.metadata?.toolGovernance,
-                    request: finalizeSummary(stats)
-                }
+        let governed;
+        try {
+            governed = governRequestWithNative({
+                request: request,
+                protocol,
+                registry: this.registry
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error ?? 'unknown error');
+            if (message.includes('Tool name exceeds max length')) {
+                throw new ToolGovernanceError(message, protocol, 'request', 'tool.function.name');
             }
-        };
+            throw error;
+        }
         return {
-            request: governed,
-            summary: finalizeSummary(stats)
+            request: governed.request,
+            summary: governed.summary
         };
     }
     governResponse(payload, protocol) {
@@ -91,53 +99,6 @@ export class ToolGovernanceEngine {
         return entry?.[direction];
     }
 }
-function sanitizeStandardizedMessage(message, rules, stats) {
-    let changed = false;
-    const next = { ...message };
-    if (Array.isArray(message.tool_calls) && message.tool_calls.length) {
-        next.tool_calls = message.tool_calls.map((call) => sanitizeToolCall(call, rules, stats));
-        if (next.tool_calls !== message.tool_calls) {
-            changed = true;
-        }
-    }
-    if (typeof message.name === 'string' || message.role === 'tool') {
-        const sanitizedName = sanitizeName(message.name, rules, stats, 'message.name');
-        if (sanitizedName !== message.name) {
-            next.name = sanitizedName;
-            changed = true;
-        }
-    }
-    return changed ? next : message;
-}
-function sanitizeStandardizedTool(tool, rules, stats) {
-    const sanitizedName = sanitizeName(tool.function?.name, rules, stats, 'tool.function.name');
-    if (sanitizedName === tool.function?.name) {
-        return tool;
-    }
-    return {
-        ...tool,
-        function: {
-            ...tool.function,
-            name: sanitizedName
-        }
-    };
-}
-function sanitizeToolCall(call, rules, stats) {
-    if (!call?.function) {
-        return call;
-    }
-    const sanitizedName = sanitizeName(call.function.name, rules, stats, 'tool_call.function.name');
-    if (sanitizedName === call.function.name) {
-        return call;
-    }
-    return {
-        ...call,
-        function: {
-            ...call.function,
-            name: sanitizedName
-        }
-    };
-}
 function sanitizeChatCompletionChoice(choice, rules, stats) {
     const message = choice?.message;
     if (!message || typeof message !== 'object') {
@@ -189,10 +150,6 @@ function createStats(protocol, direction) {
 function sanitizeName(rawName, rules, stats, field) {
     const defaultName = rules.defaultName ?? 'tool';
     let next = typeof rawName === 'string' ? rawName : '';
-    const nativeSanitized = sanitizeResponsesFunctionNameWithNative(next);
-    if (typeof nativeSanitized === 'string' && nativeSanitized.trim().length) {
-        next = nativeSanitized;
-    }
     let changed = false;
     if (rules.trimWhitespace !== false) {
         next = next.trim();