@jsonstudio/llms 0.6.2979 → 0.6.3238

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

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

@@ -1,76 +1,80 @@
-import { sanitizeResponsesFunctionNameWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+import { resolveDefaultToolGovernanceRulesWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-governance-semantics.js';
 const ALPHA_NUMERIC = /[A-Za-z0-9_-]/;
 const LOWER_SNAKE = /[a-z0-9_-]/;
 function clonePattern(pattern) {
     const flags = pattern.flags.replace(/g/g, '');
     return new RegExp(pattern.source, flags);
 }
-const DEFAULT_TOOL_NAME = sanitizeResponsesFunctionNameWithNative('tool') ?? 'tool';
-export const DEFAULT_TOOL_GOVERNANCE_RULES = {
-    'openai-chat': {
-        request: {
-            maxNameLength: 64,
-            allowedCharacters: clonePattern(ALPHA_NUMERIC),
-            defaultName: DEFAULT_TOOL_NAME,
-            trimWhitespace: true,
-            onViolation: 'truncate'
-        },
-        response: {
-            maxNameLength: 64,
-            allowedCharacters: clonePattern(ALPHA_NUMERIC),
-            defaultName: DEFAULT_TOOL_NAME,
-            trimWhitespace: true,
-            onViolation: 'truncate'
-        }
-    },
-    'openai-responses': {
-        request: {
-            maxNameLength: 64,
-            allowedCharacters: clonePattern(ALPHA_NUMERIC),
-            defaultName: DEFAULT_TOOL_NAME,
-            trimWhitespace: true,
-            onViolation: 'truncate'
-        },
-        response: {
-            maxNameLength: 64,
-            allowedCharacters: clonePattern(ALPHA_NUMERIC),
-            defaultName: DEFAULT_TOOL_NAME,
-            trimWhitespace: true,
-            onViolation: 'truncate'
-        }
-    },
-    anthropic: {
-        request: {
-            maxNameLength: 64,
-            allowedCharacters: clonePattern(LOWER_SNAKE),
-            forceCase: 'lower',
-            defaultName: DEFAULT_TOOL_NAME,
-            trimWhitespace: true,
-            onViolation: 'truncate'
-        },
-        response: {
-            maxNameLength: 64,
-            allowedCharacters: clonePattern(LOWER_SNAKE),
-            forceCase: 'lower',
-            defaultName: DEFAULT_TOOL_NAME,
-            trimWhitespace: true,
-            onViolation: 'truncate'
-        }
-    },
-    gemini: {
-        request: {
-            maxNameLength: 64,
-            allowedCharacters: clonePattern(ALPHA_NUMERIC),
-            defaultName: DEFAULT_TOOL_NAME,
-            trimWhitespace: true,
-            onViolation: 'truncate'
-        },
-        response: {
-            maxNameLength: 64,
-            allowedCharacters: clonePattern(ALPHA_NUMERIC),
-            defaultName: DEFAULT_TOOL_NAME,
-            trimWhitespace: true,
-            onViolation: 'truncate'
-        }
+function mapAllowedCharacters(token, fallback) {
+    const normalized = String(token || '').trim().toLowerCase();
+    if (normalized === 'lower_snake') {
+        return clonePattern(LOWER_SNAKE);
     }
-};
+    return clonePattern(fallback);
+}
+function mapNativeRules(nativeRules, fallback) {
+    if (!nativeRules || typeof nativeRules !== 'object') {
+        return undefined;
+    }
+    return {
+        maxNameLength: typeof nativeRules.maxNameLength === 'number' && Number.isFinite(nativeRules.maxNameLength)
+            ? Math.max(1, Math.floor(nativeRules.maxNameLength))
+            : fallback.maxNameLength,
+        allowedCharacters: mapAllowedCharacters(nativeRules.allowedCharacters, fallback.allowedCharacters),
+        defaultName: typeof nativeRules.defaultName === 'string' && nativeRules.defaultName.trim().length
+            ? nativeRules.defaultName.trim()
+            : fallback.defaultName,
+        trimWhitespace: nativeRules.trimWhitespace !== false,
+        ...(nativeRules.forceCase === 'lower' || nativeRules.forceCase === 'upper'
+            ? { forceCase: nativeRules.forceCase }
+            : {}),
+        onViolation: nativeRules.onViolation === 'reject' ? 'reject' : 'truncate'
+    };
+}
+function mapProtocolNode(nativeNode, options) {
+    const defaultName = 'tool';
+    const maxNameLength = 64;
+    const fallbackBase = {
+        allowedCharacters: options.allowedCharacters,
+        defaultName,
+        maxNameLength
+    };
+    const request = mapNativeRules(nativeNode?.request, fallbackBase) ?? {
+        ...fallbackBase,
+        trimWhitespace: true,
+        onViolation: 'truncate',
+        ...(options.forceCase ? { forceCase: options.forceCase } : {})
+    };
+    const response = mapNativeRules(nativeNode?.response, fallbackBase) ?? {
+        ...fallbackBase,
+        trimWhitespace: true,
+        onViolation: 'truncate',
+        ...(options.forceCase ? { forceCase: options.forceCase } : {})
+    };
+    if (options.forceCase) {
+        request.forceCase = options.forceCase;
+        response.forceCase = options.forceCase;
+    }
+    return {
+        request,
+        response
+    };
+}
+function mapNativeRegistry(nativeRegistry) {
+    return {
+        'openai-chat': mapProtocolNode(nativeRegistry['openai-chat'], {
+            allowedCharacters: ALPHA_NUMERIC
+        }),
+        'openai-responses': mapProtocolNode(nativeRegistry['openai-responses'], {
+            allowedCharacters: ALPHA_NUMERIC
+        }),
+        anthropic: mapProtocolNode(nativeRegistry.anthropic, {
+            allowedCharacters: LOWER_SNAKE,
+            forceCase: 'lower'
+        }),
+        gemini: mapProtocolNode(nativeRegistry.gemini, {
+            allowedCharacters: ALPHA_NUMERIC
+        })
+    };
+}
+export const DEFAULT_TOOL_GOVERNANCE_RULES = mapNativeRegistry(resolveDefaultToolGovernanceRulesWithNative());

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

@@ -2,7 +2,7 @@ import { isJsonObject, jsonClone } from '../types/json.js';
 import { mapBridgeToolsToChat, mapChatToolsToBridge } from '../../shared/tool-mapping.js';
 import { buildGeminiToolsFromBridge, prepareGeminiToolsForBridge } from '../../shared/gemini-tool-utils.js';
 import { mapAnthropicToolsToChat, mapChatToolsToAnthropicTools } from '../../shared/anthropic-message-utils.js';
-import { convertBridgeInputToChatMessages, convertMessagesToBridgeInput } from '../../shared/bridge-message-utils.js';
+import { convertBridgeInputToChatMessages, convertMessagesToBridgeInput } from '../../bridge-message-utils.js';
 import { resolveHubProtocolSpec } from '../policy/protocol-spec.js';
 import { normalizeProviderProtocolTokenWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 function clampSampleRate(value) {

package/dist/conversion/index.d.ts

@@ -19,9 +19,8 @@ export * from './shared/tooling.js';
 export * from '../guidance/index.js';
 export * from './shared/tool-mapping.js';
 export * from './shared/reasoning-mapping.js';
-export * from './shared/args-mapping.js';
+export * from './args-mapping.js';
 export * from './shared/text-markup-normalizer.js';
-export * from './shared/tool-canonicalizer.js';
 export * from './shared/tool-governor.js';
 export { governTools } from './shared/tool-governor.js';
 export * from './shared/streaming-text-extractor.js';

package/dist/conversion/index.js

@@ -19,9 +19,8 @@ export * from './shared/tooling.js';
 export * from '../guidance/index.js';
 export * from './shared/tool-mapping.js';
 export * from './shared/reasoning-mapping.js';
-export * from './shared/args-mapping.js';
+export * from './args-mapping.js';
 export * from './shared/text-markup-normalizer.js';
-export * from './shared/tool-canonicalizer.js';
 export * from './shared/tool-governor.js';
 export { governTools } from './shared/tool-governor.js';
 export * from './shared/streaming-text-extractor.js';

package/dist/conversion/{shared/jsonish.js → jsonish.js}

@@ -1,5 +1,5 @@
 // Shared JSON-ish parsing helpers
-import { parseLenientJsonishWithNative, repairArgumentsToStringWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { parseLenientJsonishWithNative, repairArgumentsToStringWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export function tryParseJson(s) {
     if (typeof s !== 'string')
         return s;

package/dist/conversion/{shared/mcp-injection.js → mcp-injection.js}

@@ -1,4 +1,4 @@
-import { injectMcpToolsForChatWithNative, injectMcpToolsForResponsesWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { injectMcpToolsForChatWithNative, injectMcpToolsForResponsesWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export function injectMcpToolsForChat(tools, discoveredServers) {
     return injectMcpToolsForChatWithNative(tools, discoveredServers);
 }

package/dist/conversion/media.js

@@ -0,0 +1,4 @@
+import { isImagePathWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function isImagePath(p) {
+    return isImagePathWithNative(p);
+}

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

@@ -1,4 +1,4 @@
-import { type JsonObject, type JsonValue } from '../hub/types/json.js';
+import { type JsonObject, type JsonValue } from './hub/types/json.js';
 interface PassthroughOptions {
     prefix: string;
     keys: readonly string[];

package/dist/conversion/{shared/metadata-passthrough.js → metadata-passthrough.js}

@@ -1,5 +1,5 @@
-import { isJsonObject, jsonClone } from '../hub/types/json.js';
-import { encodeMetadataPassthroughWithNative, extractMetadataPassthroughWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { isJsonObject, jsonClone } from './hub/types/json.js';
+import { encodeMetadataPassthroughWithNative, extractMetadataPassthroughWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export function encodeMetadataPassthrough(parameters, options) {
     return encodeMetadataPassthroughWithNative(parameters, options.prefix, options.keys);
 }

package/dist/conversion/payload-budget.js

@@ -0,0 +1,47 @@
+// Resolve payload budget (bytes) for a given model from host app config, with safety headroom.
+import { UnifiedConfig } from '../config-unified/unified-config.js';
+import { enforceChatBudgetWithNative, resolveBudgetForModelWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function resolveBudgetForModelSync(modelId) {
+    let viaFacade = null;
+    try {
+        const resolved = UnifiedConfig.getContextBudgetForModel(modelId);
+        if (resolved && typeof resolved.allowedBytes === 'number') {
+            viaFacade = resolved;
+        }
+    }
+    catch {
+        // ignore facade errors and fallback
+    }
+    if (viaFacade) {
+        return viaFacade;
+    }
+    return resolveBudgetForModelWithNative(modelId, null);
+}
+export const resolveBudgetForModel = async (modelId) => resolveBudgetForModelSync(modelId);
+// Apply payload budget enforcement to an OpenAI Chat-shaped request object in-place.
+// Strategy (deterministic, minimal):
+// 1) Truncate the first system message to RCC_SYSTEM_TEXT_LIMIT (default 8192 chars).
+// 2) Remove assistant messages that have no tool_calls and empty/whitespace content.
+// 3) Iteratively clamp tool role message content down to fit allowedBytes.
+// 4) If仍超限，轻度收紧 assistant 文本（不移除，仅截断）。
+export function enforceChatBudget(chat, modelId) {
+    try {
+        if (!chat || typeof chat !== 'object')
+            return chat;
+        const messages = Array.isArray(chat.messages) ? chat.messages : [];
+        if (!messages.length)
+            return chat;
+        const budget = resolveBudgetForModelSync(modelId || 'unknown');
+        const allowed = Math.max(1024, Number(budget.allowedBytes || 200000));
+        const sysLimit = (() => {
+            const raw = process?.env?.RCC_SYSTEM_TEXT_LIMIT;
+            const n = Number(raw);
+            return Number.isFinite(n) && n >= 0 ? n : 8192;
+        })();
+        return enforceChatBudgetWithNative(chat, allowed, sysLimit);
+    }
+    catch {
+        // ignore budget errors
+    }
+    return chat;
+}

package/dist/conversion/protocol-field-allowlists.d.ts

@@ -0,0 +1,7 @@
+export declare const OPENAI_CHAT_ALLOWED_FIELDS: readonly string[];
+export declare const ANTHROPIC_ALLOWED_FIELDS: readonly string[];
+export declare const OPENAI_RESPONSES_ALLOWED_FIELDS: readonly string[];
+export declare const GEMINI_ALLOWED_FIELDS: readonly string[];
+export declare const OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS: readonly string[];
+export declare const OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS: readonly string[];
+export declare const ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS: readonly string[];

package/dist/conversion/protocol-field-allowlists.js

@@ -0,0 +1,9 @@
+import { resolveHubProtocolAllowlistsWithNative } from '../router/virtual-router/engine-selection/native-hub-bridge-policy-semantics.js';
+const allowlists = resolveHubProtocolAllowlistsWithNative();
+export const OPENAI_CHAT_ALLOWED_FIELDS = Object.freeze([...allowlists.openaiChatAllowedFields]);
+export const ANTHROPIC_ALLOWED_FIELDS = Object.freeze([...allowlists.anthropicAllowedFields]);
+export const OPENAI_RESPONSES_ALLOWED_FIELDS = Object.freeze([...allowlists.openaiResponsesAllowedFields]);
+export const GEMINI_ALLOWED_FIELDS = Object.freeze([...allowlists.geminiAllowedFields]);
+export const OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS = Object.freeze([...allowlists.openaiResponsesParametersWrapperAllowKeys]);
+export const OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS = Object.freeze([...allowlists.openaiChatParametersWrapperAllowKeys]);
+export const ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS = Object.freeze([...allowlists.anthropicParametersWrapperAllowKeys]);

package/dist/conversion/{shared/protocol-state.d.ts → protocol-state.d.ts}

@@ -1,4 +1,4 @@
-import type { ChatEnvelope } from '../hub/types/chat-envelope.js';
-import { type JsonObject } from '../hub/types/json.js';
+import type { ChatEnvelope } from './hub/types/chat-envelope.js';
+import { type JsonObject } from './hub/types/json.js';
 export declare function ensureProtocolState(metadata: ChatEnvelope['metadata'], protocol: string): JsonObject;
 export declare function getProtocolState(metadata: ChatEnvelope['metadata'] | undefined, protocol: string): JsonObject | undefined;

package/dist/conversion/{shared/protocol-state.js → protocol-state.js}

@@ -1,5 +1,5 @@
-import { isJsonObject } from '../hub/types/json.js';
-import { ensureProtocolStateWithNative, getProtocolStateWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { isJsonObject } from './hub/types/json.js';
+import { ensureProtocolStateWithNative, getProtocolStateWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 const PROTOCOL_STATE_KEY = 'protocolState';
 export function ensureProtocolState(metadata, protocol) {
     const native = ensureProtocolStateWithNative(metadata, protocol);

package/dist/conversion/{shared/errors.d.ts → provider-protocol-error.d.ts}

@@ -4,9 +4,6 @@ export interface ProviderProtocolErrorOptions {
     code: ProviderProtocolErrorCode;
     protocol?: string;
     providerType?: string;
-    /**
-     * 粗粒度错误类别；若未显式指定，将基于 code 自动推导。
-     */
     category?: ProviderErrorCategory;
     details?: Record<string, unknown>;
 }

package/dist/conversion/provider-protocol-error.js

@@ -0,0 +1,25 @@
+import { buildProviderProtocolErrorWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export class ProviderProtocolError extends Error {
+    code;
+    protocol;
+    providerType;
+    category;
+    details;
+    constructor(message, options) {
+        super(message);
+        this.name = 'ProviderProtocolError';
+        const native = buildProviderProtocolErrorWithNative({
+            message,
+            code: options.code,
+            protocol: options.protocol,
+            providerType: options.providerType,
+            category: options.category,
+            details: options.details
+        });
+        this.code = options.code;
+        this.protocol = typeof native.protocol === 'string' ? native.protocol : options.protocol;
+        this.providerType = typeof native.providerType === 'string' ? native.providerType : options.providerType;
+        this.category = native.category || options.category || 'EXTERNAL_ERROR';
+        this.details = native.details ?? options.details;
+    }
+}

package/dist/conversion/responses/responses-openai-bridge/response-payload.js

@@ -1,13 +1,13 @@
 import { evaluateResponsesHostPolicy } from '../responses-host-policy.js';
-import { canonicalizeChatResponseTools } from '../../shared/tool-canonicalizer.js';
 import { normalizeMessageReasoningTools } from '../../shared/reasoning-tool-normalizer.js';
-import { createBridgeActionState, runBridgeActionPipeline } from '../../shared/bridge-actions.js';
-import { resolveBridgePolicy, resolvePolicyActions } from '../../shared/bridge-policies.js';
+import { createBridgeActionState, runBridgeActionPipeline } from '../../bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from '../../bridge-policies.js';
 import { buildResponsesOutputFromChat } from '../../shared/responses-output-builder.js';
 import { consumeResponsesPayloadSnapshot, consumeResponsesPassthrough } from '../../shared/responses-reasoning-registry.js';
 import { sanitizeResponsesFunctionName, stripInternalToolingMetadata } from '../../shared/responses-tool-utils.js';
-import { ProviderProtocolError } from '../../shared/errors.js';
+import { ProviderProtocolError } from '../../provider-protocol-error.js';
 import { normalizeResponsesToolCallArgumentsForClientWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+import { normalizeChatResponseReasoningToolsWithNative } from '../../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
 function isPlainObject(value) {
     return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }
@@ -77,6 +77,9 @@ function mergeResponseOutputItems(baseOutput, sourceOutput) {
         if (isMissingResponseField(baseItem.summary) && sourceItem.summary !== undefined) {
             baseItem.summary = deepCloneRecord({ value: sourceItem.summary }).value;
         }
+        if (isMissingResponseField(baseItem.encrypted_content) && sourceItem.encrypted_content !== undefined) {
+            baseItem.encrypted_content = deepCloneRecord({ value: sourceItem.encrypted_content }).value;
+        }
         return baseItem;
     });
 }
@@ -381,7 +384,7 @@ export function buildResponsesPayloadFromChat(payload, context) {
         }
         return mergedFallback;
     }
-    const canonical = canonicalizeChatResponseTools(response);
+    const canonical = normalizeChatResponseReasoningToolsWithNative(response);
     const choices = Array.isArray(canonical?.choices) ? canonical.choices : [];
     const primaryChoice = choices[0] && typeof choices[0] === 'object' ? choices[0] : undefined;
     const message = primaryChoice && typeof primaryChoice.message === 'object' ? primaryChoice.message : undefined;

package/dist/conversion/responses/responses-openai-bridge/types.d.ts

@@ -1,4 +1,4 @@
-import type { BridgeInputItem, BridgeToolDefinition } from '../../shared/bridge-message-types.js';
+import type { BridgeInputItem, BridgeToolDefinition } from '../../types/bridge-message-types.js';
 import type { ChatToolDefinition } from '../../hub/types/chat-envelope.js';
 import type { JsonObject, JsonValue } from '../../hub/types/json.js';
 import type { ToolCallIdStyle } from '../../shared/responses-tool-utils.js';

package/dist/conversion/responses/responses-openai-bridge.d.ts

@@ -1,4 +1,4 @@
-import type { BridgeInputBuildResult } from '../shared/bridge-message-utils.js';
+import type { BridgeInputBuildResult } from '../bridge-message-utils.js';
 import type { BuildChatRequestResult, BuildResponsesRequestResult, ResponsesRequestContext } from './responses-openai-bridge/types.js';
 export type { BuildChatRequestResult, BuildResponsesRequestResult, ResponsesRequestContext } from './responses-openai-bridge/types.js';
 export declare function captureResponsesContext(payload: Record<string, unknown>, dto?: {