@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/conversion/hub/tool-session-compat.js

@@ -3,132 +3,8 @@ import fsSync from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { extractSessionIdentifiersFromMetadata } from './pipeline/session-identifiers.js';
+import { normalizeToolSessionMessagesWithNative, updateToolSessionHistoryWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
 const TOOL_HISTORY_ROOT = path.join(os.homedir(), '.routecodex', 'tool-history');
-const TOOL_UNKNOWN_PREFIX = '[RouteCodex] Tool call result unknown';
-function ensureArray(value) {
-    return Array.isArray(value) ? value : [];
-}
-function normalizeToolCallId(call) {
-    if (!call || typeof call !== 'object') {
-        return undefined;
-    }
-    const raw = call.id ??
-        call.tool_call_id ??
-        call.call_id;
-    if (typeof raw !== 'string') {
-        return undefined;
-    }
-    const trimmed = raw.trim();
-    return trimmed.length ? trimmed : undefined;
-}
-function normalizeToolMessageId(message) {
-    if (!message || typeof message !== 'object') {
-        return undefined;
-    }
-    const raw = message.tool_call_id ??
-        message.call_id ??
-        message.id;
-    if (typeof raw !== 'string') {
-        return undefined;
-    }
-    const trimmed = raw.trim();
-    return trimmed.length ? trimmed : undefined;
-}
-function findFirstNonToolIndex(messages, startIndex) {
-    let index = startIndex;
-    while (index < messages.length) {
-        const msg = messages[index];
-        if (!msg || typeof msg !== 'object') {
-            break;
-        }
-        const role = String(msg.role || '').toLowerCase();
-        if (role !== 'tool') {
-            break;
-        }
-        index += 1;
-    }
-    return index;
-}
-function findToolMessageIndex(messages, startIndex, callId) {
-    for (let i = startIndex; i < messages.length; i += 1) {
-        const msg = messages[i];
-        if (!msg || typeof msg !== 'object') {
-            continue;
-        }
-        const role = String(msg.role || '').toLowerCase();
-        if (role !== 'tool') {
-            continue;
-        }
-        const id = normalizeToolMessageId(msg);
-        if (id === callId) {
-            return i;
-        }
-    }
-    return -1;
-}
-function createUnknownToolMessage(callId, call) {
-    let name;
-    const fn = call && typeof call === 'object' ? call.function : undefined;
-    if (fn && typeof fn.name === 'string' && fn.name.trim().length) {
-        name = fn.name.trim();
-    }
-    const description = name ? `tool "${name}"` : 'tool call';
-    const content = `${TOOL_UNKNOWN_PREFIX}: ${description} (${callId}) did not produce a result in this session. Treat this tool as failed with unknown status.`;
-    const msg = {
-        role: 'tool',
-        tool_call_id: callId,
-        content
-    };
-    if (name) {
-        msg.name = name;
-    }
-    return msg;
-}
-function normalizeToolCallOrdering(messages) {
-    let index = 0;
-    while (index < messages.length) {
-        const message = messages[index];
-        if (!message || typeof message !== 'object') {
-            index += 1;
-            continue;
-        }
-        const role = String(message.role || '').toLowerCase();
-        if (role !== 'assistant') {
-            index += 1;
-            continue;
-        }
-        const toolCalls = ensureArray(message.tool_calls);
-        if (!toolCalls.length) {
-            index += 1;
-            continue;
-        }
-        let insertionIndex = index + 1;
-        for (const call of toolCalls) {
-            if (!call || typeof call !== 'object') {
-                continue;
-            }
-            const callId = normalizeToolCallId(call);
-            if (!callId) {
-                continue;
-            }
-            const existingIndex = findToolMessageIndex(messages, insertionIndex, callId);
-            if (existingIndex >= 0) {
-                if (existingIndex === insertionIndex) {
-                    insertionIndex += 1;
-                    continue;
-                }
-                const [relocated] = messages.splice(existingIndex, 1);
-                messages.splice(insertionIndex, 0, relocated);
-                insertionIndex += 1;
-                continue;
-            }
-            const placeholder = createUnknownToolMessage(callId, call);
-            messages.splice(insertionIndex, 0, placeholder);
-            insertionIndex += 1;
-        }
-        index = Math.max(index + 1, insertionIndex);
-    }
-}
 function sanitizeSessionId(raw) {
     const trimmed = raw.trim();
     if (!trimmed) {
@@ -173,116 +49,24 @@ async function persistSessionHistory(sessionId, history) {
         // history persistence must never block the main flow
     }
 }
-function collectToolHistoryRecords(messages) {
-    const now = new Date().toISOString();
-    const records = [];
-    for (const msg of messages) {
-        if (!msg || typeof msg !== 'object') {
-            continue;
-        }
-        const role = String(msg.role || '').toLowerCase();
-        if (role === 'assistant') {
-            const toolCalls = ensureArray(msg.tool_calls);
-            for (const call of toolCalls) {
-                const id = normalizeToolCallId(call);
-                if (!id) {
-                    continue;
-                }
-                const fn = call.function;
-                const name = fn && typeof fn.name === 'string' && fn.name.trim().length
-                    ? fn.name.trim()
-                    : undefined;
-                records.push({
-                    role: 'assistant',
-                    tool_use: { id, name },
-                    ts: now
-                });
-            }
-            continue;
-        }
-        if (role === 'tool') {
-            const id = normalizeToolMessageId(msg);
-            if (!id) {
-                continue;
-            }
-            const rawName = msg.name;
-            const name = typeof rawName === 'string' && rawName.trim().length ? rawName.trim() : undefined;
-            const content = msg.content;
-            const status = typeof content === 'string' && content.startsWith(TOOL_UNKNOWN_PREFIX) ? 'unknown' : 'ok';
-            records.push({
-                role: 'tool',
-                tool_result: { id, name, status },
-                ts: now
-            });
-        }
-    }
-    return records;
-}
-function buildUpdatedHistory(existing, delta) {
-    const prevMessages = existing?.lastMessages ?? [];
-    const combined = [...prevMessages, ...delta];
-    const trimmed = combined.slice(-10);
-    const pending = {};
-    for (const entry of trimmed) {
-        if (entry.tool_use) {
-            pending[entry.tool_use.id] = {
-                name: entry.tool_use.name,
-                ts: entry.ts
-            };
-        }
-        if (entry.tool_result) {
-            delete pending[entry.tool_result.id];
-        }
-    }
-    return {
-        lastMessages: trimmed,
-        pendingToolUses: pending,
-        updatedAt: new Date().toISOString()
-    };
-}
 export async function applyToolSessionCompat(chat, ctx) {
     if (!chat || !Array.isArray(chat.messages) || chat.messages.length === 0) {
         return;
     }
+    const normalized = normalizeToolSessionMessagesWithNative({
+        messages: chat.messages,
+        ...(Array.isArray(chat.toolOutputs) && chat.toolOutputs.length
+            ? { toolOutputs: chat.toolOutputs }
+            : {})
+    });
+    chat.messages = normalized.messages;
+    chat.toolOutputs = Array.isArray(normalized.toolOutputs) && normalized.toolOutputs.length
+        ? normalized.toolOutputs
+        : undefined;
     const entry = (ctx.entryEndpoint || '').toLowerCase();
     if (!entry.includes('/v1/messages')) {
-        normalizeToolCallOrdering(chat.messages);
         return;
     }
-    normalizeToolCallOrdering(chat.messages);
-    const validCallIds = new Set();
-    for (const msg of chat.messages) {
-        if (!msg || typeof msg !== 'object') {
-            continue;
-        }
-        const role = String(msg.role || '').toLowerCase();
-        if (role !== 'assistant') {
-            continue;
-        }
-        const toolCalls = ensureArray(msg.tool_calls);
-        for (const call of toolCalls) {
-            const id = normalizeToolCallId(call);
-            if (id) {
-                validCallIds.add(id);
-            }
-        }
-    }
-    if (Array.isArray(chat.toolOutputs) && chat.toolOutputs.length) {
-        const filtered = chat.toolOutputs.filter((entry) => {
-            if (!entry || typeof entry !== 'object') {
-                return false;
-            }
-            const rawId = entry.tool_call_id ??
-                entry.call_id ??
-                entry.id;
-            if (typeof rawId !== 'string') {
-                return false;
-            }
-            const trimmed = rawId.trim();
-            return trimmed.length > 0 && validCallIds.has(trimmed);
-        });
-        chat.toolOutputs = filtered.length ? filtered : undefined;
-    }
     const metadata = (chat.metadata || {});
     const identifiers = extractSessionIdentifiersFromMetadata(metadata);
     const sessionId = identifiers.sessionId;
@@ -290,10 +74,12 @@ export async function applyToolSessionCompat(chat, ctx) {
         return;
     }
     const history = await loadSessionHistory(sessionId);
-    const records = collectToolHistoryRecords(chat.messages);
-    if (!records.length && !history) {
+    const updated = updateToolSessionHistoryWithNative({
+        messages: chat.messages,
+        ...(history ? { existingHistory: history } : {})
+    });
+    if (!updated.history) {
         return;
     }
-    const updated = buildUpdatedHistory(history, records);
-    await persistSessionHistory(sessionId, updated);
+    await persistSessionHistory(sessionId, updated.history);
 }

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

@@ -2,8 +2,9 @@ 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) {
     const num = typeof value === 'number' && Number.isFinite(value) ? value : 1;
     if (num <= 0)
@@ -428,16 +429,17 @@ export function applyProviderOutboundToolSurface(args) {
     if (!shouldSample(config, args.requestId)) {
         return args.payload;
     }
+    const normalizedProviderProtocol = normalizeProviderProtocolTokenWithNative(args.providerProtocol) ?? args.providerProtocol;
     const payload = args.payload;
     const tools = payload.tools;
-    const candidate = buildCandidateTools({ providerProtocol: args.providerProtocol, tools });
+    const candidate = buildCandidateTools({ providerProtocol: normalizedProviderProtocol, tools });
     if (!candidate) {
         // Still allow history/tool-call surface observation even when tool definitions don't need conversion.
     }
     const stageBase = `hub_toolsurface.${config.mode}.provider_outbound`;
     const toolSchemaCandidate = candidate?.candidateTools;
     const schemaDiff = candidate ? computeToolSchemaDiff(tools, toolSchemaCandidate) : { diffCount: 0, diffHead: [] };
-    const expectedHistoryCarrier = resolveExpectedHistoryCarrier(args.providerProtocol);
+    const expectedHistoryCarrier = resolveExpectedHistoryCarrier(normalizedProviderProtocol);
     let historyReason = undefined;
     let historyBaseline = undefined;
     let historyCandidate = undefined;
@@ -492,7 +494,7 @@ export function applyProviderOutboundToolSurface(args) {
         }
         args.stageRecorder?.record(stageBase, {
             kind: 'provider_outbound',
-            providerProtocol: args.providerProtocol,
+            providerProtocol: normalizedProviderProtocol,
             reason: candidate?.reason ?? historyReason,
             diffCount: totalDiffCount,
             diffHead: diffHeadMerged,

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/jsonish.js

@@ -0,0 +1,20 @@
+// Shared JSON-ish parsing helpers
+import { parseLenientJsonishWithNative, repairArgumentsToStringWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function tryParseJson(s) {
+    if (typeof s !== 'string')
+        return s;
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return s;
+    }
+}
+// Lenient parsing for function.arguments often produced by models
+export function parseLenient(value) {
+    return parseLenientJsonishWithNative(value);
+}
+// CCR-style repair: JSON -> JSON5-like cleanup -> safe fallback
+export function repairArgumentsToString(value) {
+    return repairArgumentsToStringWithNative(value);
+}

package/dist/conversion/mcp-injection.js

@@ -0,0 +1,7 @@
+import { injectMcpToolsForChatWithNative, injectMcpToolsForResponsesWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function injectMcpToolsForChat(tools, discoveredServers) {
+    return injectMcpToolsForChatWithNative(tools, discoveredServers);
+}
+export function injectMcpToolsForResponses(tools, discoveredServers) {
+    return injectMcpToolsForResponsesWithNative(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/metadata-passthrough.js

@@ -0,0 +1,20 @@
+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);
+}
+export function extractMetadataPassthrough(metadataField, options) {
+    if (!metadataField || !isJsonObject(metadataField)) {
+        return {};
+    }
+    const cloned = jsonClone(metadataField);
+    const native = extractMetadataPassthroughWithNative(cloned, options.prefix, options.keys);
+    const metadata = native.metadata && isJsonObject(native.metadata) ? native.metadata : undefined;
+    const passthrough = native.passthrough && isJsonObject(native.passthrough)
+        ? native.passthrough
+        : undefined;
+    return {
+        metadata,
+        passthrough
+    };
+}

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/protocol-state.js

@@ -0,0 +1,27 @@
+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);
+    for (const key of Object.keys(metadata)) {
+        if (!Object.prototype.hasOwnProperty.call(native.metadata, key)) {
+            delete metadata[key];
+        }
+    }
+    Object.assign(metadata, native.metadata);
+    if (!metadata[PROTOCOL_STATE_KEY] || !isJsonObject(metadata[PROTOCOL_STATE_KEY])) {
+        metadata[PROTOCOL_STATE_KEY] = {};
+    }
+    const container = metadata[PROTOCOL_STATE_KEY];
+    if (!isJsonObject(container[protocol])) {
+        container[protocol] = native.node;
+    }
+    return container[protocol];
+}
+export function getProtocolState(metadata, protocol) {
+    if (!metadata) {
+        return undefined;
+    }
+    const node = getProtocolStateWithNative(metadata, protocol);
+    return node && isJsonObject(node) ? node : undefined;
+}

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-host-policy.js

@@ -1,14 +1,4 @@
+import { evaluateResponsesHostPolicyWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
 export function evaluateResponsesHostPolicy(context, targetProtocol) {
-    const protocol = typeof targetProtocol === 'string' && targetProtocol.trim()
-        ? targetProtocol
-        : (typeof context?.targetProtocol === 'string' && context.targetProtocol.trim()
-            ? context.targetProtocol
-            : 'responses');
-    const normalized = protocol.toLowerCase();
-    const shouldStrip = normalized !== 'openai-responses' &&
-        normalized !== 'responses';
-    return {
-        shouldStripHostManagedFields: shouldStrip,
-        targetProtocol: normalized
-    };
+    return evaluateResponsesHostPolicyWithNative(context, targetProtocol);
 }