@jsonstudio/llms 0.6.3214 → 0.6.3271

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

@@ -1,9 +1,9 @@
 import { DEFAULT_TOOL_GOVERNANCE_RULES } from './rules.js';
-import { governRequestWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-governance-semantics.js';
+import { governRequestWithNative, governResponseWithNative } 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)
+ * - response path: native-primary
  *
  * Legacy-only snapshot retained at:
  * - src/conversion/hub/tool-governance/archive/engine.legacy.ts
@@ -79,18 +79,24 @@ export class ToolGovernanceEngine {
                 summary: buildSummary(protocol, 'response', false)
             };
         }
-        const stats = createStats(protocol, 'response');
-        const cloned = JSON.parse(JSON.stringify(payload));
-        const choices = Array.isArray(cloned?.choices) ? cloned.choices : [];
-        for (const choice of choices) {
-            sanitizeChatCompletionChoice(choice, rules, stats);
+        let governed;
+        try {
+            governed = governResponseWithNative({
+                payload: payload,
+                protocol,
+                registry: this.registry
+            });
         }
-        if (Array.isArray(cloned?.tool_calls)) {
-            cloned.tool_calls = cloned.tool_calls.map((tc) => sanitizeChatCompletionToolCall(tc, rules, stats));
+        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, 'response', 'tool.function.name');
+            }
+            throw error;
         }
         return {
-            payload: cloned,
-            summary: finalizeSummary(stats)
+            payload: governed.payload,
+            summary: governed.summary
         };
     }
     resolveRules(protocol, direction) {
@@ -99,122 +105,6 @@ export class ToolGovernanceEngine {
         return entry?.[direction];
     }
 }
-function sanitizeChatCompletionChoice(choice, rules, stats) {
-    const message = choice?.message;
-    if (!message || typeof message !== 'object') {
-        return;
-    }
-    const msg = message;
-    if (Array.isArray(msg.tool_calls)) {
-        msg.tool_calls = msg.tool_calls.map((tc, index) => sanitizeChatCompletionToolCall(tc, rules, stats, `choices[].message.tool_calls[${index}].function.name`));
-    }
-    if (msg.function_call && typeof msg.function_call === 'object') {
-        const orig = msg.function_call.name;
-        const sanitizedName = sanitizeName(orig, rules, stats, 'choices[].message.function_call.name');
-        msg.function_call.name = sanitizedName;
-    }
-    if (typeof msg.name === 'string' || msg.role === 'tool') {
-        msg.name = sanitizeName(msg.name, rules, stats, 'choices[].message.name');
-    }
-}
-function sanitizeChatCompletionToolCall(tc, rules, stats, context = 'choices[].message.tool_calls[].function.name') {
-    if (!tc || typeof tc !== 'object') {
-        return tc;
-    }
-    const fn = tc.function;
-    if (!fn || typeof fn !== 'object') {
-        return tc;
-    }
-    const sanitizedName = sanitizeName(fn.name, rules, stats, context);
-    if (sanitizedName === fn.name) {
-        return tc;
-    }
-    return {
-        ...tc,
-        function: {
-            ...fn,
-            name: sanitizedName
-        }
-    };
-}
-function createStats(protocol, direction) {
-    return {
-        protocol,
-        direction,
-        applied: false,
-        sanitizedNames: 0,
-        truncatedNames: 0,
-        defaultedNames: 0
-    };
-}
-function sanitizeName(rawName, rules, stats, field) {
-    const defaultName = rules.defaultName ?? 'tool';
-    let next = typeof rawName === 'string' ? rawName : '';
-    let changed = false;
-    if (rules.trimWhitespace !== false) {
-        next = next.trim();
-    }
-    if (!next) {
-        next = defaultName;
-        stats.defaultedNames += 1;
-        changed = true;
-    }
-    if (rules.forceCase === 'lower') {
-        const forced = next.toLowerCase();
-        if (forced !== next) {
-            next = forced;
-            changed = true;
-        }
-    }
-    else if (rules.forceCase === 'upper') {
-        const forced = next.toUpperCase();
-        if (forced !== next) {
-            next = forced;
-            changed = true;
-        }
-    }
-    if (rules.allowedCharacters) {
-        const matcher = new RegExp(rules.allowedCharacters.source);
-        const filtered = next
-            .split('')
-            .filter((ch) => matcher.test(ch))
-            .join('');
-        matcher.lastIndex = 0;
-        if (filtered.length === 0) {
-            next = defaultName;
-            stats.defaultedNames += 1;
-            changed = true;
-        }
-        else if (filtered !== next) {
-            next = filtered;
-            changed = true;
-        }
-    }
-    if (rules.maxNameLength && next.length > rules.maxNameLength) {
-        if (rules.onViolation === 'reject') {
-            throw new ToolGovernanceError(`Tool name exceeds max length of ${rules.maxNameLength}`, stats.protocol, stats.direction, field);
-        }
-        next = next.slice(0, rules.maxNameLength);
-        stats.truncatedNames += 1;
-        changed = true;
-    }
-    if (changed || (typeof rawName === 'string' && rawName !== next)) {
-        stats.sanitizedNames += 1;
-    }
-    stats.applied = true;
-    return next || defaultName;
-}
-function finalizeSummary(stats) {
-    return {
-        protocol: stats.protocol,
-        direction: stats.direction,
-        applied: stats.applied,
-        sanitizedNames: stats.sanitizedNames,
-        truncatedNames: stats.truncatedNames,
-        defaultedNames: stats.defaultedNames,
-        timestamp: Date.now()
-    };
-}
 function buildSummary(protocol, direction, applied) {
     return {
         protocol,

package/dist/conversion/shared/anthropic-message-utils.d.ts

@@ -7,7 +7,9 @@ interface OpenAIChatPayload extends Unknown {
 }
 export declare function normalizeAnthropicToolName(value: unknown): string | undefined;
 export declare function denormalizeAnthropicToolName(value: unknown): string | undefined;
-export declare function buildOpenAIChatFromAnthropic(payload: unknown): OpenAIChatPayload;
+export declare function buildOpenAIChatFromAnthropic(payload: unknown, options?: {
+    includeToolCallIds?: boolean;
+}): OpenAIChatPayload;
 export interface BuildAnthropicFromOpenAIOptions {
     toolNameMap?: Record<string, string>;
     requestId?: string;

package/dist/conversion/shared/anthropic-message-utils.js

@@ -17,23 +17,24 @@ function safeJson(v) {
     }
 }
 function stripOpenAIChatToolAliasFields(messages) {
+    // No-op: preserve tool_call_id/call_id for downstream consumers and regression parity.
+    void messages;
+}
+function stripToolCallIdFieldsFromAssistant(messages) {
     for (const message of messages) {
-        if (!message || typeof message !== 'object') {
+        if (!message || typeof message !== 'object')
             continue;
-        }
         const role = String(message.role || '').toLowerCase();
-        if (role === 'assistant' && Array.isArray(message.tool_calls)) {
-            for (const call of message.tool_calls) {
-                if (!call || typeof call !== 'object') {
-                    continue;
-                }
-                delete call.tool_call_id;
-                delete call.call_id;
-            }
+        if (role !== 'assistant')
             continue;
-        }
-        if (role === 'tool') {
-            delete message.call_id;
+        const calls = message.tool_calls;
+        if (!Array.isArray(calls))
+            continue;
+        for (const call of calls) {
+            if (!call || typeof call !== 'object')
+                continue;
+            delete call.call_id;
+            delete call.tool_call_id;
         }
     }
 }
@@ -352,7 +353,7 @@ function invertAnthropicAliasMap(source) {
     }
     return Object.keys(inverted).length ? inverted : undefined;
 }
-export function buildOpenAIChatFromAnthropic(payload) {
+export function buildOpenAIChatFromAnthropic(payload, options) {
     const newMessages = [];
     const body = isObject(payload) ? payload : {};
     const canonicalAliasMap = coerceAliasRecord(buildAnthropicToolAliasMap(body.tools));
@@ -458,7 +459,13 @@ export function buildOpenAIChatFromAnthropic(payload) {
                 const input = block.input ?? {};
                 const args = safeJson(input);
                 const canonicalName = resolveToolName(name) || name;
-                toolCalls.push({ id, type: 'function', function: { name: canonicalName, arguments: args } });
+                const includeIds = options?.includeToolCallIds === true;
+                toolCalls.push({
+                    id,
+                    ...(includeIds ? { call_id: id, tool_call_id: id } : {}),
+                    type: 'function',
+                    function: { name: canonicalName, arguments: args }
+                });
             }
             else if (t === 'tool_result') {
                 const callId = requireTrimmedString(block.tool_call_id ??
@@ -549,6 +556,7 @@ export function buildOpenAIChatFromAnthropic(payload) {
     catch {
         // ignore policy failures
     }
+    stripToolCallIdFieldsFromAssistant(newMessages);
     stripOpenAIChatToolAliasFields(newMessages);
     return request;
 }

package/dist/conversion/shared/openai-finalizer.d.ts

@@ -1,11 +1,8 @@
-type ProcessingMode = 'streaming' | 'non-streaming' | 'auto';
 export type ChatReasoningMode = 'keep' | 'drop' | 'append_to_content';
 export interface FinalizeOptions {
     requestId?: string;
     endpoint?: string;
-    processingMode?: ProcessingMode;
     stream?: boolean;
     reasoningMode?: ChatReasoningMode;
 }
 export declare function finalizeOpenAIChatResponse(chatLike: unknown, opts?: FinalizeOptions): Promise<unknown>;
-export {};

package/dist/conversion/shared/openai-finalizer.js

@@ -1,180 +1,22 @@
 // OpenAI Chat finalizer: enforce canonical shapes without the legacy hook system.
 // - Ensures tool_calls use stringified JSON arguments and sets finish_reason='tool_calls' when applicable
 // - Normalizes potential tool messages (role:'tool') content to strict strings (JSON-stringify for objects)
-import { sanitizeReasoningTaggedTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { finalizeRespProcessChatResponseWithNative } from '../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
 function asObject(v) {
     return v && typeof v === 'object' && !Array.isArray(v) ? v : null;
 }
-function stringifyArgs(argVal) {
-    if (typeof argVal === 'string')
-        return argVal;
-    try {
-        return JSON.stringify(argVal ?? {});
-    }
-    catch {
-        return '{}';
-    }
-}
-function toStringContent(val, emptyFallback = 'Command succeeded (no output).') {
-    if (val == null)
-        return emptyFallback;
-    if (typeof val === 'string') {
-        const s = val.trim();
-        return s.length ? s : emptyFallback;
-    }
-    if (Array.isArray(val) || typeof val === 'object') {
-        try {
-            const s = JSON.stringify(val);
-            return s && s.trim().length ? s : emptyFallback;
-        }
-        catch {
-            return emptyFallback;
-        }
-    }
-    try {
-        const s = String(val);
-        return s.trim().length ? s : emptyFallback;
-    }
-    catch {
-        return emptyFallback;
-    }
-}
+// Canonicalization handled by native finalizeChatResponseJson.
 export async function finalizeOpenAIChatResponse(chatLike, opts) {
-    const streamingIntent = opts?.stream === true;
     const obj = asObject(chatLike);
     if (!obj)
         return chatLike;
-    try {
-        // Case A: OpenAI Chat completion response ({ id, object, choices[0].message })
-        if ('choices' in obj && Array.isArray(obj.choices)) {
-            const first = obj.choices[0];
-            if (first && typeof first === 'object' && first.message && typeof first.message === 'object') {
-                const msg = first.message;
-                if (Array.isArray(msg.tool_calls)) {
-                    for (const tc of msg.tool_calls) {
-                        try {
-                            const fn = tc?.function || {};
-                            if (fn && typeof fn === 'object') {
-                                fn.arguments = stringifyArgs(fn.arguments);
-                            }
-                        }
-                        catch { /* ignore */ }
-                    }
-                    if (String(first.finish_reason || '').toLowerCase() !== 'tool_calls') {
-                        first.finish_reason = 'tool_calls';
-                    }
-                }
-            }
-            // nothing more to do for Chat completion response
-        }
-        // Case B: Chat-style messages array ({ messages: [...] })
-        if (Array.isArray(obj.messages)) {
-            const msgs = obj.messages;
-            // Build latest assistant tool_call id->name map
-            const idToName = new Map();
-            for (let i = msgs.length - 1; i >= 0; i--) {
-                const m = msgs[i];
-                if (m && m.role === 'assistant' && Array.isArray(m.tool_calls) && m.tool_calls.length) {
-                    for (const tc of m.tool_calls) {
-                        const id = typeof tc?.id === 'string' ? tc.id : undefined;
-                        const nm = typeof tc?.function?.name === 'string' ? tc.function.name : undefined;
-                        if (id && nm)
-                            idToName.set(id, nm);
-                        if (tc?.function)
-                            tc.function.arguments = stringifyArgs(tc.function.arguments);
-                    }
-                    break;
-                }
-            }
-            // Normalize tool role messages: ensure string content + name (if known)
-            for (const m of msgs) {
-                if (!m || typeof m !== 'object')
-                    continue;
-                if (String(m.role || '').toLowerCase() !== 'tool')
-                    continue;
-                const cid = typeof m.tool_call_id === 'string' ? m.tool_call_id : undefined;
-                // add name when available
-                const nm = cid ? idToName.get(cid) : undefined;
-                if (nm && typeof m.name !== 'string')
-                    m.name = nm;
-                m.content = toStringContent(m.content);
-            }
-        }
-    }
-    catch { /* ignore normalization errors */ }
-    applyChatReasoningPolicy(obj, opts?.reasoningMode);
-    return obj;
-}
-function applyChatReasoningPolicy(target, mode) {
-    if (!mode || mode === 'keep') {
-        return;
-    }
-    const containers = [];
-    if (Array.isArray(target.messages)) {
-        target.messages.forEach(entry => {
-            if (entry && typeof entry === 'object') {
-                containers.push(entry);
-            }
-        });
-    }
-    if (Array.isArray(target.choices)) {
-        target.choices.forEach(choice => {
-            if (!choice || typeof choice !== 'object') {
-                return;
-            }
-            const record = choice;
-            if (record.message && typeof record.message === 'object') {
-                containers.push(record.message);
-            }
-            if (record.delta && typeof record.delta === 'object') {
-                containers.push(record.delta);
-            }
-        });
-    }
-    containers.forEach(container => normalizeReasoningField(container, mode));
-}
-function normalizeReasoningField(container, mode) {
-    const bag = container;
-    const rawValue = typeof bag.reasoning_content === 'string' ? bag.reasoning_content : '';
-    const trimmed = sanitizeReasoningTaggedTextWithNative(rawValue).trim();
-    if (!trimmed && Object.prototype.hasOwnProperty.call(bag, 'reasoning_content')) {
-        delete bag.reasoning_content;
-        return;
-    }
-    if (!trimmed) {
-        return;
-    }
-    if (mode === 'drop') {
-        delete bag.reasoning_content;
-        return;
-    }
-    if (mode === 'append_to_content') {
-        appendReasoningToContent(bag, trimmed);
-        delete bag.reasoning_content;
-        return;
-    }
-}
-function appendReasoningToContent(container, reasoning) {
-    const separator = reasoning.startsWith('\n') ? '' : '\n';
-    if (typeof container.content === 'string') {
-        const base = container.content.trim().length ? container.content : '';
-        container.content = base ? `${base}${separator}${reasoning}` : reasoning;
-        return;
-    }
-    if (Array.isArray(container.content)) {
-        const list = container.content;
-        list.push({ type: 'text', text: reasoning });
-        return;
-    }
-    if (container.content && typeof container.content === 'object') {
-        try {
-            const serialized = JSON.stringify(container.content);
-            container.content = serialized ? `${serialized}${separator}${reasoning}` : reasoning;
-        }
-        catch {
-            container.content = reasoning;
-        }
-        return;
-    }
-    container.content = reasoning;
+    const finalized = await finalizeRespProcessChatResponseWithNative({
+        payload: obj,
+        stream: opts?.stream === true,
+        reasoningMode: opts?.reasoningMode,
+        endpoint: opts?.endpoint,
+        requestId: opts?.requestId
+    });
+    return finalized;
 }
+// All canonicalization + reasoning policy handled by native finalizeChatResponseJson.

package/dist/conversion/shared/openai-message-normalize.js

@@ -1,5 +1,6 @@
 import { injectMcpToolsForChat } from '../mcp-injection.js';
 import { normalizeOpenaiChatMessagesWithNative, normalizeOpenaiMessageWithNative, normalizeOpenaiToolCallWithNative, normalizeOpenaiToolWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { enforceChatBudgetWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 // Message normalization utilities for OpenAI chat payloads (renamed to avoid confusion
 // with the deprecated "openai-normalizer" module entry). This file contains the
 // previously-implemented logic from openai-normalize.ts.
@@ -7,47 +8,14 @@ import { normalizeOpenaiChatMessagesWithNative, normalizeOpenaiMessageWithNative
 export function normalizeChatRequest(request) {
     if (!request || typeof request !== 'object')
         return request;
-    const normalized = { ...request };
+    let normalized = { ...request };
     if (Array.isArray(normalized.messages)) {
         normalized.messages = normalized.messages.map((msg) => normalizeMessage(msg));
     }
     if (Array.isArray(normalized.tools)) {
         normalized.tools = normalized.tools.map((tool) => normalizeTool(tool));
     }
-    // Limit handling: keep structure without truncating tool outputs or adding markers.
-    // - Do not remove messages; avoid truncating tool output content.
-    try {
-        const msgs = Array.isArray(normalized.messages) ? normalized.messages : [];
-        if (msgs.length) {
-            const asstLimitRaw = process?.env?.RCC_ASSISTANT_TEXT_LIMIT;
-            const ASST_LIMIT = (asstLimitRaw === '0') ? 0 : Math.max(0, Number(asstLimitRaw ?? 8192));
-            const clamp = (s, n) => {
-                try {
-                    const t = String(s);
-                    return (n > 0 && t.length > n) ? (t.slice(0, n) + '...(truncated)') : t;
-                }
-                catch {
-                    return s;
-                }
-            };
-            for (let i = 0; i < msgs.length; i++) {
-                const m = msgs[i];
-                if (!m || typeof m !== 'object')
-                    continue;
-                const role = String(m.role || '').toLowerCase();
-                if (role === 'assistant') {
-                    if (ASST_LIMIT > 0) {
-                        if (typeof m.content === 'string')
-                            m.content = clamp(m.content, ASST_LIMIT);
-                        else if (Array.isArray(m.content)) {
-                            m.content = m.content.map((p) => (p && typeof p.text === 'string') ? { ...p, text: clamp(p.text, ASST_LIMIT) } : p);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    catch { /* ignore limit errors */ }
+    // Assistant text limit handling has been moved into native budget enforcement.
     // MCP 注入（两步法）统一走共享实现，避免路径分叉
     const disableMcpTools = Boolean(normalized.__rcc_disable_mcp_tools);
     if (!disableMcpTools) {
@@ -141,48 +109,19 @@ export function normalizeChatRequest(request) {
     }
     catch { /* ignore message normalization */ }
     // 注意：不合并/删除多条 system（与 统一标准，避免高风险修改）。
-    // 基于“载荷预算”（配置驱动）进行分层裁剪，避免整体载荷超限导致上游 500。
+    // 基于“载荷预算”（配置驱动）进行裁剪，统一走 native。
     try {
         const msgs = Array.isArray(normalized.messages) ? normalized.messages : [];
         if (msgs.length) {
             const modelId = String(normalized?.model || '').trim();
             const budget = resolveBudgetForModelSync(modelId);
-            const allowed = Math.max(32 * 1024, Math.floor(budget.allowedBytes)); // 最低 32KB
-            const sizeBytes = (obj) => { try {
-                return Buffer.byteLength(JSON.stringify(obj), 'utf8');
-            }
-            catch {
-                return 0;
-            } };
-            let total = sizeBytes(normalized.messages);
-            if (total > allowed) {
-                // 分层裁剪：最近 3 条工具消息额度更大，其余更严格；若仍超限，再统一降到最小额度。
-                const toolIdx = [];
-                for (let i = 0; i < msgs.length; i++) {
-                    const m = msgs[i];
-                    if (m && m.role === 'tool' && typeof m.content === 'string')
-                        toolIdx.push(i);
-                }
-                if (toolIdx.length) {
-                    // Disable shrinking/truncation of tool outputs to avoid altering content
-                    const shrinkTo = (_idx, _limit) => { };
-                    const recentLimitChars = Number(process?.env?.RCC_TOOL_TEXT_RECENT || 1024);
-                    const olderLimitChars = Number(process?.env?.RCC_TOOL_TEXT_OLDER || 256);
-                    const minimalLimitChars = Number(process?.env?.RCC_TOOL_TEXT_MIN || 128);
-                    const recent = toolIdx.slice(-3);
-                    const older = toolIdx.slice(0, Math.max(0, toolIdx.length - recent.length));
-                    // No-op shrink to keep content intact
-                    for (const i of older)
-                        shrinkTo(i, olderLimitChars);
-                    for (const i of recent)
-                        shrinkTo(i, recentLimitChars);
-                    total = sizeBytes(normalized.messages);
-                    if (total > allowed) {
-                        for (const i of toolIdx)
-                            shrinkTo(i, minimalLimitChars);
-                    }
-                }
-            }
+            const allowed = Math.max(32 * 1024, Math.floor(budget.allowedBytes));
+            const sysLimit = (() => {
+                const raw = process?.env?.RCC_SYSTEM_TEXT_LIMIT;
+                const n = Number(raw);
+                return Number.isFinite(n) && n >= 0 ? n : 8192;
+            })();
+            normalized = enforceChatBudgetWithNative(normalized, allowed, sysLimit);
         }
     }
     catch { /* ignore budget enforcement */ }

package/dist/conversion/shared/tool-mapping.js

@@ -1,4 +1,5 @@
 import { sanitizeResponsesFunctionNameWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+import { mapChatToolsToBridgeWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export function stringifyArgs(args) {
     if (typeof args === 'string')
         return args;
@@ -209,6 +210,10 @@ export function mapChatToolsToBridge(rawTools, options) {
     if (!Array.isArray(rawTools) || rawTools.length === 0) {
         return undefined;
     }
+    if (!options?.sanitizeName) {
+        const mapped = mapChatToolsToBridgeWithNative(rawTools);
+        return mapped && mapped.length ? mapped : undefined;
+    }
     const mapped = rawTools
         .map((entry) => chatToolToBridgeDefinition(entry, options))
         .filter((entry) => !!entry);

package/dist/router/virtual-router/bootstrap/provider-normalization.js

@@ -116,17 +116,25 @@ function normalizeDeepSeekOptions(provider) {
         : typeof source.strictToolRequired === 'string'
             ? source.strictToolRequired.trim().toLowerCase() === 'true'
             : undefined;
-    const textToolFallback = typeof source.textToolFallback === 'boolean'
+    const toolProtocolRaw = typeof source.toolProtocol === 'string' ? source.toolProtocol.trim().toLowerCase() : '';
+    let toolProtocol;
+    if (toolProtocolRaw === 'text' || toolProtocolRaw === 'native') {
+        toolProtocol = toolProtocolRaw;
+    }
+    const legacyTextToolFallback = typeof source.textToolFallback === 'boolean'
         ? source.textToolFallback
         : typeof source.textToolFallback === 'string'
             ? source.textToolFallback.trim().toLowerCase() === 'true'
             : undefined;
-    if (strictToolRequired === undefined && textToolFallback === undefined) {
+    if (toolProtocol === undefined && legacyTextToolFallback !== undefined) {
+        toolProtocol = legacyTextToolFallback ? 'text' : 'native';
+    }
+    if (strictToolRequired === undefined && toolProtocol === undefined) {
         return undefined;
     }
     return {
         ...(strictToolRequired !== undefined ? { strictToolRequired } : {}),
-        ...(textToolFallback !== undefined ? { textToolFallback } : {})
+        ...(toolProtocol !== undefined ? { toolProtocol } : {})
     };
 }
 function resolveCompatibilityProfile(providerId, provider) {

package/dist/router/virtual-router/engine-selection/native-hub-bridge-action-semantics.d.ts

@@ -113,6 +113,25 @@ export interface NativeApplyBridgeEnsureSystemInstructionOutput {
     messages: unknown[];
     metadata?: Record<string, unknown>;
 }
+export interface NativeBridgeActionPipelineInput {
+    stage: 'request_inbound' | 'request_outbound' | 'response_inbound' | 'response_outbound';
+    actions?: Array<{
+        name: string;
+        options?: Record<string, unknown>;
+    }>;
+    protocol?: string;
+    moduleType?: string;
+    requestId?: string;
+    state: NativeBridgeActionState;
+}
+export interface NativeBridgeActionState {
+    messages: unknown[];
+    requiredAction?: Record<string, unknown>;
+    capturedToolResults?: Array<Record<string, unknown>>;
+    rawRequest?: Record<string, unknown>;
+    rawResponse?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
 export interface NativeNormalizeMessageReasoningToolsOutput {
     message: Record<string, unknown>;
     toolCallsAdded: number;
@@ -130,5 +149,6 @@ export declare function applyBridgeReasoningExtractWithNative(input: NativeApply
 export declare function applyBridgeResponsesOutputReasoningWithNative(input: NativeApplyBridgeResponsesOutputReasoningInput): NativeApplyBridgeResponsesOutputReasoningOutput;
 export declare function applyBridgeInjectSystemInstructionWithNative(input: NativeApplyBridgeInjectSystemInstructionInput): NativeApplyBridgeInjectSystemInstructionOutput;
 export declare function applyBridgeEnsureSystemInstructionWithNative(input: NativeApplyBridgeEnsureSystemInstructionInput): NativeApplyBridgeEnsureSystemInstructionOutput;
+export declare function runBridgeActionPipelineWithNative(input: NativeBridgeActionPipelineInput): NativeBridgeActionState | null;
 export declare function normalizeMessageReasoningToolsWithNative(message: Record<string, unknown>, idPrefix?: string): NativeNormalizeMessageReasoningToolsOutput;
 export declare function normalizeChatResponseReasoningToolsWithNative(response: Record<string, unknown>, idPrefixBase?: string): Record<string, unknown>;