@jsonstudio/llms 0.6.3275 → 0.6.3379

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

@@ -1,18 +1,14 @@
 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];
-    }
-    for (const [key, value] of Object.entries(source)) {
-        target[key] = value;
+const MODULE_NAME = 'reasoning-tool-normalizer';
+function assertReasoningToolNormalizerNativeAvailable() {
+    if (typeof normalizeMessageReasoningToolsWithNative !== 'function' ||
+        typeof normalizeChatResponseReasoningToolsWithNative !== 'function') {
+        throw new Error(`[${MODULE_NAME}] native bindings unavailable`);
     }
 }
 export function normalizeMessageReasoningTools(message, options) {
-    if (!message || typeof message !== 'object') {
-        return { toolCallsAdded: 0 };
-    }
+    assertReasoningToolNormalizerNativeAvailable();
     const normalized = normalizeMessageReasoningToolsWithNative(message, typeof options?.idPrefix === 'string' ? options.idPrefix : undefined);
-    overwriteRecordInPlace(message, normalized.message);
     return {
         toolCallsAdded: normalized.toolCallsAdded,
         ...(typeof normalized.cleanedReasoning === 'string'
@@ -21,9 +17,6 @@ export function normalizeMessageReasoningTools(message, options) {
     };
 }
 export function normalizeChatResponseReasoningTools(response, options) {
-    if (!response || typeof response !== 'object') {
-        return;
-    }
-    const normalized = normalizeChatResponseReasoningToolsWithNative(response, typeof options?.idPrefixBase === 'string' ? options.idPrefixBase : undefined);
-    overwriteRecordInPlace(response, normalized);
+    assertReasoningToolNormalizerNativeAvailable();
+    normalizeChatResponseReasoningToolsWithNative(response, typeof options?.idPrefixBase === 'string' ? options.idPrefixBase : undefined);
 }

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

@@ -1,41 +1,19 @@
-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 push = (value) => {
-        const trimmed = (value ?? '').trim();
-        if (trimmed && reasoningCollector) {
-            reasoningCollector.push(trimmed);
-        }
-    };
-    const patterns = [
-        /<think>([\s\S]*?)<\/think>/gi,
-        /<reflection>([\s\S]*?)<\/reflection>/gi,
-        /```\s*(?:think|reflection)[\s\S]*?```/gi
-    ];
-    for (const pattern of patterns) {
-        working = working.replace(pattern, (_match, inner) => {
-            push(inner);
-            return '';
-        });
+import { extractReasoningSegmentsWithNative, sanitizeReasoningTaggedTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+function assertReasoningUtilsNativeAvailable() {
+    if (typeof extractReasoningSegmentsWithNative !== 'function' ||
+        typeof sanitizeReasoningTaggedTextWithNative !== 'function') {
+        throw new Error('[reasoning-utils] native bindings unavailable');
     }
-    working = working
-        .replace(/<\/?think>/gi, '')
-        .replace(/<\/?reflection>/gi, '');
-    working = working.replace(/\n{3,}/g, '\n\n');
-    if (reasoningCollector && !hasExplicitOpen && hasExplicitClose) {
-        const trimmed = working.trim();
-        if (trimmed.length) {
-            reasoningCollector.push(trimmed);
-        }
-        return '';
+}
+export function extractReasoningSegments(source, reasoningCollector) {
+    assertReasoningUtilsNativeAvailable();
+    const output = extractReasoningSegmentsWithNative(source ?? '');
+    if (reasoningCollector) {
+        reasoningCollector.push(...output.segments);
     }
-    return working.trim();
+    return output.text;
 }
 export function sanitizeReasoningTaggedText(value) {
+    assertReasoningUtilsNativeAvailable();
     return sanitizeReasoningTaggedTextWithNative(value);
 }

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

@@ -6,9 +6,9 @@ export interface CallIdTransformer {
     normalizeOutputId(callId: string, raw: unknown): string;
 }
 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;
+export declare function enforceToolCallIdStyle(input: BridgeInputItem[], transformer: CallIdTransformer): void;
 export {};

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

@@ -1,75 +1,52 @@
-import { normalizeFunctionCallId, normalizeFunctionCallOutputId, normalizeResponsesCallId } from '../bridge-id-utils.js';
+import { createToolCallIdTransformerWithNative, normalizeFunctionCallIdWithNative, normalizeFunctionCallOutputIdWithNative, normalizeResponsesCallIdWithNative } 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 assertResponsesToolUtilsNativeAvailable() {
+    if (typeof createToolCallIdTransformerWithNative !== 'function' ||
+        typeof normalizeFunctionCallIdWithNative !== 'function' ||
+        typeof normalizeFunctionCallOutputIdWithNative !== 'function' ||
+        typeof normalizeResponsesCallIdWithNative !== 'function' ||
+        typeof sanitizeResponsesFunctionNameWithNative !== 'function') {
+        throw new Error('[responses-tool-utils] native bindings unavailable');
+    }
+}
 export function createToolCallIdTransformer(style) {
+    assertResponsesToolUtilsNativeAvailable();
     if (style !== 'fc') {
         return null;
     }
-    let callCounter = 0;
-    let itemCounter = 0;
-    let outputCounter = 0;
-    const callAlias = new Map();
-    const normalizeCallId = (raw) => {
-        const rawStr = typeof raw === 'string' && raw.trim().length ? raw.trim() : undefined;
-        if (rawStr && callAlias.has(rawStr)) {
-            return callAlias.get(rawStr);
-        }
-        const normalized = normalizeResponsesCallId({
-            callId: rawStr,
-            fallback: `call_${++callCounter}`
-        });
-        if (rawStr) {
-            callAlias.set(rawStr, normalized);
-        }
-        return normalized;
-    };
-    const normalizeItemId = (raw, callId) => {
-        const rawStr = typeof raw === 'string' && raw.trim().length ? raw.trim() : undefined;
-        return normalizeFunctionCallId({
-            callId: rawStr ?? callId,
-            fallback: `fc_item_${++itemCounter}`
-        });
-    };
-    const normalizeOutputId = (callId, raw) => {
-        const rawStr = typeof raw === 'string' && raw.trim().length ? raw.trim() : undefined;
-        return normalizeFunctionCallOutputId({
-            callId,
-            fallback: rawStr ?? `fc_tool_${++outputCounter}`
-        });
-    };
+    const state = createToolCallIdTransformerWithNative(style);
     return {
-        normalizeCallId,
-        normalizeItemId,
-        normalizeOutputId
+        normalizeCallId(raw) {
+            return normalizeResponsesCallIdWithNative({
+                callId: typeof raw === 'string' && raw.trim().length ? raw.trim() : undefined,
+                fallback: transformCounter(state, 'call')
+            });
+        },
+        normalizeItemId(raw, callId) {
+            return normalizeFunctionCallIdWithNative({
+                callId: typeof raw === 'string' && raw.trim().length ? raw.trim() : callId,
+                fallback: transformCounter(state, 'item')
+            });
+        },
+        normalizeOutputId(callId, raw) {
+            return normalizeFunctionCallOutputIdWithNative({
+                callId,
+                fallback: typeof raw === 'string' && raw.trim().length ? raw.trim() : transformCounter(state, 'tool')
+            });
+        }
     };
 }
-export function enforceToolCallIdStyle(input, transformer) {
-    for (const entry of input) {
-        if (!entry || typeof entry !== 'object')
-            continue;
-        const type = typeof entry.type === 'string' ? entry.type.toLowerCase() : '';
-        if (type === 'function_call') {
-            const normalizedCallId = transformer.normalizeCallId(entry.call_id ?? entry.id);
-            entry.call_id = normalizedCallId;
-            entry.id = transformer.normalizeItemId(entry.id ?? normalizedCallId, normalizedCallId);
-            continue;
-        }
-        if (type === 'function_call_output' || type === 'tool_result' || type === 'tool_message') {
-            const normalizedCallId = transformer.normalizeCallId(entry.call_id ?? entry.tool_call_id ?? entry.id);
-            entry.call_id = normalizedCallId;
-            // OpenAI `/v1/responses` request schema uses `call_id` for tool outputs.
-            // Some internal carriers may include `tool_call_id`; strip it before sending upstream
-            // to avoid strict schema errors (e.g. "Unknown parameter: input[N].tool_call_id").
-            if (entry.tool_call_id !== undefined) {
-                delete entry.tool_call_id;
-            }
-            entry.id = transformer.normalizeOutputId(normalizedCallId, entry.id);
-        }
-    }
+function transformCounter(state, prefix) {
+    const current = typeof state.__counter === 'number' ? state.__counter : 0;
+    const next = current + 1;
+    state.__counter = next;
+    return `${prefix}_${next}`;
 }
 function isStableToolCallId(raw) {
     return /^((fc|call)_[A-Za-z0-9_-]+)$/i.test(raw);
 }
 export function normalizeResponsesToolCallIds(payload) {
+    assertResponsesToolUtilsNativeAvailable();
     if (!payload || typeof payload !== 'object') {
         return;
     }
@@ -85,7 +62,7 @@ export function normalizeResponsesToolCallIds(payload) {
         }
         const normalized = trimmed && isStableToolCallId(trimmed)
             ? trimmed
-            : normalizeFunctionCallId({
+            : normalizeFunctionCallIdWithNative({
                 callId: trimmed || undefined,
                 fallback: nextFallback(fallbackPrefix)
             });
@@ -106,7 +83,7 @@ export function normalizeResponsesToolCallIds(payload) {
                 item.tool_call_id = normalizedCallId;
             }
             const rawOutputId = typeof item.id === 'string' ? item.id : undefined;
-            item.id = normalizeFunctionCallOutputId({
+            item.id = normalizeFunctionCallOutputIdWithNative({
                 callId: normalizedCallId,
                 fallback: rawOutputId ?? nextFallback('fc')
             });
@@ -119,7 +96,7 @@ export function normalizeResponsesToolCallIds(payload) {
                 item.tool_call_id = normalizedCallId;
             }
             const rawOutputId = typeof item.id === 'string' ? item.id : undefined;
-            item.id = normalizeFunctionCallOutputId({
+            item.id = normalizeFunctionCallOutputIdWithNative({
                 callId: normalizedCallId,
                 fallback: rawOutputId ?? nextFallback('fc')
             });
@@ -155,8 +132,6 @@ export function normalizeResponsesToolCallIds(payload) {
     }
 }
 export function resolveToolCallIdStyle(metadata) {
-    // Standard OpenAI `/v1/responses` requires function_call item ids to start with `fc_`.
-    // Default to `fc` unless explicitly overridden (e.g. LM Studio compat).
     if (!metadata)
         return 'fc';
     const raw = metadata.toolCallIdStyle;
@@ -171,6 +146,7 @@ export function resolveToolCallIdStyle(metadata) {
     }
     return 'fc';
 }
+const RAW_SYSTEM_SENTINEL = '__rcc_raw_system';
 export function stripInternalToolingMetadata(metadata) {
     if (!metadata || typeof metadata !== 'object')
         return;
@@ -203,7 +179,29 @@ function prunePrivateExtraFields(target) {
         }
     }
 }
-const RAW_SYSTEM_SENTINEL = '__rcc_raw_system';
 export function sanitizeResponsesFunctionName(rawName) {
+    assertResponsesToolUtilsNativeAvailable();
     return sanitizeResponsesFunctionNameWithNative(rawName);
 }
+export function enforceToolCallIdStyle(input, transformer) {
+    assertResponsesToolUtilsNativeAvailable();
+    for (const entry of input) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const type = typeof entry.type === 'string' ? entry.type.toLowerCase() : '';
+        if (type === 'function_call') {
+            const normalizedCallId = transformer.normalizeCallId(entry.call_id ?? entry.id);
+            entry.call_id = normalizedCallId;
+            entry.id = transformer.normalizeItemId(entry.id ?? normalizedCallId, normalizedCallId);
+            continue;
+        }
+        if (type === 'function_call_output' || type === 'tool_result' || type === 'tool_message') {
+            const normalizedCallId = transformer.normalizeCallId(entry.call_id ?? entry.tool_call_id ?? entry.id);
+            entry.call_id = normalizedCallId;
+            if (entry.tool_call_id !== undefined) {
+                delete entry.tool_call_id;
+            }
+            entry.id = transformer.normalizeOutputId(normalizedCallId, entry.id);
+        }
+    }
+}

package/dist/conversion/shared/streaming-text-extractor.d.ts

@@ -16,10 +16,5 @@ export declare class StreamingTextToolExtractor {
     constructor(opts?: StreamingToolExtractorOptions);
     reset(): void;
     feedText(text: string): StreamingToolCall[];
-    private genId;
-    private toToolCall;
-    private tryExtractStructuredBlocks;
-    private tryExtractFunctionExecuteBlocks;
-    private splitCommand;
 }
 export declare function createStreamingToolExtractor(opts?: StreamingToolExtractorOptions): StreamingTextToolExtractor;

package/dist/conversion/shared/streaming-text-extractor.js

@@ -1,10 +1,11 @@
 // Streaming textual tool intent extractor (对齐)
 // Detects <function=execute> blocks and structured apply_patch payloads
 // and converts them into OpenAI tool_calls incrementally.
-import { isStructuredApplyPatchPayload } from '../../tools/apply-patch-structured.js';
-import { repairArgumentsToStringWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
-function isObject(v) {
-    return !!v && typeof v === 'object' && !Array.isArray(v);
+import { extractStreamingToolCallsWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+function assertStreamingToolExtractorNativeAvailable() {
+    if (typeof extractStreamingToolCallsWithNative !== 'function') {
+        throw new Error('[streaming-text-extractor] native bindings unavailable');
+    }
 }
 export class StreamingTextToolExtractor {
     opts;
@@ -18,114 +19,20 @@ export class StreamingTextToolExtractor {
         this.idCounter = 0;
     }
     feedText(text) {
-        const out = [];
         if (typeof text !== 'string' || !text)
-            return out;
-        this.buffer += text;
-        // 1) Structured apply_patch block detection (```json ... ```)
-        out.push(...this.tryExtractStructuredBlocks());
-        // 2) <function=execute> compact blocks detection
-        out.push(...this.tryExtractFunctionExecuteBlocks());
-        return out;
-    }
-    genId() {
-        const p = this.opts.idPrefix || 'call';
-        return `${p}_${Date.now()}_${(++this.idCounter).toString(36)}`;
-    }
-    toToolCall(name, argsObj) {
-        const argStr = repairArgumentsToStringWithNative(argsObj);
-        return { id: this.genId(), type: 'function', function: { name, arguments: argStr } };
-    }
-    tryExtractStructuredBlocks() {
-        const out = [];
-        let searchIdx = 0;
-        while (searchIdx < this.buffer.length) {
-            const startIdx = this.buffer.indexOf('```', searchIdx);
-            if (startIdx < 0)
-                break;
-            const headerEnd = this.buffer.indexOf('\n', startIdx + 3);
-            if (headerEnd < 0)
-                break;
-            const language = this.buffer.slice(startIdx + 3, headerEnd).trim().toLowerCase();
-            const endIdx = this.buffer.indexOf('```', headerEnd + 1);
-            if (endIdx < 0)
-                break;
-            const body = this.buffer.slice(headerEnd + 1, endIdx);
-            if (!language || language === 'json' || language === 'apply_patch' || language === 'toon') {
-                try {
-                    const parsed = JSON.parse(body);
-                    if (isStructuredApplyPatchPayload(parsed)) {
-                        out.push(this.toToolCall('apply_patch', parsed));
-                        this.buffer = this.buffer.slice(0, startIdx) + this.buffer.slice(endIdx + 3);
-                        searchIdx = 0;
-                        continue;
-                    }
-                }
-                catch {
-                    /* ignore parse errors */
-                }
-            }
-            searchIdx = endIdx + 3;
-        }
-        return out;
-    }
-    // rcc.tool.v1 JSON detection removed
-    tryExtractFunctionExecuteBlocks() {
-        const out = [];
-        // Very lightweight parser for <function=execute> <parameter=command>...</parameter>
-        const execRe = /<function=execute>[\s\S]*?<parameter=command>([\s\S]*?)<\/parameter>[\s\S]*?<\/function=execute>/gi;
-        let m;
-        while ((m = execRe.exec(this.buffer)) !== null) {
-            const cmd = (m[1] || '').trim();
-            if (cmd) {
-                // split a shell command string into argv best-effort
-                const argv = this.splitCommand(cmd);
-                out.push(this.toToolCall('shell', { command: argv }));
-            }
-        }
-        if (out.length > 0) {
-            this.buffer = this.buffer.replace(execRe, '');
-        }
-        return out;
-    }
-    splitCommand(s) {
-        try {
-            // basic quotes-aware split
-            const out = [];
-            let cur = '';
-            let quote = null;
-            for (let i = 0; i < s.length; i++) {
-                const ch = s[i];
-                if (quote) {
-                    if (ch === quote) {
-                        quote = null;
-                    }
-                    else {
-                        cur += ch;
-                    }
-                }
-                else {
-                    if (ch === '"' || ch === '\'') {
-                        quote = ch;
-                    }
-                    else if (/\s/.test(ch)) {
-                        if (cur) {
-                            out.push(cur);
-                            cur = '';
-                        }
-                    }
-                    else {
-                        cur += ch;
-                    }
-                }
-            }
-            if (cur)
-                out.push(cur);
-            return out;
-        }
-        catch {
-            return [s];
-        }
+            return [];
+        assertStreamingToolExtractorNativeAvailable();
+        const idPrefix = this.opts.idPrefix || 'call';
+        const output = extractStreamingToolCallsWithNative({
+            buffer: this.buffer,
+            text,
+            idPrefix,
+            idCounter: this.idCounter,
+            nowMs: Date.now()
+        });
+        this.buffer = typeof output.buffer === 'string' ? output.buffer : this.buffer;
+        this.idCounter = typeof output.idCounter === 'number' ? output.idCounter : this.idCounter;
+        return Array.isArray(output.toolCalls) ? output.toolCalls : [];
     }
 }
 export function createStreamingToolExtractor(opts) {

package/dist/conversion/shared/text-markup-normalizer/normalize.d.ts

@@ -1,2 +1,2 @@
 import type { TextMarkupNormalizeOptions } from '../../types/text-markup-normalizer.js';
-export declare function normalizeAssistantTextToToolCalls(message: Record<string, any>, _options?: TextMarkupNormalizeOptions): Record<string, any>;
+export declare function normalizeAssistantTextToToolCalls(message: Record<string, any>, options?: TextMarkupNormalizeOptions): Record<string, any>;

package/dist/conversion/shared/text-markup-normalizer/normalize.js

@@ -1,4 +1,4 @@
-import { extractToolCallsFromReasoningTextWithNative } from '../../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { normalizeAssistantTextToToolCallsWithNative } from '../../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 function enabled() {
     try {
         return String(process?.env?.RCC_TEXT_MARKUP_COMPAT ?? '1').trim() !== '0';
@@ -7,96 +7,8 @@ function enabled() {
         return true;
     }
 }
-export function normalizeAssistantTextToToolCalls(message, _options) {
+export function normalizeAssistantTextToToolCalls(message, options) {
     if (!enabled())
         return message;
-    try {
-        if (!message || typeof message !== 'object')
-            return message;
-        if (Array.isArray(message.tool_calls) && message.tool_calls.length)
-            return message;
-        const content = message.content;
-        const candidates = [];
-        if (typeof content === 'string') {
-            candidates.push(content);
-        }
-        else if (Array.isArray(content)) {
-            for (const part of content) {
-                if (!part || typeof part !== 'object')
-                    continue;
-                const p = part;
-                if (typeof p.text === 'string' && p.text.trim()) {
-                    candidates.push(p.text);
-                    continue;
-                }
-                if (typeof p.content === 'string' && p.content.trim()) {
-                    candidates.push(p.content);
-                    continue;
-                }
-            }
-        }
-        if (typeof message.reasoning === 'string' && message.reasoning.trim()) {
-            candidates.push(String(message.reasoning));
-        }
-        if (typeof message.thinking === 'string' && message.thinking.trim()) {
-            candidates.push(String(message.thinking));
-        }
-        if (!candidates.length)
-            return message;
-        let calls = null;
-        const mapNativeToolCalls = (raw) => {
-            const mapped = [];
-            raw.forEach((entry, index) => {
-                if (!entry || typeof entry !== 'object')
-                    return;
-                const functionNode = entry.function && typeof entry.function === 'object' && !Array.isArray(entry.function)
-                    ? entry.function
-                    : undefined;
-                const name = (typeof functionNode?.name === 'string' && functionNode.name.trim()) ||
-                    (typeof entry.name === 'string' && entry.name.trim()) ||
-                    undefined;
-                if (!name)
-                    return;
-                const argsCandidate = functionNode?.arguments ?? entry.arguments ?? entry.args ?? '{}';
-                let args = '{}';
-                if (typeof argsCandidate === 'string') {
-                    args = argsCandidate;
-                }
-                else {
-                    try {
-                        args = JSON.stringify(argsCandidate ?? {});
-                    }
-                    catch {
-                        args = '{}';
-                    }
-                }
-                const id = (typeof entry.id === 'string' && entry.id.trim()) ||
-                    (typeof entry.call_id === 'string' && entry.call_id.trim()) ||
-                    `call_${index + 1}`;
-                mapped.push({ id, name, args });
-            });
-            return mapped;
-        };
-        for (const text of candidates) {
-            const nativeParsed = extractToolCallsFromReasoningTextWithNative(text);
-            if (nativeParsed.toolCalls.length) {
-                const nativeCalls = mapNativeToolCalls(nativeParsed.toolCalls);
-                if (nativeCalls.length) {
-                    calls = nativeCalls;
-                    break;
-                }
-            }
-        }
-        if (calls && calls.length) {
-            const toolCalls = calls.map((c) => ({ id: c.id, type: 'function', function: { name: c.name, arguments: c.args } }));
-            const copy = { ...message };
-            copy.tool_calls = toolCalls;
-            copy.content = '';
-            return copy;
-        }
-    }
-    catch {
-        // ignore normalization failures
-    }
-    return message;
+    return normalizeAssistantTextToToolCallsWithNative(message, options);
 }