@jsonstudio/llms 0.6.2172 → 0.6.2979

package/README.md

@@ -23,6 +23,8 @@
 
 👉 **ServerTool 是所有 server-side 工具的唯一统一框架。** web_search / vision followup 等服务端工具均在 llmswitch-core 内部通过 ServerTool 执行，Host 只需提供 providerInvoker/reenterPipeline 即可。设计与接入方式详见 `docs/SERVERTOOL_DESIGN.md`。
 
+👉 **Rust 逐步替换门禁与 Shadow 条件**：参见 `docs/rust-migration-gates.md`。
+
 ## 总览
 
 ```

package/dist/conversion/compat/antigravity-session-signature.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
+import { cacheAntigravitySessionSignatureWithNative, getAntigravityRequestSessionMetaWithNative, resetAntigravitySignatureCachesWithNative } from '../../router/virtual-router/engine-selection/native-router-hotpath.js';
 const DUMMY_THOUGHT_SIGNATURE_SENTINEL = 'skip_thought_signature_validator';
 // Antigravity-Manager alignment:
 // - session_id has no time limit (continuity across long conversations / restarts)
@@ -693,7 +694,23 @@ export function getAntigravityRequestSessionMeta(requestId) {
     }
     const entry = requestSessionIds.get(rid);
     if (!entry) {
-        return undefined;
+        try {
+            const nativeMeta = getAntigravityRequestSessionMetaWithNative(rid);
+            const sid = typeof nativeMeta.sessionId === 'string' ? nativeMeta.sessionId.trim() : '';
+            if (!sid) {
+                return undefined;
+            }
+            const alias = normalizeAliasKey(nativeMeta.aliasKey);
+            const messageCount = typeof nativeMeta.messageCount === 'number' && Number.isFinite(nativeMeta.messageCount) && nativeMeta.messageCount > 0
+                ? Math.floor(nativeMeta.messageCount)
+                : 1;
+            const ts = nowMs();
+            requestSessionIds.set(rid, { aliasKey: alias, sessionId: sid, messageCount, timestamp: ts });
+            return { aliasKey: alias, sessionId: sid, messageCount };
+        }
+        catch {
+            return undefined;
+        }
     }
     const ts = nowMs();
     if (isRequestSessionExpired(entry, ts)) {
@@ -809,6 +826,17 @@ export function cacheAntigravitySessionSignature(a, b, c, d = 1) {
     maybePinAntigravitySessionToAlias(aliasKey, sessionId, ts);
     ensureCacheLimit();
     schedulePersistenceFlush();
+    try {
+        cacheAntigravitySessionSignatureWithNative({
+            aliasKey,
+            sessionId,
+            signature: trimmedSignature,
+            messageCount
+        });
+    }
+    catch {
+        // best-effort native sync; TS cache remains source for persistence semantics
+    }
 }
 function maybePinAntigravitySessionToAlias(aliasKeyInput, sessionIdInput, ts) {
     const aliasKey = normalizeAliasKey(aliasKeyInput);
@@ -1063,6 +1091,12 @@ export function resetAntigravitySessionSignatureCachesForTests() {
         persistence.loadedOnce = false;
         persistence.loadedMtimeMs = null;
     }
+    try {
+        resetAntigravitySignatureCachesWithNative();
+    }
+    catch {
+        // best-effort
+    }
 }
 export function shouldTreatAsMissingThoughtSignature(value) {
     if (typeof value !== 'string') {

package/dist/conversion/compat/profiles/chat-gemini-cli.json

@@ -5,8 +5,6 @@
     "mappings": [
       { "action": "snapshot", "phase": "compat-pre" },
       { "action": "claude_thinking_tool_schema" },
-      { "action": "antigravity_thought_signature_prepare" },
-      { "action": "gemini_cli_request_wrap" },
       {
         "action": "shallow_pick",
         "allowTopLevel": [
@@ -21,10 +19,5 @@
       },
       { "action": "snapshot", "phase": "compat-post" }
     ]
-  },
-  "response": {
-    "mappings": [
-      { "action": "antigravity_thought_signature_cache" }
-    ]
   }
 }

package/dist/conversion/compat/profiles/chat-gemini.json

@@ -5,7 +5,6 @@
     "mappings": [
       { "action": "snapshot", "phase": "compat-pre" },
       { "action": "claude_thinking_tool_schema" },
-      { "action": "antigravity_thought_signature_prepare" },
       {
         "action": "gemini_web_search_request"
       },
@@ -28,10 +27,5 @@
       },
       { "action": "snapshot", "phase": "compat-post" }
     ]
-  },
-  "response": {
-    "mappings": [
-      { "action": "antigravity_thought_signature_cache" }
-    ]
   }
 }

package/dist/conversion/hub/core/detour-registry.d.ts

@@ -1,5 +1,7 @@
 import type { DetourEntry, DetourState } from '../types/chat-schema.js';
 import type { HubDirection } from './hub-context.js';
+import type { NativeReqInboundSemanticLiftApplyInput } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export type DetourRegistryNativeEnvelope = NativeReqInboundSemanticLiftApplyInput['chatEnvelope'];
 export declare class DetourRegistry {
     private readonly inbound;
     private readonly outbound;

package/dist/conversion/hub/core/hub-context.d.ts

@@ -1,8 +1,10 @@
 import type { JsonObject, JsonValue } from '../types/json.js';
+import type { NativeProviderProtocolToken } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 export type HubDirection = 'inbound' | 'outbound';
+export type HubNativeProtocolToken = NativeProviderProtocolToken;
 export interface HubContext {
     readonly requestId: string;
-    readonly protocol: string;
+    readonly protocol: HubNativeProtocolToken;
     readonly direction: HubDirection;
     readonly routeId?: string;
     readonly providerId?: string;

package/dist/conversion/hub/core/index.d.ts

@@ -1,3 +1,4 @@
 export * from './hub-context.js';
 export * from './detour-registry.js';
 export * from './stage-driver.js';
+export type { NativeReqInboundSemanticLiftApplyInput as HubCoreNativeReqInboundSemanticLiftApplyInput } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';

package/dist/conversion/hub/core/stage-driver.js

@@ -1,5 +1,6 @@
 import { DetourRegistry } from './detour-registry.js';
 import { jsonClone } from '../types/json.js';
+import { normalizeProviderProtocolTokenWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 function recordSnapshot(recorder, stage, ctx, payload) {
     if (!recorder)
         return;
@@ -12,6 +13,7 @@ function recordSnapshot(recorder, stage, ctx, payload) {
 }
 export async function runHubPlan(options) {
     const { plan, context, initialInput, recorder } = options;
+    normalizeProviderProtocolTokenWithNative(plan.protocol || context.protocol);
     if (!plan.stages?.length && !plan.passthrough) {
         throw new Error(`Hub plan for ${plan.protocol} has neither stages nor passthrough`);
     }

package/dist/conversion/hub/format-adapters/anthropic-format-adapter.js

@@ -1,23 +1,34 @@
 import { normalizeReasoningInAnthropicPayload } from '../../shared/reasoning-normalizer.js';
+import { parseReqInboundFormatEnvelopeWithNative, parseRespInboundFormatEnvelopeWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
 export class AnthropicFormatAdapter {
     protocol = 'anthropic-messages';
     async parseRequest(original, _ctx) {
-        normalizeReasoningInAnthropicPayload(original);
+        const parsed = parseReqInboundFormatEnvelopeWithNative({
+            rawRequest: original,
+            protocol: this.protocol
+        });
+        const payload = parsed.payload;
+        normalizeReasoningInAnthropicPayload(payload);
         return {
             protocol: this.protocol,
             direction: 'request',
-            payload: original
+            payload
         };
     }
     async buildRequest(format, _ctx) {
         return format.payload;
     }
     async parseResponse(original, _ctx) {
-        normalizeReasoningInAnthropicPayload(original);
+        const parsed = parseRespInboundFormatEnvelopeWithNative({
+            payload: original,
+            protocol: this.protocol
+        });
+        const payload = parsed.payload;
+        normalizeReasoningInAnthropicPayload(payload);
         return {
             protocol: this.protocol,
             direction: 'response',
-            payload: original
+            payload
         };
     }
     async buildResponse(format, _ctx) {

package/dist/conversion/hub/format-adapters/chat-format-adapter.js

@@ -1,23 +1,34 @@
 import { normalizeReasoningInChatPayload } from '../../shared/reasoning-normalizer.js';
+import { parseReqInboundFormatEnvelopeWithNative, parseRespInboundFormatEnvelopeWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
 export class ChatFormatAdapter {
     protocol = 'openai-chat';
     async parseRequest(original, _ctx) {
-        normalizeReasoningInChatPayload(original);
+        const parsed = parseReqInboundFormatEnvelopeWithNative({
+            rawRequest: original,
+            protocol: this.protocol
+        });
+        const payload = parsed.payload;
+        normalizeReasoningInChatPayload(payload);
         return {
             protocol: this.protocol,
             direction: 'request',
-            payload: original
+            payload
         };
     }
     async buildRequest(format, _ctx) {
         return format.payload;
     }
     async parseResponse(original, _ctx) {
-        normalizeReasoningInChatPayload(original);
+        const parsed = parseRespInboundFormatEnvelopeWithNative({
+            payload: original,
+            protocol: this.protocol
+        });
+        const payload = parsed.payload;
+        normalizeReasoningInChatPayload(payload);
         return {
             protocol: this.protocol,
             direction: 'response',
-            payload: original
+            payload
         };
     }
     async buildResponse(format, _ctx) {

package/dist/conversion/hub/format-adapters/gemini-format-adapter.js

@@ -1,23 +1,34 @@
 import { normalizeReasoningInGeminiPayload } from '../../shared/reasoning-normalizer.js';
+import { parseReqInboundFormatEnvelopeWithNative, parseRespInboundFormatEnvelopeWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
 export class GeminiFormatAdapter {
     protocol = 'gemini-chat';
     async parseRequest(original, _ctx) {
-        normalizeReasoningInGeminiPayload(original);
+        const parsed = parseReqInboundFormatEnvelopeWithNative({
+            rawRequest: original,
+            protocol: this.protocol
+        });
+        const payload = parsed.payload;
+        normalizeReasoningInGeminiPayload(payload);
         return {
             protocol: this.protocol,
             direction: 'request',
-            payload: original
+            payload
         };
     }
     async buildRequest(format, _ctx) {
         return format.payload;
     }
     async parseResponse(original, _ctx) {
-        normalizeReasoningInGeminiPayload(original);
+        const parsed = parseRespInboundFormatEnvelopeWithNative({
+            payload: original,
+            protocol: this.protocol
+        });
+        const payload = parsed.payload;
+        normalizeReasoningInGeminiPayload(payload);
         return {
             protocol: this.protocol,
             direction: 'response',
-            payload: original
+            payload
         };
     }
     async buildResponse(format, _ctx) {

package/dist/conversion/hub/format-adapters/responses-format-adapter.js

@@ -1,29 +1,40 @@
 import { normalizeReasoningInResponsesPayload } from '../../shared/reasoning-normalizer.js';
+import { parseReqInboundFormatEnvelopeWithNative, parseRespInboundFormatEnvelopeWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
 export class ResponsesFormatAdapter {
     protocol = 'openai-responses';
     async parseRequest(original, _ctx) {
-        normalizeReasoningInResponsesPayload(original, {
+        const parsed = parseReqInboundFormatEnvelopeWithNative({
+            rawRequest: original,
+            protocol: this.protocol
+        });
+        const payload = parsed.payload;
+        normalizeReasoningInResponsesPayload(payload, {
             includeInput: true,
             includeInstructions: true
         });
         return {
             protocol: this.protocol,
             direction: 'request',
-            payload: original
+            payload
         };
     }
     async buildRequest(format, _ctx) {
         return format.payload;
     }
     async parseResponse(original, _ctx) {
-        normalizeReasoningInResponsesPayload(original, {
+        const parsed = parseRespInboundFormatEnvelopeWithNative({
+            payload: original,
+            protocol: this.protocol
+        });
+        const payload = parsed.payload;
+        normalizeReasoningInResponsesPayload(payload, {
             includeOutput: true,
             includeRequiredAction: true
         });
         return {
             protocol: this.protocol,
             direction: 'response',
-            payload: original
+            payload
         };
     }
     async buildResponse(format, _ctx) {

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

@@ -1,3 +1,4 @@
+import { normalizeProviderProtocolTokenWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 const DISABLE_FLAG = (process.env.ROUTECODEX_HUB_ENABLED || process.env.ROUTECODEX_ENABLE_HUB) ?? '1';
 const PROTOCOL_LIST = process.env.ROUTECODEX_HUB_PROTOCOLS;
 function parseProtocolList(input) {
@@ -5,7 +6,7 @@ function parseProtocolList(input) {
         return null;
     const entries = input
         .split(',')
-        .map((token) => token.trim().toLowerCase())
+        .map((token) => normalizeProviderProtocolTokenWithNative(token) ?? token.trim().toLowerCase())
         .filter(Boolean);
     if (!entries.length) {
         return null;
@@ -20,6 +21,6 @@ export function isHubProtocolEnabled(protocol) {
     if (!normalizedList) {
         return true;
     }
-    const normalizedProtocol = protocol.trim().toLowerCase();
+    const normalizedProtocol = normalizeProviderProtocolTokenWithNative(protocol) ?? protocol.trim().toLowerCase();
     return normalizedList.has(normalizedProtocol);
 }

package/dist/conversion/hub/node-support.js

@@ -1,10 +1,11 @@
 import { createProtocolPlans } from './registry.js';
 import { runInboundPipeline } from './pipelines/inbound.js';
 import { runOutboundPipeline } from './pipelines/outbound.js';
-import { chatEnvelopeToStandardized, standardizedToChatEnvelope } from './standardized-bridge.js';
 import { createSnapshotRecorder } from './snapshot-recorder.js';
 import { ConversionError } from './types/errors.js';
 import { isHubProtocolEnabled } from './hub-feature.js';
+import { chatEnvelopeToStandardizedWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+import { standardizedToChatEnvelopeWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
 export function shouldUseHub(protocol) {
     return isHubProtocolEnabled(protocol);
 }
@@ -19,8 +20,9 @@ export async function runHubInboundConversion(options) {
         plan: inbound,
         stageRecorder
     });
-    const standardized = chatEnvelopeToStandardized(chatEnvelope, {
-        adapterContext,
+    const standardized = chatEnvelopeToStandardizedWithNative({
+        chatEnvelope: chatEnvelope,
+        adapterContext: adapterContext,
         endpoint: options.nodeContext.request.endpoint,
         requestId: options.nodeContext.request.id
     });
@@ -38,7 +40,10 @@ export async function runHubOutboundConversion(options) {
     // A /v1/responses request routed to an anthropic upstream is still a responses *entry* request.
     const stageRecorder = maybeCreateStageRecorder(adapterContext, options.nodeContext.request.endpoint);
     const { outbound } = createProtocolPlans(options.protocol);
-    const chatEnvelope = standardizedToChatEnvelope(options.request, { adapterContext });
+    const chatEnvelope = standardizedToChatEnvelopeWithNative({
+        request: options.request,
+        adapterContext: adapterContext
+    });
     const payload = await runOutboundPipeline({
         chat: chatEnvelope,
         context: adapterContext,

package/dist/conversion/hub/operation-table/operation-table-runner.js

@@ -1,5 +1,6 @@
 import { createBridgeActionState, runBridgeActionPipeline } from '../../shared/bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from '../../shared/bridge-policies.js';
+import { normalizeProviderProtocolTokenWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 const INBOUND_BRIDGE_SPECS = {
     'openai-chat': { protocol: 'openai-chat', stage: 'request_inbound', messages: 'chat_envelope' },
     // Keep parity with the legacy semantic mapper behavior: do not pass messages[] into the action state
@@ -17,10 +18,11 @@ const OUTBOUND_BRIDGE_SPECS = {
     'gemini-chat': { protocol: 'gemini-chat', stage: 'request_outbound', messages: 'chat_envelope', includeCapturedToolResults: true }
 };
 function isSupportedProtocol(protocol) {
-    return protocol === 'openai-chat' ||
-        protocol === 'openai-responses' ||
-        protocol === 'anthropic-messages' ||
-        protocol === 'gemini-chat';
+    const normalizedProtocol = normalizeProviderProtocolTokenWithNative(protocol) ?? protocol;
+    return normalizedProtocol === 'openai-chat' ||
+        normalizedProtocol === 'openai-responses' ||
+        normalizedProtocol === 'anthropic-messages' ||
+        normalizedProtocol === 'gemini-chat';
 }
 function extractPayloadMessages(payload) {
     const value = payload?.messages;
@@ -109,7 +111,8 @@ function rebuildGeminiToolOutputsFromMessages(chatEnvelope) {
     chatEnvelope.toolOutputs = outputs.length ? outputs : undefined;
 }
 export function applyHubOperationTableInbound(options) {
-    const protocol = options.formatEnvelope.protocol;
+    const protocol = normalizeProviderProtocolTokenWithNative(options.formatEnvelope.protocol)
+        ?? options.formatEnvelope.protocol;
     if (!isSupportedProtocol(protocol)) {
         return;
     }
@@ -142,7 +145,8 @@ export function applyHubOperationTableOutboundPreMap(options) {
     })();
 }
 export function applyHubOperationTableOutboundPostMap(options) {
-    const protocol = options.formatEnvelope.protocol;
+    const protocol = normalizeProviderProtocolTokenWithNative(options.formatEnvelope.protocol)
+        ?? options.formatEnvelope.protocol;
     if (!isSupportedProtocol(protocol)) {
         return;
     }

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

@@ -1,7 +1,7 @@
 import { isJsonObject, jsonClone } from '../../types/json.js';
 import { buildOpenAIChatFromAnthropic, buildAnthropicRequestFromOpenAIChat } from '../../../codecs/anthropic-openai-codec.js';
 import { encodeMetadataPassthrough, extractMetadataPassthrough } from '../../../shared/metadata-passthrough.js';
-import { buildAnthropicToolAliasMap } from '../../../shared/anthropic-message-utils.js';
+import { buildAnthropicToolAliasMapWithNative } from '../../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
 import { ChatSemanticMapper } from './chat-mapper.js';
 const ANTHROPIC_PARAMETER_KEYS = [
     'model',
@@ -279,7 +279,7 @@ export class AnthropicSemanticMapper {
         if (payload.tools && Array.isArray(payload.tools) && payload.tools.length === 0) {
             markExplicitEmptyTools(chatEnvelope);
         }
-        const aliasMap = buildAnthropicToolAliasMap(payload.tools);
+        const aliasMap = buildAnthropicToolAliasMapWithNative(payload.tools);
         if (aliasMap) {
             const toolsNode = ensureToolsSemanticsNode(chatEnvelope);
             toolsNode.toolNameAliasMap = jsonClone(aliasMap);

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

@@ -1,6 +1,7 @@
 import { isJsonObject, jsonClone } from '../../types/json.js';
-import { normalizeChatMessageContent } from '../../../shared/chat-output-normalizer.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',
@@ -163,7 +164,7 @@ function normalizeChatMessages(raw) {
         }
         const chatMessage = value;
         if (roleValue !== 'system' && roleValue !== 'tool') {
-            const normalizedContent = normalizeChatMessageContent(chatMessage.content);
+            const normalizedContent = normalizeChatMessageContentWithNative(chatMessage.content);
             const shouldOverwriteContent = !Array.isArray(chatMessage.content);
             if (shouldOverwriteContent && normalizedContent.contentText !== undefined) {
                 chatMessage.content = normalizedContent.contentText;
@@ -242,16 +243,15 @@ function normalizeStandaloneToolOutputs(raw, missing) {
     return outputs;
 }
 function normalizeTools(raw, missing) {
-    if (!Array.isArray(raw) || raw.length === 0)
+    if (!Array.isArray(raw) || raw.length === 0) {
         return undefined;
-    const tools = [];
-    raw.forEach((entry, index) => {
-        if (!isJsonObject(entry)) {
+    }
+    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.push(entry);
-    });
+        });
+    }
     return tools.length ? tools : undefined;
 }
 function extractParameters(body) {

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

@@ -5,8 +5,8 @@ import { mapBridgeToolsToChat, mapChatToolsToBridge } from '../../../shared/tool
 import { prepareGeminiToolsForBridge, buildGeminiToolsFromBridge } from '../../../shared/gemini-tool-utils.js';
 import { ensureProtocolState, getProtocolState } from '../../../shared/protocol-state.js';
 import { sanitizeReasoningTaggedText } from '../../../shared/reasoning-utils.js';
-import { applyClaudeThinkingToolSchemaCompat } from '../../../compat/actions/claude-thinking-tools.js';
-import { extractAntigravityGeminiSessionId } from '../../../compat/antigravity-session-signature.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';
 const GENERATION_CONFIG_KEYS = [
     { source: 'temperature', target: 'temperature' },
     { source: 'topP', target: 'top_p' },
@@ -280,10 +280,6 @@ function resolveAntigravityRequestConfig(options) {
     const enableNetworking = wantsNetworking;
     let finalModel = stripOnlineSuffix(mapped);
     finalModel = normalizePreviewAlias(finalModel);
-    // Only gemini-2.5-flash reliably supports googleSearch in v1internal; downgrade for networking.
-    if (enableNetworking && finalModel !== 'gemini-2.5-flash') {
-        finalModel = 'gemini-2.5-flash';
-    }
     return {
         requestType: enableNetworking ? 'web_search' : 'agent',
         injectGoogleSearch: enableNetworking,
@@ -1098,13 +1094,13 @@ function buildGeminiRequestFromChat(chat, metadata) {
         request.metadata = request.metadata ?? {};
         const existing = request.metadata.antigravitySessionId;
         if (typeof existing !== 'string' || !existing.trim()) {
-            request.metadata.antigravitySessionId = extractAntigravityGeminiSessionId(request);
+            request.metadata.antigravitySessionId = extractAntigravityGeminiSessionIdWithNative(request);
         }
     }
     // Apply claude-thinking compat at Gemini mapping time to ensure it is always active
     // for Claude models, regardless of compatibilityProfile wiring. Provider层负责进一步的
     // 传输层收紧（如 session_id / generationConfig），这里不做非标裁剪。
-    const compatRequest = applyClaudeThinkingToolSchemaCompat(request, adapterContext);
+    const compatRequest = applyClaudeThinkingToolSchemaCompatWithNative(request);
     return compatRequest;
 }
 function sanitizeAntigravityToolCallId(raw) {

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

@@ -1,6 +1,7 @@
 import { isJsonObject, jsonClone } from '../../types/json.js';
 import { captureResponsesContext, buildChatRequestFromResponses, buildResponsesRequestFromChat } from '../../../responses/responses-openai-bridge.js';
 import { maybeAugmentApplyPatchErrorContent } from './chat-mapper.js';
+import { mapReqInboundBridgeToolsToChatWithNative, mapReqInboundResumeToolOutputsDetailedWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 const RESPONSES_PARAMETER_KEYS = [
     'model',
     'temperature',
@@ -65,31 +66,14 @@ function deriveResumeToolOutputsFromResume(resume) {
     if (!resume || typeof resume !== 'object') {
         return undefined;
     }
-    const detailed = Array.isArray(resume.toolOutputsDetailed)
-        ? resume.toolOutputsDetailed
-        : undefined;
-    if (!detailed || detailed.length === 0) {
+    const mapped = mapReqInboundResumeToolOutputsDetailedWithNative(resume);
+    if (!Array.isArray(mapped) || mapped.length === 0) {
         return undefined;
     }
-    const outputs = [];
-    detailed.forEach((entry, index) => {
-        if (!entry || typeof entry !== 'object') {
-            return;
-        }
-        const callIdRaw = typeof entry.callId === 'string' && entry.callId.trim().length
-            ? entry.callId.trim()
-            : typeof entry.originalId === 'string' && entry.originalId.trim().length
-                ? entry.originalId.trim()
-                : `resume_tool_${index}`;
-        if (!callIdRaw) {
-            return;
-        }
-        const outputText = typeof entry.outputText === 'string' ? entry.outputText : '';
-        outputs.push({
-            tool_call_id: callIdRaw,
-            content: outputText
-        });
-    });
+    const outputs = mapped.map((entry) => ({
+        tool_call_id: entry.tool_call_id,
+        content: entry.content
+    }));
     return outputs.length ? outputs : undefined;
 }
 function collectParameters(payload, streamHint) {
@@ -105,35 +89,15 @@ function collectParameters(payload, streamHint) {
     return Object.keys(params).length ? params : undefined;
 }
 function normalizeTools(rawTools, missing) {
-    if (!rawTools || rawTools.length === 0)
+    if (!rawTools || rawTools.length === 0) {
         return undefined;
-    const tools = [];
-    rawTools.forEach((tool, index) => {
-        if (!tool || typeof tool !== 'object' || Array.isArray(tool)) {
+    }
+    const tools = mapReqInboundBridgeToolsToChatWithNative(rawTools);
+    if (tools.length === 0) {
+        rawTools.forEach((tool, index) => {
             missing.push({ path: `tools[${index}]`, reason: 'invalid_entry', originalValue: jsonClone(tool) });
-            return;
-        }
-        const fn = tool.function;
-        if (!fn || typeof fn !== 'object' || Array.isArray(fn))
-            return;
-        const name = fn.name;
-        const nameValue = typeof name === 'string' ? name : undefined;
-        if (!nameValue)
-            return;
-        const descriptionValue = fn.description;
-        const parametersValue = fn.parameters;
-        const strictValue = fn.strict;
-        const definition = {
-            type: 'function',
-            function: {
-                name: nameValue,
-                description: typeof descriptionValue === 'string' ? descriptionValue : undefined,
-                parameters: parametersValue,
-                strict: typeof strictValue === 'boolean' ? strictValue : undefined
-            }
-        };
-        tools.push(definition);
-    });
+        });
+    }
     return tools.length ? tools : undefined;
 }
 function normalizeMessages(value, missing) {
@@ -364,21 +328,11 @@ function collectSubmitToolOutputs(chat, responsesContext) {
     }
     if (!outputs.length) {
         const resume = readResponsesResumeFromSemantics(chat);
-        const detailed = Array.isArray(resume?.toolOutputsDetailed)
-            ? (resume.toolOutputsDetailed ?? undefined)
-            : undefined;
-        if (detailed) {
-            detailed.forEach((entry, index) => {
-                if (!entry || typeof entry !== 'object') {
-                    return;
-                }
-                const callId = typeof entry.callId === 'string' && entry.callId.trim().length
-                    ? entry.callId.trim()
-                    : typeof entry.originalId === 'string' && entry.originalId.trim().length
-                        ? entry.originalId.trim()
-                        : `resume_tool_${index + 1}`;
-                append(callId, typeof entry.outputText === 'string' ? entry.outputText : entry.outputText ?? '');
-            });
+        if (resume) {
+            const resumeOutputs = deriveResumeToolOutputsFromResume(resume);
+            if (resumeOutputs?.length) {
+                resumeOutputs.forEach((entry) => append(entry.tool_call_id, entry.content, entry.name));
+            }
         }
     }
     return outputs;