@jsonstudio/llms 0.6.3275 → 0.6.3405

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

@@ -1,48 +1,86 @@
-import { normalizeFunctionCallId, normalizeFunctionCallOutputId, normalizeResponsesCallId } from '../bridge-id-utils.js';
+import { createToolCallIdTransformerWithNative, normalizeResponsesToolCallIdsWithNative, normalizeFunctionCallIdWithNative, normalizeFunctionCallOutputIdWithNative, normalizeResponsesCallIdWithNative, resolveToolCallIdStyleWithNative, stripInternalToolingMetadataWithNative } 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 normalizeResponsesToolCallIdsWithNative !== 'function' ||
+        typeof normalizeFunctionCallIdWithNative !== 'function' ||
+        typeof normalizeFunctionCallOutputIdWithNative !== 'function' ||
+        typeof normalizeResponsesCallIdWithNative !== 'function' ||
+        typeof resolveToolCallIdStyleWithNative !== 'function' ||
+        typeof stripInternalToolingMetadataWithNative !== 'function' ||
+        typeof sanitizeResponsesFunctionNameWithNative !== 'function') {
+        throw new Error('[responses-tool-utils] native bindings unavailable');
+    }
+}
+function replaceMutableRecord(target, next) {
+    for (const key of Object.keys(target)) {
+        delete target[key];
+    }
+    Object.assign(target, next);
+}
 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')
+            });
+        }
     };
 }
+function transformCounter(state, prefix) {
+    const current = typeof state.__counter === 'number' ? state.__counter : 0;
+    const next = current + 1;
+    state.__counter = next;
+    return `${prefix}_${next}`;
+}
+export function normalizeResponsesToolCallIds(payload) {
+    assertResponsesToolUtilsNativeAvailable();
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return;
+    }
+    const normalized = normalizeResponsesToolCallIdsWithNative(payload);
+    if (normalized && typeof normalized === 'object' && !Array.isArray(normalized)) {
+        replaceMutableRecord(payload, normalized);
+    }
+}
+export function resolveToolCallIdStyle(metadata) {
+    assertResponsesToolUtilsNativeAvailable();
+    const style = resolveToolCallIdStyleWithNative(metadata ?? null);
+    return style === 'preserve' ? 'preserve' : 'fc';
+}
+export function stripInternalToolingMetadata(metadata) {
+    assertResponsesToolUtilsNativeAvailable();
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata))
+        return;
+    const normalized = stripInternalToolingMetadataWithNative(metadata);
+    if (normalized && typeof normalized === 'object' && !Array.isArray(normalized)) {
+        replaceMutableRecord(metadata, normalized);
+    }
+}
+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;
@@ -56,9 +94,6 @@ export function enforceToolCallIdStyle(input, transformer) {
         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;
             }
@@ -66,144 +101,3 @@ export function enforceToolCallIdStyle(input, transformer) {
         }
     }
 }
-function isStableToolCallId(raw) {
-    return /^((fc|call)_[A-Za-z0-9_-]+)$/i.test(raw);
-}
-export function normalizeResponsesToolCallIds(payload) {
-    if (!payload || typeof payload !== 'object') {
-        return;
-    }
-    let counter = 0;
-    const aliasMap = new Map();
-    const nextFallback = (prefix) => `${prefix}_${++counter}`;
-    const normalizeCallId = (raw, fallbackPrefix) => {
-        const trimmed = typeof raw === 'string' ? raw.trim() : '';
-        if (trimmed) {
-            const cached = aliasMap.get(trimmed);
-            if (cached)
-                return cached;
-        }
-        const normalized = trimmed && isStableToolCallId(trimmed)
-            ? trimmed
-            : normalizeFunctionCallId({
-                callId: trimmed || undefined,
-                fallback: nextFallback(fallbackPrefix)
-            });
-        if (trimmed) {
-            aliasMap.set(trimmed, normalized);
-        }
-        return normalized;
-    };
-    const output = Array.isArray(payload.output) ? payload.output : [];
-    for (const item of output) {
-        if (!item || typeof item !== 'object')
-            continue;
-        const type = typeof item.type === 'string' ? String(item.type).toLowerCase() : '';
-        if (type === 'function_call') {
-            const normalizedCallId = normalizeCallId(item.call_id ?? item.tool_call_id ?? item.id, 'fc_call');
-            item.call_id = normalizedCallId;
-            if (item.tool_call_id !== undefined) {
-                item.tool_call_id = normalizedCallId;
-            }
-            const rawOutputId = typeof item.id === 'string' ? item.id : undefined;
-            item.id = normalizeFunctionCallOutputId({
-                callId: normalizedCallId,
-                fallback: rawOutputId ?? nextFallback('fc')
-            });
-            continue;
-        }
-        if (type === 'function_call_output' || type === 'tool_result' || type === 'tool_message') {
-            const normalizedCallId = normalizeCallId(item.call_id ?? item.tool_call_id ?? item.id, 'fc_call');
-            item.call_id = normalizedCallId;
-            if (item.tool_call_id !== undefined) {
-                item.tool_call_id = normalizedCallId;
-            }
-            const rawOutputId = typeof item.id === 'string' ? item.id : undefined;
-            item.id = normalizeFunctionCallOutputId({
-                callId: normalizedCallId,
-                fallback: rawOutputId ?? nextFallback('fc')
-            });
-            continue;
-        }
-        if (Array.isArray(item.tool_calls)) {
-            for (const call of item.tool_calls) {
-                if (!call || typeof call !== 'object')
-                    continue;
-                const normalizedCallId = normalizeCallId(call.id ?? call.tool_call_id ?? call.call_id, 'fc_call');
-                call.id = normalizedCallId;
-                if (call.tool_call_id !== undefined) {
-                    call.tool_call_id = normalizedCallId;
-                }
-                if (call.call_id !== undefined) {
-                    call.call_id = normalizedCallId;
-                }
-            }
-        }
-    }
-    const submitCalls = payload?.required_action?.submit_tool_outputs?.tool_calls;
-    if (Array.isArray(submitCalls)) {
-        for (const call of submitCalls) {
-            if (!call || typeof call !== 'object')
-                continue;
-            const normalizedCallId = normalizeCallId(call.tool_call_id ?? call.id ?? call.call_id, 'fc_call');
-            call.tool_call_id = normalizedCallId;
-            call.id = normalizedCallId;
-            if (call.call_id !== undefined) {
-                call.call_id = normalizedCallId;
-            }
-        }
-    }
-}
-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;
-    if (typeof raw === 'string') {
-        const lowered = raw.trim().toLowerCase();
-        if (lowered === 'fc') {
-            return 'fc';
-        }
-        if (lowered === 'preserve') {
-            return 'preserve';
-        }
-    }
-    return 'fc';
-}
-export function stripInternalToolingMetadata(metadata) {
-    if (!metadata || typeof metadata !== 'object')
-        return;
-    const record = metadata;
-    if ('toolCallIdStyle' in record) {
-        delete record.toolCallIdStyle;
-    }
-    if (RAW_SYSTEM_SENTINEL in record) {
-        delete record[RAW_SYSTEM_SENTINEL];
-    }
-    if (record.extraFields && typeof record.extraFields === 'object') {
-        prunePrivateExtraFields(record.extraFields);
-        if (!Object.keys(record.extraFields).length) {
-            delete record.extraFields;
-        }
-    }
-}
-function prunePrivateExtraFields(target) {
-    for (const key of Object.keys(target)) {
-        const value = target[key];
-        if (typeof key === 'string' && key.startsWith('__rcc_')) {
-            delete target[key];
-            continue;
-        }
-        if (value && typeof value === 'object') {
-            prunePrivateExtraFields(value);
-            if (!Object.keys(value).length) {
-                delete target[key];
-            }
-        }
-    }
-}
-const RAW_SYSTEM_SENTINEL = '__rcc_raw_system';
-export function sanitizeResponsesFunctionName(rawName) {
-    return sanitizeResponsesFunctionNameWithNative(rawName);
-}

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