@jsonstudio/llms 0.6.2172 → 0.6.3214

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,9 +1,11 @@
+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) ||
         /<reflection>/i.test(source) ||
         /```\s*(?:think|reflection)/i.test(source);
-    const hasExplicitClose = /<\/think>/i.test(source) || /<\/reflection>/i.test(source);
+    const hasExplicitClose = /<\/think>/i.test(source) ||
+        /<\/reflection>/i.test(source);
     const push = (value) => {
         const trimmed = (value ?? '').trim();
         if (trimmed && reasoningCollector) {
@@ -21,7 +23,9 @@ export function extractReasoningSegments(source, reasoningCollector) {
             return '';
         });
     }
-    working = working.replace(/<\/?think>/gi, '').replace(/<\/?reflection>/gi, '');
+    working = working
+        .replace(/<\/?think>/gi, '')
+        .replace(/<\/?reflection>/gi, '');
     working = working.replace(/\n{3,}/g, '\n\n');
     if (reasoningCollector && !hasExplicitOpen && hasExplicitClose) {
         const trimmed = working.trim();
@@ -33,10 +37,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 { ProviderProtocolError } from '../provider-protocol-error.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 { 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 {
@@ -82,17 +86,28 @@ export function buildResponsesOutputFromChat(options) {
     }
     const hasToolCalls = toolCalls.length > 0;
     const reasoningChunks = [];
-    const preservedReasoning = Array.isArray(response?.__responses_reasoning)
-        ? response.__responses_reasoning
-        : undefined;
-    if (preservedReasoning && preservedReasoning.length) {
-        reasoningChunks.push(...preservedReasoning);
+    const preservedReasoning = response?.__responses_reasoning;
+    const preservedSummary = preservedReasoning?.summary ?? [];
+    const preservedContent = preservedReasoning?.content ?? [];
+    const preservedEncrypted = preservedReasoning?.encrypted_content;
+    if (preservedContent.length) {
+        for (const entry of preservedContent) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const text = String(entry.text ?? '').trim();
+            if (text.length) {
+                reasoningChunks.push(text);
+            }
+        }
     }
     else {
         appendReasoningSegments(reasoningChunks, message?.reasoning_content);
     }
     const convertedContent = convertChatContentToResponses(content);
-    const shouldEmitMessage = Boolean(message) && (convertedContent.length > 0 || reasoningChunks.length > 0 || !hasToolCalls);
+    const shouldEmitMessage = Boolean(message) && (convertedContent.length > 0 ||
+        reasoningChunks.length > 0 ||
+        preservedSummary.length > 0 ||
+        !hasToolCalls);
     if (shouldEmitMessage) {
         const responsesMessage = {
             id: allocateOutputId('message'),
@@ -106,6 +121,28 @@ export function buildResponsesOutputFromChat(options) {
             outputIndex: outputItems.length,
             extraReasoning: reasoningChunks
         });
+        const summaryItems = preservedSummary
+            .map((entry) => ({ type: 'summary_text', text: String(entry.text ?? '') }))
+            .filter((entry) => entry.text.trim().length > 0);
+        let reasoningItem = expandedItems.find((item) => item.type === 'reasoning');
+        if (!reasoningItem && summaryItems.length > 0) {
+            reasoningItem = {
+                id: `${responsesMessage.id}_reasoning`,
+                type: 'reasoning',
+                summary: summaryItems,
+                content: undefined,
+                ...(typeof preservedEncrypted === 'string' ? { encrypted_content: preservedEncrypted } : {})
+            };
+            expandedItems.unshift(reasoningItem);
+        }
+        else if (reasoningItem) {
+            if (summaryItems.length > 0) {
+                reasoningItem.summary = summaryItems;
+            }
+            if (typeof preservedEncrypted === 'string') {
+                reasoningItem.encrypted_content = preservedEncrypted;
+            }
+        }
         for (const expanded of expandedItems) {
             outputItems.push(expanded);
         }
@@ -161,50 +198,14 @@ 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 (usageRaw === null || usageRaw === undefined) {
+        return undefined;
     }
-    if (usage.completion_tokens == null && outputTokens !== undefined) {
-        usage.completion_tokens = outputTokens;
+    const normalized = normalizeResponsesUsageWithNative(usageRaw);
+    if (normalized === null) {
+        return undefined;
     }
-    return usage;
+    return normalized;
 }
 function buildFunctionCallOutput(call, allocateOutputId, sanitizeFunctionName, baseCount, offset) {
     try {
@@ -229,10 +230,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}`
@@ -301,9 +305,13 @@ function resolveOutputText(parts, meta) {
     if (meta && typeof meta === 'object') {
         const hasField = Boolean(meta.hasField);
         if (hasField) {
-            const raw = meta.value;
-            if (typeof raw === 'string') {
-                return raw;
+            const rawValue = meta.raw;
+            if (typeof rawValue === 'string') {
+                return rawValue;
+            }
+            const fallbackValue = meta.value;
+            if (typeof fallbackValue === 'string') {
+                return fallbackValue;
             }
             return '';
         }

package/dist/conversion/shared/responses-reasoning-registry.d.ts

@@ -1,9 +1,21 @@
 export interface ResponsesOutputTextMeta {
     hasField: boolean;
     value?: string;
+    raw?: string;
 }
-export declare function registerResponsesReasoning(id: unknown, segments: string[] | undefined): void;
-export declare function consumeResponsesReasoning(id: unknown): string[] | undefined;
+export interface ResponsesReasoningPayload {
+    summary?: Array<{
+        type: 'summary_text';
+        text: string;
+    }>;
+    content?: Array<{
+        type: 'reasoning_text' | 'text';
+        text: string;
+    }>;
+    encrypted_content?: string | null;
+}
+export declare function registerResponsesReasoning(id: unknown, reasoning: ResponsesReasoningPayload | undefined): void;
+export declare function consumeResponsesReasoning(id: unknown): ResponsesReasoningPayload | undefined;
 export declare function registerResponsesOutputTextMeta(id: unknown, meta: ResponsesOutputTextMeta | undefined): void;
 export declare function consumeResponsesOutputTextMeta(id: unknown): ResponsesOutputTextMeta | undefined;
 export declare function registerResponsesPayloadSnapshot(id: unknown, snapshot: Record<string, unknown> | undefined): void;

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,19 +27,46 @@ 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;
     }
 }
-export function registerResponsesReasoning(id, segments) {
+export function registerResponsesReasoning(id, reasoning) {
     if (typeof id !== 'string')
         return;
-    if (!Array.isArray(segments) || segments.length === 0)
+    if (!reasoning)
+        return;
+    const summary = Array.isArray(reasoning.summary)
+        ? reasoning.summary
+            .map((item) => ({ type: 'summary_text', text: String(item.text ?? '').trim() }))
+            .filter((item) => item.text.length > 0)
+        : undefined;
+    const content = Array.isArray(reasoning.content)
+        ? reasoning.content
+            .map((item) => ({
+            type: item.type === 'text' ? 'text' : 'reasoning_text',
+            text: String(item.text ?? '').trim()
+        }))
+            .filter((item) => item.text.length > 0)
+        : undefined;
+    const hasSummary = Array.isArray(summary) && summary.length > 0;
+    const hasContent = Array.isArray(content) && content.length > 0;
+    const hasEncrypted = reasoning.encrypted_content !== undefined;
+    if (!hasSummary && !hasContent && !hasEncrypted)
         return;
     const entry = ensureEntry(id);
-    entry.reasoning = [...segments];
+    entry.reasoning = {
+        summary: hasSummary ? summary : undefined,
+        content: hasContent ? content : undefined,
+        encrypted_content: reasoning.encrypted_content
+    };
 }
 export function consumeResponsesReasoning(id) {
     if (typeof id !== 'string')
@@ -46,7 +74,11 @@ export function consumeResponsesReasoning(id) {
     const entry = registry.get(id);
     if (!entry?.reasoning)
         return undefined;
-    const value = [...entry.reasoning];
+    const value = {
+        summary: entry.reasoning.summary ? [...entry.reasoning.summary] : undefined,
+        content: entry.reasoning.content ? [...entry.reasoning.content] : undefined,
+        encrypted_content: entry.reasoning.encrypted_content
+    };
     entry.reasoning = undefined;
     pruneEntry(id);
     return value;
@@ -59,7 +91,8 @@ export function registerResponsesOutputTextMeta(id, meta) {
     const entry = ensureEntry(id);
     entry.outputText = {
         hasField: Boolean(meta.hasField),
-        value: typeof meta.value === 'string' ? meta.value : undefined
+        value: typeof meta.value === 'string' ? meta.value : undefined,
+        raw: typeof meta.raw === 'string' ? meta.raw : undefined
     };
 }
 export function consumeResponsesOutputTextMeta(id) {
@@ -70,7 +103,8 @@ export function consumeResponsesOutputTextMeta(id) {
         return undefined;
     const value = {
         hasField: Boolean(entry.outputText.hasField),
-        value: entry.outputText.value
+        value: entry.outputText.value,
+        raw: entry.outputText.raw
     };
     entry.outputText = undefined;
     pruneEntry(id);

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);
+}