@jsonstudio/llms 0.6.3238 → 0.6.3275

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>;

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

@@ -68,6 +68,40 @@ function parseBridgeHistoryOutput(raw) {
         return null;
     }
 }
+function parseBridgeActionState(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        if (!Array.isArray(row.messages)) {
+            return null;
+        }
+        const output = {
+            messages: row.messages
+        };
+        if (row.requiredAction && typeof row.requiredAction === 'object' && !Array.isArray(row.requiredAction)) {
+            output.requiredAction = row.requiredAction;
+        }
+        if (Array.isArray(row.capturedToolResults)) {
+            output.capturedToolResults = row.capturedToolResults.filter((entry) => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry));
+        }
+        if (row.rawRequest && typeof row.rawRequest === 'object' && !Array.isArray(row.rawRequest)) {
+            output.rawRequest = row.rawRequest;
+        }
+        if (row.rawResponse && typeof row.rawResponse === 'object' && !Array.isArray(row.rawResponse)) {
+            output.rawResponse = row.rawResponse;
+        }
+        if (row.metadata && typeof row.metadata === 'object' && !Array.isArray(row.metadata)) {
+            output.metadata = row.metadata;
+        }
+        return output;
+    }
+    catch {
+        return null;
+    }
+}
 function parseApplyBridgeNormalizeHistoryOutput(raw) {
     try {
         const parsed = JSON.parse(raw);
@@ -673,6 +707,43 @@ export function applyBridgeEnsureSystemInstructionWithNative(input) {
         return fail(reason);
     }
 }
+export function runBridgeActionPipelineWithNative(input) {
+    const capability = 'runBridgeActionPipelineJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({
+        stage: input.stage,
+        actions: input.actions,
+        protocol: input.protocol,
+        moduleType: input.moduleType,
+        requestId: input.requestId,
+        state: input.state
+    });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseBridgeActionState(raw);
+        if (!parsed) {
+            return null;
+        }
+        return parsed;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function normalizeMessageReasoningToolsWithNative(message, idPrefix) {
     const capability = 'normalizeMessageReasoningToolsJson';
     const fail = (reason) => failNativeRequired(capability, reason);

package/dist/router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.d.ts

@@ -29,6 +29,7 @@ export declare function resolveReqInboundServerToolFollowupSnapshotWithNative(ad
 export declare function augmentReqInboundContextSnapshotWithNative(context: Record<string, unknown>, fallbackSnapshot: Record<string, unknown>): Record<string, unknown>;
 export declare function normalizeReqInboundToolCallIdStyleWithNative(value: unknown): 'fc' | 'preserve' | undefined;
 export declare function mapReqInboundBridgeToolsToChatWithNative(rawTools: unknown): Array<Record<string, unknown>>;
+export declare function mapChatToolsToBridgeWithNative(rawTools: unknown): Array<Record<string, unknown>>;
 export declare function captureReqInboundResponsesContextSnapshotWithNative(input: {
     rawRequest: Record<string, unknown>;
     requestId?: string;

package/dist/router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js

@@ -339,6 +339,36 @@ export function mapReqInboundBridgeToolsToChatWithNative(rawTools) {
         return fail(reason);
     }
 }
+export function mapChatToolsToBridgeWithNative(rawTools) {
+    const capability = 'mapChatToolsToBridgeJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(Array.isArray(rawTools) ? rawTools : []);
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseArray(raw);
+        if (!parsed) {
+            return fail('invalid payload');
+        }
+        return parsed.filter((entry) => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function captureReqInboundResponsesContextSnapshotWithNative(input) {
     const capability = 'captureReqInboundResponsesContextSnapshotJson';
     const fail = (reason) => failNativeRequired(capability, reason);

package/dist/router/virtual-router/engine-selection/native-router-hotpath-loader.js

@@ -29,6 +29,7 @@ const REQUIRED_NATIVE_EXPORTS = [
     'augmentContextSnapshotJson',
     'annotatePassthroughGovernanceSkipJson',
     'buildAnthropicToolAliasMapJson',
+    'buildAnthropicResponseFromChatJson',
     'buildChatNodeResultMetadataJson',
     'buildProcessedRequestFromChatResponseJson',
     'applyChatProcessedRequestJson',
@@ -65,6 +66,7 @@ const REQUIRED_NATIVE_EXPORTS = [
     'mapBridgeToolsToChatJson',
     'mapOpenaiChatToChatJson',
     'mapOpenaiChatFromChatJson',
+    'mapChatToolsToBridgeJson',
     'captureReqInboundResponsesContextSnapshotJson',
     'computeQuotaBucketsJson',
     'deserializeStopMessageStateJson',
@@ -112,6 +114,8 @@ const REQUIRED_NATIVE_EXPORTS = [
     'injectTimeTagIntoMessagesJson',
     'injectMcpToolsForChatJson',
     'injectMcpToolsForResponsesJson',
+    'mapOpenaiChatToChatJson',
+    'mapOpenaiChatFromChatJson',
     'isStopMessageStateActiveJson',
     'isContextLengthExceededSignalJson',
     'isCompactionRequestJson',
@@ -207,9 +211,11 @@ const REQUIRED_NATIVE_EXPORTS = [
     'resolveSseStreamModeJson',
     'resolveSseProtocolFromMetadataJson',
     'repairArgumentsToStringJsonishJson',
+    'runBridgeActionPipelineJson',
     'sanitizeChatCompletionLikeJson',
     'sanitizeFormatEnvelopeJson',
     'sanitizeReasoningTaggedTextJson',
+    'ensureBridgeInstructionsJson',
     'sanitizeResponsesFunctionNameJson',
     'shouldRecordSnapshotsJson',
     'writeSnapshotViaHooksJson',

package/dist/router/virtual-router/engine-selection/native-shared-conversion-semantics.d.ts

@@ -4,7 +4,9 @@ export declare function extractToolCallsFromReasoningTextWithNative(text: string
     cleanedText: string;
     toolCalls: Array<Record<string, unknown>>;
 };
+export declare function mapChatToolsToBridgeWithNative(rawTools: unknown): Array<Record<string, unknown>>;
 export declare function sanitizeReasoningTaggedTextWithNative(text: string): string;
+export declare function ensureBridgeInstructionsWithNative(payload: Record<string, unknown>): Record<string, unknown>;
 export declare function deriveToolCallKeyWithNative(call: Record<string, unknown> | null | undefined): string | null;
 export declare function buildProviderProtocolErrorWithNative(input: {
     message: string;

package/dist/router/virtual-router/engine-selection/native-shared-conversion-semantics.js

@@ -80,6 +80,10 @@ function parseToolCallLiteArray(raw) {
     }
     return out;
 }
+function parseArray(raw) {
+    const parsed = parseJson(raw);
+    return Array.isArray(parsed) ? parsed : null;
+}
 export function parseLenientJsonishWithNative(value) {
     const capability = 'parseLenientJsonishJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -156,6 +160,36 @@ export function extractToolCallsFromReasoningTextWithNative(text, idPrefix) {
         return fail(reason);
     }
 }
+export function mapChatToolsToBridgeWithNative(rawTools) {
+    const capability = 'mapChatToolsToBridgeJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(Array.isArray(rawTools) ? rawTools : []);
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseArray(raw);
+        if (!parsed) {
+            return fail('invalid payload');
+        }
+        return parsed.filter((entry) => !!entry && typeof entry === 'object' && !Array.isArray(entry));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function sanitizeReasoningTaggedTextWithNative(text) {
     const capability = 'sanitizeReasoningTaggedTextJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -178,6 +212,33 @@ export function sanitizeReasoningTaggedTextWithNative(text) {
         return fail(reason);
     }
 }
+export function ensureBridgeInstructionsWithNative(payload) {
+    const capability = 'ensureBridgeInstructionsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload ?? {});
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseRecord(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function deriveToolCallKeyWithNative(call) {
     const capability = 'deriveToolCallKeyJson';
     const fail = (reason) => failNativeRequired(capability, reason);