@jsonstudio/llms 0.6.2172 → 0.6.2979

package/dist/conversion/shared/reasoning-tool-normalizer.js

@@ -1,141 +1,29 @@
-import { extractToolCallsFromReasoningText } from './reasoning-tool-parser.js';
-import { mergeToolCalls } from './tool-call-utils.js';
-const THINK_TAG_PATTERN = /<\/?think[^>]*>/gi;
-const REFLECTION_TAG_PATTERN = /<\/?reflection[^>]*>/gi;
-function flattenReasoning(value, depth = 0) {
-    if (depth > 4 || value == null) {
-        return '';
+import { normalizeChatResponseReasoningToolsWithNative, normalizeMessageReasoningToolsWithNative } from '../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
+function overwriteRecordInPlace(target, source) {
+    for (const key of Object.keys(target)) {
+        delete target[key];
     }
-    if (typeof value === 'string') {
-        return value;
+    for (const [key, value] of Object.entries(source)) {
+        target[key] = value;
     }
-    if (Array.isArray(value)) {
-        return value
-            .map((item) => flattenReasoning(item, depth + 1))
-            .filter(Boolean)
-            .join('\n');
-    }
-    if (typeof value === 'object') {
-        const record = value;
-        if (typeof record.text === 'string') {
-            return record.text;
-        }
-        if (typeof record.content === 'string') {
-            return record.content;
-        }
-        if (Array.isArray(record.content) || typeof record.content === 'object') {
-            return flattenReasoning(record.content, depth + 1);
-        }
-    }
-    return '';
-}
-function collectReasoningFragments(message) {
-    const fragments = [];
-    if ('reasoning_content' in message) {
-        const text = flattenReasoning(message.reasoning_content);
-        if (text) {
-            fragments.push(text);
-        }
-    }
-    if ('reasoning' in message) {
-        const text = flattenReasoning(message.reasoning);
-        if (text) {
-            fragments.push(text);
-        }
-    }
-    return fragments;
-}
-function writeReasoningContent(message, text) {
-    const trimmed = text.trim();
-    if (trimmed.length) {
-        message.reasoning_content = trimmed;
-    }
-    else if (Object.prototype.hasOwnProperty.call(message, 'reasoning_content')) {
-        delete message.reasoning_content;
-    }
-    if (typeof message.reasoning === 'string') {
-        if (trimmed.length) {
-            message.reasoning = trimmed;
-        }
-        else {
-            delete message.reasoning;
-        }
-    }
-}
-function stripReasoningTags(text) {
-    if (!text) {
-        return '';
-    }
-    return text.replace(THINK_TAG_PATTERN, '').replace(REFLECTION_TAG_PATTERN, '').trim();
 }
 export function normalizeMessageReasoningTools(message, options) {
     if (!message || typeof message !== 'object') {
         return { toolCallsAdded: 0 };
     }
-    const fragments = collectReasoningFragments(message);
-    if (!fragments.length) {
-        const existing = typeof message.reasoning_content === 'string'
-            ? message.reasoning_content.trim()
-            : '';
-        if (!existing && Object.prototype.hasOwnProperty.call(message, 'reasoning_content')) {
-            delete message.reasoning_content;
-        }
-        return { toolCallsAdded: 0 };
-    }
-    const combined = fragments.join('\n').trim();
-    if (!combined.length) {
-        writeReasoningContent(message, '');
-        return { toolCallsAdded: 0 };
-    }
-    const sanitized = stripReasoningTags(combined);
-    if (!sanitized.length) {
-        writeReasoningContent(message, '');
-        return { toolCallsAdded: 0 };
-    }
-    const idPrefix = options?.idPrefix ?? 'reasoning';
-    const { cleanedText, toolCalls } = extractToolCallsFromReasoningText(sanitized, { idPrefix });
-    const trimmed = (cleanedText || '').trim();
-    writeReasoningContent(message, trimmed);
-    // Chat 统一行为：如果 message 本身没有正文内容，但存在非空 reasoning_content，
-    // 则将思考内容提升到正文，前后包裹 [思考] 标记，避免客户端只看到"空回答"。
-    const rawContent = message.content;
-    if ((typeof rawContent !== 'string' || rawContent.trim().length === 0) &&
-        trimmed.length > 0) {
-        // 检查是否已经包含 [思考] 标签，避免重复嵌套
-        const hasThinkingTags = trimmed.includes('[思考]') && trimmed.includes('[/思考]');
-        message.content = hasThinkingTags ? trimmed : `[思考]\n${trimmed}\n[/思考]`;
-    }
-    if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
-        return { toolCallsAdded: 0, cleanedReasoning: trimmed };
-    }
-    const current = Array.isArray(message.tool_calls)
-        ? message.tool_calls
-        : undefined;
-    const merged = mergeToolCalls(current, toolCalls);
-    message.tool_calls = merged;
+    const normalized = normalizeMessageReasoningToolsWithNative(message, typeof options?.idPrefix === 'string' ? options.idPrefix : undefined);
+    overwriteRecordInPlace(message, normalized.message);
     return {
-        toolCallsAdded: merged.length - (current?.length ?? 0),
-        cleanedReasoning: trimmed
+        toolCallsAdded: normalized.toolCallsAdded,
+        ...(typeof normalized.cleanedReasoning === 'string'
+            ? { cleanedReasoning: normalized.cleanedReasoning }
+            : {})
     };
 }
 export function normalizeChatResponseReasoningTools(response, options) {
     if (!response || typeof response !== 'object') {
         return;
     }
-    const choices = Array.isArray(response.choices)
-        ? response.choices
-        : [];
-    for (let i = 0; i < choices.length; i++) {
-        const choice = choices[i];
-        if (!choice || typeof choice !== 'object') {
-            continue;
-        }
-        const message = choice.message;
-        if (!message || typeof message !== 'object') {
-            continue;
-        }
-        normalizeMessageReasoningTools(message, {
-            idPrefix: `${options?.idPrefixBase ?? 'reasoning_choice'}_${i + 1}`
-        });
-    }
+    const normalized = normalizeChatResponseReasoningToolsWithNative(response, typeof options?.idPrefixBase === 'string' ? options.idPrefixBase : undefined);
+    overwriteRecordInPlace(response, normalized);
 }

package/dist/conversion/shared/reasoning-tool-parser.js

@@ -1,95 +1,12 @@
-import { repairArgumentsToString, parseLenient } from './jsonish.js';
-const FENCE_PATTERN = /```(?:tool_call|tool_calls|function_call|json)?\s*([\s\S]*?)\s*```/gi;
-const TAG_PATTERN = /<(tool_call|function_call)(?:\s+name="([^"]+)")?\s*>([\s\S]*?)<\/\1>/gi;
-const BRACKET_PATTERN = /\[(tool_call|function_call)(?:\s+name="([^"]+)")?\]([\s\S]*?)\[\/\1\]/gi;
-const LABEL_PATTERN = /(tool_call|function_call)\s*[:=]\s*({[\s\S]+?})/gi;
+import { extractToolCallsFromReasoningTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export function extractToolCallsFromReasoningText(text, options) {
     if (typeof text !== 'string' || !text.trim()) {
         return { cleanedText: typeof text === 'string' ? text : '', toolCalls: [] };
     }
     const idPrefix = options?.idPrefix ?? 'reasoning';
-    const matches = [];
-    const consume = (pattern, getPayload) => {
-        pattern.lastIndex = 0;
-        let match;
-        while ((match = pattern.exec(text))) {
-            const payload = getPayload(match);
-            if (!payload) {
-                continue;
-            }
-            const parsed = parseToolCall(payload.body, payload.nameHint);
-            if (!parsed) {
-                continue;
-            }
-            matches.push({ start: match.index, end: match.index + match[0].length, call: parsed });
-        }
-    };
-    consume(FENCE_PATTERN, match => ({ body: match[1] ?? '' }));
-    consume(TAG_PATTERN, match => ({ body: match[3] ?? '', nameHint: match[2] }));
-    consume(BRACKET_PATTERN, match => ({ body: match[3] ?? '', nameHint: match[2] }));
-    consume(LABEL_PATTERN, match => ({ body: match[2] ?? '' }));
-    if (!matches.length) {
-        const parsed = parseToolCall(text);
-        if (parsed) {
-            return {
-                cleanedText: '',
-                toolCalls: [buildToolCall(parsed, idPrefix, 0)]
-            };
-        }
-        return { cleanedText: text, toolCalls: [] };
-    }
-    const toolCalls = matches.map((entry, index) => buildToolCall(entry.call, idPrefix, index));
-    matches.sort((a, b) => b.start - a.start);
-    let cleaned = text;
-    for (const entry of matches) {
-        cleaned = cleaned.slice(0, entry.start) + cleaned.slice(entry.end);
-    }
-    return {
-        cleanedText: cleaned.trim(),
-        toolCalls
-    };
-}
-function parseToolCall(raw, nameHint) {
-    if (!raw || typeof raw !== 'string') {
-        return null;
-    }
-    const trimmed = raw.trim();
-    if (!trimmed) {
-        return null;
-    }
-    const parsed = parseLenient(trimmed);
-    if (!parsed || typeof parsed !== 'object') {
-        return null;
-    }
-    const candidateName = parsed.name ??
-        parsed.function?.name ??
-        parsed.tool_name ??
-        parsed.tool ??
-        nameHint;
-    const name = typeof candidateName === 'string' ? candidateName.trim() : undefined;
-    if (!name) {
-        return null;
-    }
-    const argsSource = parsed.function?.arguments ??
-        parsed.arguments ??
-        parsed.input ??
-        parsed.params ??
-        parsed.parameters ??
-        parsed.payload ??
-        {};
-    const args = repairArgumentsToString(argsSource);
-    return {
-        name,
-        args
-    };
-}
-function buildToolCall(parsed, prefix, index) {
+    const output = extractToolCallsFromReasoningTextWithNative(text, idPrefix);
     return {
-        id: `${prefix}_${index + 1}`,
-        type: 'function',
-        function: {
-            name: parsed.name,
-            arguments: parsed.args
-        }
+        cleanedText: output.cleanedText,
+        toolCalls: output.toolCalls
     };
 }

package/dist/conversion/shared/reasoning-utils.js

@@ -1,3 +1,4 @@
+import { sanitizeReasoningTaggedTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export function extractReasoningSegments(source, reasoningCollector) {
     let working = source ?? '';
     const hasExplicitOpen = /<think>/i.test(source) ||
@@ -33,10 +34,5 @@ export function extractReasoningSegments(source, reasoningCollector) {
     return working.trim();
 }
 export function sanitizeReasoningTaggedText(value) {
-    try {
-        return extractReasoningSegments(value);
-    }
-    catch {
-        return value;
-    }
+    return sanitizeReasoningTaggedTextWithNative(value);
 }

package/dist/conversion/shared/responses-conversation-store.js

@@ -1,5 +1,6 @@
 import { ProviderProtocolError } from './errors.js';
-import { normalizeFunctionCallOutputId } from './bridge-id-utils.js';
+import { normalizeFunctionCallOutputIdWithNative as normalizeFunctionCallOutputId } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { convertResponsesOutputToInputItemsWithNative, pickResponsesPersistedFieldsWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 const TTL_MS = 1000 * 60 * 30; // 30min
 function cloneDeep(value) {
     try {
@@ -28,89 +29,10 @@ function coerceTools(tools) {
     return cloneDeep(tools);
 }
 function pickPersistedFields(payload) {
-    const fields = [
-        'model',
-        'instructions',
-        'metadata',
-        'include',
-        'store',
-        'tool_choice',
-        'parallel_tool_calls',
-        'response_format',
-        'temperature',
-        'top_p',
-        'max_output_tokens',
-        'max_tokens',
-        'stop',
-        'user',
-        'modal',
-        'truncation_strategy',
-        'previous_response_id',
-        'reasoning',
-        'attachments',
-        'input_audio',
-        'output_audio'
-    ];
-    const next = {};
-    for (const key of fields) {
-        if (payload[key] !== undefined) {
-            next[key] = cloneDeep(payload[key]);
-        }
-    }
-    return next;
-}
-function normalizeOutputItemToInput(item) {
-    if (!item || typeof item !== 'object') {
-        return null;
-    }
-    const type = typeof item.type === 'string' ? item.type : '';
-    if (type === 'message' || type === 'reasoning') {
-        const role = typeof item.role === 'string' ? item.role : 'assistant';
-        const content = Array.isArray(item.content)
-            ? cloneDeep(item.content)
-            : typeof item.text === 'string'
-                ? [{ type: 'text', text: item.text }]
-                : [];
-        return {
-            type: 'message',
-            role,
-            content,
-            message: { role, content }
-        };
-    }
-    if (type === 'function_call') {
-        const callId = typeof item.call_id === 'string'
-            ? item.call_id
-            : typeof item.id === 'string'
-                ? item.id
-                : undefined;
-        return {
-            type: 'function_call',
-            role: 'assistant',
-            id: typeof item.id === 'string' ? item.id : undefined,
-            call_id: callId,
-            name: typeof item.name === 'string' ? item.name : undefined,
-            arguments: item.arguments,
-            function: isRecord(item.function)
-                ? cloneDeep(item.function)
-                : typeof item.name === 'string'
-                    ? { name: item.name, arguments: item.arguments }
-                    : undefined
-        };
-    }
-    return null;
+    return pickResponsesPersistedFieldsWithNative(payload);
 }
 function convertOutputToInputItems(response) {
-    const output = Array.isArray(response.output) ? response.output : [];
-    const items = [];
-    for (const entry of output) {
-        if (!entry || typeof entry !== 'object')
-            continue;
-        const mapped = normalizeOutputItemToInput(entry);
-        if (mapped)
-            items.push(mapped);
-    }
-    return items;
+    return convertResponsesOutputToInputItemsWithNative(response);
 }
 function normalizeSubmittedToolOutputs(toolOutputs, callIdToFunctionItemId) {
     const items = [];

package/dist/conversion/shared/responses-output-builder.js

@@ -1,6 +1,10 @@
 import { normalizeFunctionCallId, normalizeFunctionCallOutputId } from './bridge-id-utils.js';
 import { normalizeContentPart } from './output-content-normalizer.js';
 import { expandResponsesMessageItem } from '../../sse/shared/responses-output-normalizer.js';
+import { normalizeResponsesUsageWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+function isStableToolCallId(raw) {
+    return /^((fc|call)_[A-Za-z0-9_-]+)$/i.test(raw);
+}
 function buildToolOutputIndex(response) {
     const ids = new Set();
     try {
@@ -161,50 +165,7 @@ export function buildResponsesOutputFromChat(options) {
     };
 }
 function normalizeUsage(usageRaw) {
-    if (!usageRaw || typeof usageRaw !== 'object') {
-        return usageRaw;
-    }
-    const usage = { ...usageRaw };
-    // 统一 Responses 与 Chat 两种 usage 形态：
-    // - Responses: input_tokens / output_tokens / total_tokens
-    // - Chat: prompt_tokens / completion_tokens / total_tokens
-    const inputTokens = typeof usage.input_tokens === 'number'
-        ? usage.input_tokens
-        : typeof usage.prompt_tokens === 'number'
-            ? usage.prompt_tokens
-            : undefined;
-    const outputTokens = typeof usage.output_tokens === 'number'
-        ? usage.output_tokens
-        : typeof usage.completion_tokens === 'number'
-            ? usage.completion_tokens
-            : undefined;
-    let totalTokens = typeof usage.total_tokens === 'number'
-        ? usage.total_tokens
-        : undefined;
-    if (totalTokens === undefined && inputTokens !== undefined && outputTokens !== undefined) {
-        const total = Number(inputTokens) + Number(outputTokens);
-        if (!Number.isNaN(total)) {
-            totalTokens = total;
-        }
-    }
-    // Responses 规范字段：input_tokens / output_tokens / total_tokens
-    if (inputTokens !== undefined) {
-        usage.input_tokens = inputTokens;
-    }
-    if (outputTokens !== undefined) {
-        usage.output_tokens = outputTokens;
-    }
-    if (totalTokens !== undefined) {
-        usage.total_tokens = totalTokens;
-    }
-    // 为了兼容内部统计逻辑，保留 prompt_tokens / completion_tokens 映射（如果原本没有）
-    if (usage.prompt_tokens == null && inputTokens !== undefined) {
-        usage.prompt_tokens = inputTokens;
-    }
-    if (usage.completion_tokens == null && outputTokens !== undefined) {
-        usage.completion_tokens = outputTokens;
-    }
-    return usage;
+    return normalizeResponsesUsageWithNative(usageRaw);
 }
 function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, baseCount, offset) {
     try {
@@ -229,10 +190,13 @@ function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, b
         const originalCallId = typeof call.id === 'string' && call.id.trim().length
             ? String(call.id)
             : (typeof call.call_id === 'string' && call.call_id.trim().length ? String(call.call_id) : undefined);
-        // Preserve original tool call IDs when present (OpenAI Responses contract expects stable call_id
-        // across tool_call → submit_tool_outputs). Only generate/normalize when missing.
-        const callId = typeof originalCallId === 'string' && originalCallId.trim().length
+        const stableOriginalCallId = typeof originalCallId === 'string' && originalCallId.trim().length && isStableToolCallId(originalCallId.trim())
             ? originalCallId.trim()
+            : undefined;
+        // Preserve original tool call IDs when they already follow supported call-id styles.
+        // Otherwise normalize to fc_* to keep tool_call_id invariants stable across outputs.
+        const callId = typeof stableOriginalCallId === 'string' && stableOriginalCallId.length
+            ? stableOriginalCallId
             : normalizeFunctionCallId({
                 callId: originalCallId,
                 fallback: `fc_call_${baseCount + offset}`

package/dist/conversion/shared/responses-reasoning-registry.js

@@ -1,3 +1,4 @@
+import { parseLenientJsonishWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 const registry = new Map();
 function ensureEntry(id) {
     let entry = registry.get(id);
@@ -26,7 +27,12 @@ function cloneSnapshot(snapshot) {
         /* ignore structuredClone failures */
     }
     try {
-        return JSON.parse(JSON.stringify(snapshot));
+        const serialized = JSON.stringify(snapshot);
+        const parsed = parseLenientJsonishWithNative(serialized);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return undefined;
     }
     catch {
         return undefined;

package/dist/conversion/shared/responses-request-adapter.d.ts

@@ -1 +1,7 @@
-export { captureResponsesContext, buildChatRequestFromResponses } from '../responses/responses-openai-bridge.js';
+import type { BuildChatRequestResult, ResponsesRequestContext } from '../responses/responses-openai-bridge/types.js';
+export declare function captureResponsesContext(payload: Record<string, unknown>, dto?: {
+    route?: {
+        requestId?: string;
+    };
+}): ResponsesRequestContext;
+export declare function buildChatRequestFromResponses(payload: Record<string, unknown>, context: ResponsesRequestContext): BuildChatRequestResult;

package/dist/conversion/shared/responses-request-adapter.js

@@ -1 +1,14 @@
-export { captureResponsesContext, buildChatRequestFromResponses } from '../responses/responses-openai-bridge.js';
+import { buildChatRequestFromResponses as buildChatRequestFromResponsesImpl, captureResponsesContext as captureResponsesContextImpl } from '../responses/responses-openai-bridge.js';
+import { normalizeProviderProtocolTokenWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+function assertResponsesNativeBoundary() {
+    // Keep adapter as a thin boundary while forcing native capability presence.
+    normalizeProviderProtocolTokenWithNative('openai-responses');
+}
+export function captureResponsesContext(payload, dto) {
+    assertResponsesNativeBoundary();
+    return captureResponsesContextImpl(payload, dto);
+}
+export function buildChatRequestFromResponses(payload, context) {
+    assertResponsesNativeBoundary();
+    return buildChatRequestFromResponsesImpl(payload, context);
+}

package/dist/conversion/shared/responses-response-utils.js

@@ -1,10 +1,9 @@
-import { sanitizeResponsesFunctionName } from './responses-tool-utils.js';
-import { normalizeFunctionCallId } from './bridge-id-utils.js';
 import { extractOutputSegments } from './output-content-normalizer.js';
-import { sanitizeReasoningTaggedText } from './reasoning-utils.js';
 import { createBridgeActionState, runBridgeActionPipeline } from './bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from './bridge-policies.js';
 import { registerResponsesPayloadSnapshot, registerResponsesPassthrough } from './responses-reasoning-registry.js';
+import { normalizeFunctionCallIdWithNative, sanitizeReasoningTaggedTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { sanitizeResponsesFunctionNameWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
 function selectCallId(entry) {
     const candidates = [
         entry?.call_id,
@@ -23,7 +22,7 @@ function normalizeToolCall(entry, fallbackPrefix) {
     if (!entry || typeof entry !== 'object')
         return null;
     const fn = entry.function || {};
-    const rawName = sanitizeResponsesFunctionName(fn.name ?? entry.name);
+    const rawName = sanitizeResponsesFunctionNameWithNative(fn.name ?? entry.name);
     if (!rawName)
         return null;
     const argsRaw = fn.arguments ?? entry.arguments ?? {};
@@ -40,7 +39,7 @@ function normalizeToolCall(entry, fallbackPrefix) {
     const callIdRaw = selectCallId(entry);
     const callId = typeof callIdRaw === 'string' && callIdRaw.length
         ? callIdRaw
-        : normalizeFunctionCallId({
+        : normalizeFunctionCallIdWithNative({
             callId: callIdRaw,
             fallback: `${fallbackPrefix}_${Math.random().toString(36).slice(2, 10)}`
         });
@@ -187,7 +186,7 @@ export function buildChatResponseFromResponses(payload) {
     const { textParts, reasoningParts } = extractOutputSegments(response);
     const rawReasoningSegments = collectRawReasoningSegments(response);
     const explicitOutput = typeof response.output_text === 'string' && response.output_text.trim().length
-        ? sanitizeReasoningTaggedText(response.output_text)
+        ? sanitizeReasoningTaggedTextWithNative(response.output_text)
         : undefined;
     const messageContentText = explicitOutput || textParts.join('\n').trim();
     const messageContent = messageContentText || '';
@@ -244,7 +243,7 @@ export function buildChatResponseFromResponses(payload) {
     chat.__responses_output_text_meta = {
         hasField: hasOutputTextField,
         value: hasOutputTextField && typeof response.output_text === 'string'
-            ? sanitizeReasoningTaggedText(response.output_text)
+            ? sanitizeReasoningTaggedTextWithNative(response.output_text)
             : undefined
     };
     if (usage !== undefined) {

package/dist/conversion/shared/responses-tool-utils.d.ts

@@ -7,6 +7,7 @@ export interface CallIdTransformer {
 }
 export declare function createToolCallIdTransformer(style: ToolCallIdStyle): CallIdTransformer | null;
 export declare function enforceToolCallIdStyle(input: BridgeInputItem[], transformer: CallIdTransformer): void;
+export declare function normalizeResponsesToolCallIds(payload: Record<string, unknown> | null | undefined): void;
 export declare function resolveToolCallIdStyle(metadata: Record<string, unknown> | undefined): ToolCallIdStyle;
 export declare function stripInternalToolingMetadata(metadata: unknown): void;
 export declare function sanitizeResponsesFunctionName(rawName: unknown): string | undefined;