@jsonstudio/llms 0.6.2172 → 0.6.3214

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/args-mapping.js

@@ -0,0 +1,8 @@
+import { normalizeArgsBySchemaWithNative, normalizeToolsWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function normalizeArgsBySchema(input, schema) {
+    return normalizeArgsBySchemaWithNative(input, schema);
+}
+// Tools normalizer (OpenAI-like)
+export function normalizeTools(tools) {
+    return normalizeToolsWithNative(tools);
+}

package/dist/conversion/bridge-actions.js

@@ -0,0 +1,367 @@
+import { applyBridgeCaptureToolResultsWithNative, applyBridgeEnsureToolPlaceholdersWithNative, applyBridgeNormalizeHistoryWithNative, applyBridgeNormalizeToolIdentifiersWithNative, applyBridgeEnsureSystemInstructionWithNative, applyBridgeInjectSystemInstructionWithNative, applyBridgeMetadataActionWithNative, applyBridgeReasoningExtractWithNative, applyBridgeResponsesOutputReasoningWithNative, ensureBridgeOutputFieldsWithNative } from '../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
+const registry = new Map();
+export function registerBridgeAction(name, action) {
+    registry.set(name, action);
+}
+export function createBridgeActionState(seed) {
+    const state = {
+        messages: Array.isArray(seed?.messages) ? seed.messages : []
+    };
+    if (seed?.requiredAction)
+        state.requiredAction = seed.requiredAction;
+    if (seed?.capturedToolResults)
+        state.capturedToolResults = seed.capturedToolResults;
+    if (seed?.rawRequest)
+        state.rawRequest = seed.rawRequest;
+    if (seed?.rawResponse)
+        state.rawResponse = seed.rawResponse;
+    if (seed?.metadata)
+        state.metadata = seed.metadata;
+    return state;
+}
+export function runBridgeActionPipeline(options) {
+    const { stage, actions, protocol, moduleType, requestId, state } = options;
+    if (!actions?.length)
+        return;
+    for (const descriptor of actions) {
+        if (!descriptor || typeof descriptor !== 'object')
+            continue;
+        const action = registry.get(descriptor.name);
+        if (!action)
+            continue;
+        try {
+            action({
+                stage,
+                protocol,
+                moduleType,
+                requestId,
+                descriptor,
+                state
+            });
+        }
+        catch {
+            // Ignore action failures to preserve core flow; telemetry hooks can be added later.
+        }
+    }
+}
+function ensureMessagesArray(state) {
+    if (!Array.isArray(state.messages)) {
+        state.messages = [];
+    }
+    return state.messages;
+}
+function ensureMetadataRecord(state) {
+    if (!state.metadata || typeof state.metadata !== 'object') {
+        state.metadata = {};
+    }
+    return state.metadata;
+}
+const injectSystemInstructionAction = (ctx) => {
+    const messages = ensureMessagesArray(ctx.state);
+    const normalized = applyBridgeInjectSystemInstructionWithNative({
+        stage: ctx.stage,
+        options: ctx.descriptor.options && typeof ctx.descriptor.options === 'object'
+            ? ctx.descriptor.options
+            : undefined,
+        messages,
+        rawRequest: ctx.state.rawRequest && typeof ctx.state.rawRequest === 'object'
+            ? ctx.state.rawRequest
+            : undefined
+    });
+    if (Array.isArray(normalized.messages)) {
+        applyMessagesInPlace(messages, normalized.messages);
+        ctx.state.messages = messages;
+    }
+};
+const ensureToolResponsePlaceholders = (ctx) => {
+    const messages = ensureMessagesArray(ctx.state);
+    if (!messages.length)
+        return;
+    const output = applyBridgeEnsureToolPlaceholdersWithNative({
+        stage: ctx.stage,
+        messages,
+        capturedToolResults: Array.isArray(ctx.state.capturedToolResults)
+            ? ctx.state.capturedToolResults
+            : undefined,
+        rawRequest: ctx.state.rawRequest && typeof ctx.state.rawRequest === 'object'
+            ? ctx.state.rawRequest
+            : undefined,
+        rawResponse: ctx.state.rawResponse && typeof ctx.state.rawResponse === 'object'
+            ? ctx.state.rawResponse
+            : undefined
+    });
+    if (Array.isArray(output.messages)) {
+        applyMessagesInPlace(messages, output.messages);
+        ctx.state.messages = messages;
+    }
+    ctx.state.capturedToolResults = applyCapturedToolResultsInPlace(ctx.state.capturedToolResults, output.toolOutputs);
+};
+const extractReasoningAction = (ctx) => {
+    const messages = ensureMessagesArray(ctx.state);
+    if (!messages.length)
+        return;
+    const dropFromContent = ctx.descriptor.options?.dropFromContent !== false;
+    const idPrefixBase = typeof ctx.descriptor.options?.idPrefix === 'string' && ctx.descriptor.options.idPrefix.trim().length
+        ? ctx.descriptor.options.idPrefix.trim()
+        : `${ctx.protocol ?? 'bridge'}_${ctx.stage}`;
+    const normalized = applyBridgeReasoningExtractWithNative({
+        messages,
+        dropFromContent,
+        idPrefixBase
+    });
+    if (Array.isArray(normalized.messages)) {
+        applyMessagesInPlace(messages, normalized.messages);
+        ctx.state.messages = messages;
+    }
+};
+registerBridgeAction('messages.inject-system-instruction', injectSystemInstructionAction);
+registerBridgeAction('reasoning.extract', extractReasoningAction);
+registerBridgeAction('tools.ensure-response-placeholders', ensureToolResponsePlaceholders);
+// (intentionally no-op: capture handled in responses-format normalization)
+const ensureSystemInstructionAction = (ctx) => {
+    const messages = ensureMessagesArray(ctx.state);
+    const normalized = applyBridgeEnsureSystemInstructionWithNative({
+        stage: ctx.stage,
+        messages,
+        metadata: ctx.state.metadata && typeof ctx.state.metadata === 'object'
+            ? ctx.state.metadata
+            : undefined
+    });
+    if (Array.isArray(normalized.messages)) {
+        applyMessagesInPlace(messages, normalized.messages);
+        ctx.state.messages = messages;
+    }
+    const metadata = applyObjectInPlace(ctx.state.metadata, normalized.metadata);
+    if (metadata) {
+        ctx.state.metadata = metadata;
+    }
+};
+const normalizeHistoryAction = (ctx) => {
+    if (ctx.stage !== 'request_outbound') {
+        return;
+    }
+    const messages = ensureMessagesArray(ctx.state);
+    if (!messages.length) {
+        return;
+    }
+    const toolsNode = ctx.state.rawRequest &&
+        typeof ctx.state.rawRequest === 'object' &&
+        Array.isArray(ctx.state.rawRequest.tools)
+        ? ctx.state.rawRequest.tools
+        : undefined;
+    const normalized = applyBridgeNormalizeHistoryWithNative({
+        messages,
+        tools: toolsNode
+    });
+    if (Array.isArray(normalized.messages)) {
+        applyMessagesInPlace(messages, normalized.messages);
+        ctx.state.messages = messages;
+    }
+    if (normalized.bridgeHistory && typeof normalized.bridgeHistory === 'object' && !Array.isArray(normalized.bridgeHistory)) {
+        const metadata = ensureMetadataRecord(ctx.state);
+        metadata.bridgeHistory = normalized.bridgeHistory;
+    }
+};
+const ensureOutputFieldsAction = (ctx) => {
+    if (ctx.stage !== 'request_outbound') {
+        return;
+    }
+    const messages = ensureMessagesArray(ctx.state);
+    if (!messages.length) {
+        return;
+    }
+    const fallback = typeof ctx.descriptor.options?.toolFallback === 'string' && ctx.descriptor.options.toolFallback.trim().length
+        ? ctx.descriptor.options.toolFallback.trim()
+        : 'Tool call completed (no output).';
+    const assistantFallback = typeof ctx.descriptor.options?.assistantFallback === 'string' && ctx.descriptor.options.assistantFallback.trim().length
+        ? ctx.descriptor.options.assistantFallback.trim()
+        : 'Assistant response unavailable.';
+    const normalized = ensureBridgeOutputFieldsWithNative({
+        messages,
+        toolFallback: fallback,
+        assistantFallback
+    });
+    if (Array.isArray(normalized.messages)) {
+        applyMessagesInPlace(messages, normalized.messages);
+        ctx.state.messages = messages;
+    }
+};
+const ensureToolPlaceholdersAction = (ctx) => {
+    ensureToolResponsePlaceholders(ctx);
+};
+const captureToolResultsAction = (ctx) => {
+    const output = applyBridgeCaptureToolResultsWithNative({
+        stage: ctx.stage,
+        capturedToolResults: Array.isArray(ctx.state.capturedToolResults)
+            ? ctx.state.capturedToolResults
+            : undefined,
+        rawRequest: ctx.state.rawRequest && typeof ctx.state.rawRequest === 'object'
+            ? ctx.state.rawRequest
+            : undefined,
+        rawResponse: ctx.state.rawResponse && typeof ctx.state.rawResponse === 'object'
+            ? ctx.state.rawResponse
+            : undefined,
+        metadata: ctx.state.metadata && typeof ctx.state.metadata === 'object'
+            ? ctx.state.metadata
+            : undefined
+    });
+    ctx.state.capturedToolResults = applyCapturedToolResultsInPlace(ctx.state.capturedToolResults, output.capturedToolResults);
+    const metadata = applyObjectInPlace(ctx.state.metadata, output.metadata);
+    if (metadata) {
+        ctx.state.metadata = metadata;
+    }
+};
+const attachReasoningOutputAction = (ctx) => {
+    responsesOutputReasoningAction(ctx);
+};
+registerBridgeAction('messages.ensure-system-instruction', ensureSystemInstructionAction);
+registerBridgeAction('messages.normalize-history', normalizeHistoryAction);
+registerBridgeAction('messages.ensure-output-fields', ensureOutputFieldsAction);
+registerBridgeAction('tools.ensure-placeholders', ensureToolPlaceholdersAction);
+registerBridgeAction('tools.capture-results', captureToolResultsAction);
+registerBridgeAction('reasoning.attach-output', attachReasoningOutputAction);
+function deriveToolIdPrefix(ctx) {
+    if (typeof ctx.descriptor.options?.idPrefix === 'string' && ctx.descriptor.options.idPrefix.trim().length) {
+        return ctx.descriptor.options.idPrefix.trim();
+    }
+    if (typeof ctx.requestId === 'string' && ctx.requestId.trim().length) {
+        const safe = ctx.requestId.trim().replace(/[^A-Za-z0-9]/g, '');
+        if (safe.length) {
+            return `${safe.slice(-24)}_tool`;
+        }
+    }
+    const base = ctx.protocol || 'bridge';
+    return `${base}_tool`;
+}
+function overwriteRecordInPlace(target, source) {
+    for (const key of Object.keys(target)) {
+        delete target[key];
+    }
+    for (const [key, value] of Object.entries(source)) {
+        target[key] = value;
+    }
+}
+function applyMessagesInPlace(current, next) {
+    const normalizedNext = next.filter((entry) => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry));
+    const nextLength = normalizedNext.length;
+    for (let i = 0; i < nextLength; i++) {
+        const nextEntry = normalizedNext[i];
+        const currentEntry = current[i];
+        if (currentEntry && typeof currentEntry === 'object' && !Array.isArray(currentEntry)) {
+            overwriteRecordInPlace(currentEntry, nextEntry);
+            continue;
+        }
+        current[i] = { ...nextEntry };
+    }
+    if (current.length > nextLength) {
+        current.splice(nextLength);
+    }
+}
+function applyObjectInPlace(current, next) {
+    if (!next || typeof next !== 'object' || Array.isArray(next)) {
+        return undefined;
+    }
+    const nextRecord = next;
+    if (current && typeof current === 'object' && !Array.isArray(current)) {
+        overwriteRecordInPlace(current, nextRecord);
+        return current;
+    }
+    return { ...nextRecord };
+}
+function applyCapturedToolResultsInPlace(current, next) {
+    if (!Array.isArray(next)) {
+        return current;
+    }
+    const normalizedNext = next
+        .filter((entry) => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry))
+        .map((entry) => ({ ...entry }));
+    if (!Array.isArray(current)) {
+        return normalizedNext;
+    }
+    current.splice(0, current.length, ...normalizedNext);
+    return current;
+}
+const normalizeToolIdentifiersAction = (ctx) => {
+    const messages = ensureMessagesArray(ctx.state);
+    const idPrefix = deriveToolIdPrefix(ctx);
+    const normalized = applyBridgeNormalizeToolIdentifiersWithNative({
+        stage: ctx.stage,
+        protocol: ctx.protocol,
+        moduleType: ctx.moduleType,
+        messages,
+        rawRequest: ctx.state.rawRequest,
+        capturedToolResults: Array.isArray(ctx.state.capturedToolResults)
+            ? ctx.state.capturedToolResults
+            : undefined,
+        idPrefix
+    });
+    if (Array.isArray(normalized.messages)) {
+        applyMessagesInPlace(messages, normalized.messages);
+        ctx.state.messages = messages;
+    }
+    const rawRequest = applyObjectInPlace(ctx.state.rawRequest, normalized.rawRequest);
+    if (rawRequest) {
+        ctx.state.rawRequest = rawRequest;
+    }
+    ctx.state.capturedToolResults = applyCapturedToolResultsInPlace(ctx.state.capturedToolResults, normalized.capturedToolResults);
+};
+registerBridgeAction('tools.normalize-call-ids', normalizeToolIdentifiersAction);
+const responsesOutputReasoningAction = (ctx) => {
+    if (ctx.stage !== 'response_inbound')
+        return;
+    const messages = ensureMessagesArray(ctx.state);
+    const normalized = applyBridgeResponsesOutputReasoningWithNative({
+        messages,
+        rawResponse: ctx.state.rawResponse && typeof ctx.state.rawResponse === 'object'
+            ? ctx.state.rawResponse
+            : undefined,
+        idPrefix: `${ctx.protocol ?? 'responses'}_${ctx.stage}_output`
+    });
+    if (Array.isArray(normalized.messages)) {
+        applyMessagesInPlace(messages, normalized.messages);
+        ctx.state.messages = messages;
+    }
+};
+registerBridgeAction('responses.output-reasoning', responsesOutputReasoningAction);
+function applyMetadataActionWithNative(ctx, actionName) {
+    const output = applyBridgeMetadataActionWithNative({
+        actionName,
+        stage: ctx.stage,
+        options: ctx.descriptor.options && typeof ctx.descriptor.options === 'object'
+            ? ctx.descriptor.options
+            : undefined,
+        rawRequest: ctx.state.rawRequest && typeof ctx.state.rawRequest === 'object'
+            ? ctx.state.rawRequest
+            : undefined,
+        rawResponse: ctx.state.rawResponse && typeof ctx.state.rawResponse === 'object'
+            ? ctx.state.rawResponse
+            : undefined,
+        metadata: ctx.state.metadata && typeof ctx.state.metadata === 'object'
+            ? ctx.state.metadata
+            : undefined
+    });
+    const rawRequest = applyObjectInPlace(ctx.state.rawRequest, output.rawRequest);
+    if (rawRequest) {
+        ctx.state.rawRequest = rawRequest;
+    }
+    const rawResponse = applyObjectInPlace(ctx.state.rawResponse, output.rawResponse);
+    if (rawResponse) {
+        ctx.state.rawResponse = rawResponse;
+    }
+    const metadata = applyObjectInPlace(ctx.state.metadata, output.metadata);
+    if (metadata) {
+        ctx.state.metadata = metadata;
+    }
+}
+const metadataExtraFieldsAction = (ctx) => {
+    applyMetadataActionWithNative(ctx, 'metadata.extra-fields');
+};
+const metadataProviderFieldAction = (ctx) => {
+    applyMetadataActionWithNative(ctx, 'metadata.provider-field');
+};
+const metadataProviderSentinelAction = (ctx) => {
+    applyMetadataActionWithNative(ctx, 'metadata.provider-sentinel');
+};
+registerBridgeAction('metadata.extra-fields', metadataExtraFieldsAction);
+registerBridgeAction('metadata.provider-field', metadataProviderFieldAction);
+registerBridgeAction('metadata.provider-sentinel', metadataProviderSentinelAction);

package/dist/conversion/bridge-id-utils.js

@@ -0,0 +1,13 @@
+import { clampResponsesInputItemIdWithNative, normalizeFunctionCallIdWithNative, normalizeFunctionCallOutputIdWithNative, normalizeResponsesCallIdWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function normalizeFunctionCallId(options) {
+    return normalizeFunctionCallIdWithNative(options);
+}
+export function normalizeFunctionCallOutputId(options) {
+    return normalizeFunctionCallOutputIdWithNative(options);
+}
+export function normalizeResponsesCallId(options) {
+    return normalizeResponsesCallIdWithNative(options);
+}
+export function clampResponsesInputItemId(raw) {
+    return clampResponsesInputItemIdWithNative(raw);
+}

package/dist/conversion/{shared/bridge-instructions.js → bridge-instructions.js}

@@ -1,3 +1,4 @@
+import { sanitizeReasoningTaggedTextWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 function collectTextFromBlocks(blocks) {
     const parts = [];
     for (const block of blocks) {
@@ -77,7 +78,7 @@ function extractSystemInstruction(entry) {
                 collected.push(text);
         }
     }
-    const merged = collected.join('\n').trim();
+    const merged = sanitizeReasoningTaggedTextWithNative(collected.join('\n')).trim();
     return merged ? merged : null;
 }
 export function ensureBridgeInstructions(payload) {

package/dist/conversion/{shared/bridge-message-utils.d.ts → bridge-message-utils.d.ts}

@@ -1,4 +1,4 @@
-import type { BridgeInputItem } from './bridge-message-types.js';
+import type { BridgeInputItem } from './types/bridge-message-types.js';
 export declare function coerceBridgeRole(role: unknown): string;
 export declare function serializeToolArguments(argsStringOrObj: unknown, _functionName: string | undefined, _tools: unknown): string;
 export declare function serializeToolOutput(entry: BridgeInputItem): string | null;

package/dist/conversion/{shared/bridge-message-utils.js → bridge-message-utils.js}

@@ -1,6 +1,6 @@
-import { normalizeFunctionCallId, normalizeFunctionCallOutputId } from './bridge-id-utils.js';
-import { normalizeChatMessageContent } from './chat-output-normalizer.js';
-import { repairToolArguments } from './tool-argument-repairer.js';
+import { normalizeChatMessageContent } from './shared/chat-output-normalizer.js';
+import { normalizeFunctionCallIdWithNative as normalizeFunctionCallId, repairArgumentsToStringWithNative as repairToolArguments } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { buildBridgeHistoryWithNative } from '../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
 function ensureAssistantToolCallIdentity(call, fallbackId) {
     const resolved = (typeof call.id === 'string' && call.id.trim().length ? call.id.trim() : undefined) ??
         (typeof call.tool_call_id === 'string' && call.tool_call_id.trim().length
@@ -142,153 +142,8 @@ function extractUserTextFromEntry(entry) {
 }
 export function convertMessagesToBridgeInput(options) {
     const { messages, tools } = options;
-    const input = [];
-    const systemParts = [];
-    const originalSystemMessages = [];
-    let latestUserInstruction = null;
-    const pendingToolCallIds = [];
-    const knownToolCallIds = new Set();
-    for (const m of messages) {
-        if (!m || typeof m !== 'object')
-            continue;
-        const role = coerceBridgeRole(m.role || 'user');
-        const content = m.content;
-        const collectedText = collectText(content);
-        const mediaBlocks = extractMediaBlocksFromContent(content);
-        const text = role === 'system' ? collectedText : collectedText.trim();
-        if (role === 'system') {
-            if (collectedText && collectedText.length) {
-                originalSystemMessages.push(collectedText);
-                systemParts.push(collectedText);
-            }
-            continue;
-        }
-        if (role === 'tool') {
-            const rawToolId = m.tool_call_id ||
-                m.call_id ||
-                m.tool_use_id ||
-                m.id ||
-                undefined;
-            let callId = typeof rawToolId === 'string' && rawToolId.trim().length ? rawToolId.trim() : undefined;
-            if (callId && knownToolCallIds.has(callId)) {
-                const idx = pendingToolCallIds.indexOf(callId);
-                if (idx >= 0)
-                    pendingToolCallIds.splice(idx, 1);
-            }
-            if (!callId && pendingToolCallIds.length) {
-                callId = pendingToolCallIds.shift();
-            }
-            if (!callId) {
-                callId = normalizeFunctionCallId({
-                    callId,
-                    fallback: `fc_call_${input.length + 1}`
-                });
-            }
-            knownToolCallIds.add(callId);
-            const normalizedId = normalizeFunctionCallOutputId({
-                callId,
-                fallback: `fc_tool_${input.length + 1}`
-            });
-            const entry = {
-                type: 'function_call_output',
-                id: normalizedId,
-                call_id: callId,
-                output: typeof text === 'string' ? text : ''
-            };
-            input.push(entry);
-            continue;
-        }
-        const toolCalls = Array.isArray(m.tool_calls) ? m.tool_calls : [];
-        if (toolCalls.length) {
-            for (const tc of toolCalls) {
-                try {
-                    const rawIdCandidate = (typeof tc?.id === 'string' && tc.id.trim().length ? tc.id.trim() : undefined) ??
-                        (typeof tc?.call_id === 'string' && tc.call_id.trim().length ? tc.call_id.trim() : undefined);
-                    const callId = rawIdCandidate ?? normalizeFunctionCallId({
-                        callId: rawIdCandidate,
-                        fallback: `fc_call_${input.length + 1}`
-                    });
-                    const fn = tc?.function || {};
-                    const name = typeof fn?.name === 'string' ? String(fn.name) : 'tool';
-                    const argsRaw = fn?.arguments;
-                    const args = typeof argsRaw === 'string'
-                        ? argsRaw
-                        : serializeToolArguments(argsRaw, name, tools);
-                    const entry = {
-                        type: 'function_call',
-                        id: callId,
-                        call_id: callId,
-                        name,
-                        arguments: args
-                    };
-                    input.push(entry);
-                    knownToolCallIds.add(callId);
-                    pendingToolCallIds.push(callId);
-                }
-                catch {
-                    // ignore malformed tool_call
-                }
-            }
-            continue;
-        }
-        if (typeof text === 'string' || mediaBlocks.length) {
-            const tRole = role === 'assistant' ? 'output_text' : 'input_text';
-            const blocks = [];
-            if (typeof text === 'string' && text.length) {
-                blocks.push({ type: tRole, text });
-            }
-            for (const media of mediaBlocks) {
-                const block = media.kind === 'video'
-                    ? {
-                        type: 'input_video',
-                        video_url: media.url
-                    }
-                    : {
-                        type: 'input_image',
-                        image_url: media.url
-                    };
-                if (media.detail) {
-                    block.detail = media.detail;
-                }
-                ;
-                blocks.push(block);
-            }
-            if (blocks.length) {
-                const entry = {
-                    role,
-                    content: blocks
-                };
-                input.push(entry);
-            }
-            if (role === 'user') {
-                const trimmed = typeof text === 'string' ? text.trim() : '';
-                if (trimmed.length) {
-                    latestUserInstruction = trimmed;
-                }
-            }
-        }
-    }
-    if (!latestUserInstruction) {
-        for (let i = input.length - 1; i >= 0; i -= 1) {
-            const entry = input[i];
-            const roleSource = entry?.role ?? entry?.message?.role;
-            const role = typeof roleSource === 'string' ? roleSource.toLowerCase() : '';
-            if (role !== 'user')
-                continue;
-            const text = extractUserTextFromEntry(entry);
-            if (text) {
-                latestUserInstruction = text;
-                break;
-            }
-        }
-    }
-    const combinedSystemInstruction = systemParts.join('\n\n').trim();
-    return {
-        input,
-        combinedSystemInstruction: combinedSystemInstruction.length ? combinedSystemInstruction : undefined,
-        latestUserInstruction: latestUserInstruction || undefined,
-        originalSystemMessages
-    };
+    const native = buildBridgeHistoryWithNative({ messages, tools });
+    return native;
 }
 function defaultNormalizeFunctionName(raw) {
     if (typeof raw !== 'string')

package/dist/conversion/{shared/bridge-metadata.d.ts → bridge-metadata.d.ts}

@@ -1 +1,2 @@
 export declare const BRIDGE_RAW_SYSTEM_METADATA_KEY = "__rcc_raw_system";
+export declare function resolveBridgeMetadataNativeProtocol(): string;

package/dist/conversion/bridge-metadata.js

@@ -0,0 +1,5 @@
+export const BRIDGE_RAW_SYSTEM_METADATA_KEY = '__rcc_raw_system';
+import { normalizeProviderProtocolTokenWithNative } from '../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export function resolveBridgeMetadataNativeProtocol() {
+    return normalizeProviderProtocolTokenWithNative('openai-responses') ?? 'openai-responses';
+}

package/dist/conversion/bridge-policies.js

@@ -0,0 +1,11 @@
+import { resolveBridgePolicyActionsWithNative, resolveBridgePolicyWithNative } from '../router/virtual-router/engine-selection/native-hub-bridge-policy-semantics.js';
+export function resolveBridgePolicy(options) {
+    const resolved = resolveBridgePolicyWithNative(options);
+    if (!resolved) {
+        return undefined;
+    }
+    return resolved;
+}
+export function resolvePolicyActions(policy, stage) {
+    return resolveBridgePolicyActionsWithNative(policy, stage);
+}

package/dist/conversion/codecs/gemini-openai-codec.js

@@ -1,10 +1,10 @@
-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 { normalizeChatMessageContent } from '../shared/chat-output-normalizer.js';
 import { mapBridgeToolsToChat } from '../shared/tool-mapping.js';
 import { prepareGeminiToolsForBridge } from '../shared/gemini-tool-utils.js';
 import { registerResponsesReasoning, consumeResponsesReasoning, registerResponsesOutputTextMeta, consumeResponsesOutputTextMeta, consumeResponsesPayloadSnapshot, registerResponsesPayloadSnapshot, consumeResponsesPassthrough, registerResponsesPassthrough } from '../shared/responses-reasoning-registry.js';
-import { ProviderProtocolError } from '../shared/errors.js';
+import { ProviderProtocolError } from '../provider-protocol-error.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -431,10 +431,18 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
     if (toolOutputs.length > 0) {
         chatResp.tool_outputs = toolOutputs;
     }
+    const localReasoning = reasoningParts.length
+        ? {
+            content: reasoningParts.map((text) => ({ type: 'reasoning_text', text }))
+        }
+        : undefined;
     const preservedReasoning = consumeResponsesReasoning(chatResp.id);
-    if (preservedReasoning && preservedReasoning.length) {
+    if (preservedReasoning) {
         chatResp.__responses_reasoning = preservedReasoning;
     }
+    else if (localReasoning) {
+        chatResp.__responses_reasoning = localReasoning;
+    }
     const preservedOutputMeta = consumeResponsesOutputTextMeta(chatResp.id);
     if (preservedOutputMeta) {
         chatResp.__responses_output_text_meta = preservedOutputMeta;
@@ -521,9 +529,20 @@ export function buildGeminiFromOpenAIChat(chatResp) {
     if (contentText && contentText.length) {
         parts.push({ text: contentText });
     }
-    const reasoningText = typeof msg?.reasoning_content === 'string' && msg.reasoning_content.trim().length
-        ? String(msg.reasoning_content).trim()
-        : undefined;
+    const preservedReasoning = chatResp?.__responses_reasoning;
+    const preservedContent = Array.isArray(preservedReasoning?.content)
+        ? preservedReasoning?.content?.map((entry) => String(entry.text ?? '')).filter((text) => text.trim().length > 0)
+        : [];
+    const preservedSummary = Array.isArray(preservedReasoning?.summary)
+        ? preservedReasoning?.summary?.map((entry) => String(entry.text ?? '')).filter((text) => text.trim().length > 0)
+        : [];
+    const reasoningText = preservedContent.length > 0
+        ? preservedContent.join('\n')
+        : (preservedSummary.length > 0
+            ? preservedSummary.join('\n')
+            : (typeof msg?.reasoning_content === 'string' && msg.reasoning_content.trim().length
+                ? String(msg.reasoning_content).trim()
+                : undefined));
     if (reasoningText) {
         parts.push({ reasoning: reasoningText });
     }
@@ -613,7 +632,7 @@ export function buildGeminiFromOpenAIChat(chatResp) {
     }
     if (Object.keys(usageMetadata).length > 0)
         out.usageMetadata = usageMetadata;
-    if (Array.isArray(chatResp?.__responses_reasoning)) {
+    if (chatResp?.__responses_reasoning) {
         registerResponsesReasoning(responseId, chatResp.__responses_reasoning);
     }
     if (chatResp?.__responses_output_text_meta) {