@jsonstudio/llms 0.6.3271 → 0.6.3379

package/dist/conversion/shared/tool-argument-repairer.js

@@ -7,27 +7,24 @@
  * This module provides a deterministic, best-effort repair surface that returns a JSON string
  * or `{}` and never throws.
  */
-import { repairArgumentsToStringWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { repairArgumentsToStringWithNative, repairToolCallsWithNative, validateToolArgumentsWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export class ToolArgumentRepairer {
     repairToString(args) {
+        if (typeof repairArgumentsToStringWithNative !== 'function') {
+            throw new Error('[tool-argument-repairer] native bindings unavailable');
+        }
         return repairArgumentsToStringWithNative(args);
     }
     validateAndRepair(toolName, args) {
-        const repaired = this.repairToString(args);
-        try {
-            JSON.parse(repaired);
-            return {
-                repaired,
-                success: true
-            };
-        }
-        catch (error) {
-            return {
-                repaired,
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
+        if (typeof validateToolArgumentsWithNative !== 'function') {
+            throw new Error('[tool-argument-repairer] native bindings unavailable');
         }
+        const output = validateToolArgumentsWithNative(toolName, args);
+        return {
+            repaired: output.repaired,
+            success: output.success,
+            ...(output.error ? { error: output.error } : {})
+        };
     }
     /**
      * 批量修复工具参数
@@ -36,10 +33,10 @@ export class ToolArgumentRepairer {
      * @returns 修复后的工具调用列表
      */
     repairToolCalls(toolCalls) {
-        return toolCalls.map((call) => ({
-            name: call.name,
-            arguments: this.repairToString(call.arguments)
-        }));
+        if (typeof repairToolCallsWithNative !== 'function') {
+            throw new Error('[tool-argument-repairer] native bindings unavailable');
+        }
+        return repairToolCallsWithNative(toolCalls);
     }
 }
 /**

package/dist/conversion/shared/tool-call-id-manager.d.ts

@@ -29,7 +29,7 @@ export interface ToolCallIdManagerOptions {
  */
 export declare class ToolCallIdManager {
     private options;
-    private counter;
+    private state;
     constructor(options?: ToolCallIdManagerOptions);
     /**
      * 生成新的工具调用 ID
@@ -77,10 +77,6 @@ export declare class ToolCallIdManager {
      * 更新配置
      */
     updateOptions(options: Partial<ToolCallIdManagerOptions>): void;
-    /**
-     * 生成 UUID（用于 preserve 风格）
-     */
-    private generateUUID;
 }
 /**
  * 规范化工具调用 ID 值

package/dist/conversion/shared/tool-call-id-manager.js

@@ -4,30 +4,42 @@
  * 提供统一的工具调用 ID 生成、规范化和风格管理功能。
  * 支持 'fc' (function call) 和 'preserve' 两种风格。
  */
-import { normalizeFunctionCallIdWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { createToolCallIdTransformerWithNative, enforceToolCallIdStyleWithNative, extractToolCallIdWithNative, normalizeIdValueWithNative, transformToolCallIdWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 const DEFAULT_OPTIONS = {
     style: 'fc',
     prefix: 'fc_',
     idLength: 8
 };
+function assertToolCallIdManagerNativeAvailable() {
+    if (typeof normalizeIdValueWithNative !== 'function' ||
+        typeof extractToolCallIdWithNative !== 'function' ||
+        typeof createToolCallIdTransformerWithNative !== 'function' ||
+        typeof transformToolCallIdWithNative !== 'function' ||
+        typeof enforceToolCallIdStyleWithNative !== 'function') {
+        throw new Error('[tool-call-id-manager] native bindings unavailable');
+    }
+}
 /**
  * 工具调用 ID 管理器
  */
 export class ToolCallIdManager {
     options;
-    counter = 0;
+    state;
     constructor(options) {
+        assertToolCallIdManagerNativeAvailable();
         this.options = { ...DEFAULT_OPTIONS, ...options };
+        this.state = createToolCallIdTransformerWithNative(this.options.style);
     }
     /**
      * 生成新的工具调用 ID
      */
     generateId() {
+        assertToolCallIdManagerNativeAvailable();
         if (this.options.style === 'fc') {
-            return `${this.options.prefix}${this.counter++}`;
+            const next = transformToolCallIdWithNative(this.state, '').id;
+            return next;
         }
-        // preserve 风格：使用 UUID
-        return this.generateUUID();
+        return normalizeIdValueWithNative(undefined, true);
     }
     /**
      * 规范化工具调用 ID
@@ -36,21 +48,15 @@ export class ToolCallIdManager {
      * @returns 规范化后的 ID
      */
     normalizeId(id) {
-        if (!id) {
-            return this.generateId();
-        }
-        const trimmed = id.trim();
-        if (!trimmed) {
-            return this.generateId();
-        }
+        assertToolCallIdManagerNativeAvailable();
+        const raw = typeof id === 'string' ? id : '';
         if (this.options.style === 'fc') {
-            return normalizeFunctionCallIdWithNative({
-                callId: trimmed,
-                fallback: this.generateId()
-            });
+            const output = transformToolCallIdWithNative(this.state, raw);
+            this.state = output.state;
+            return output.id;
         }
-        // preserve 风格：保留原始 ID
-        return trimmed;
+        const trimmed = raw.trim();
+        return trimmed ? trimmed : normalizeIdValueWithNative(undefined, true);
     }
     /**
      * 规范化工具调用 ID（带别名注册）
@@ -60,22 +66,20 @@ export class ToolCallIdManager {
      * @returns 规范化后的 ID
      */
     normalizeIdWithAlias(id, aliasMap) {
-        if (!id) {
-            return this.generateId();
-        }
-        const trimmed = id.trim();
-        if (!trimmed) {
-            return this.generateId();
+        assertToolCallIdManagerNativeAvailable();
+        const raw = typeof id === 'string' ? id : '';
+        if (this.options.style !== 'preserve') {
+            return this.normalizeId(raw);
         }
-        if (this.options.style === 'fc') {
-            return this.normalizeId(id);
-        }
-        // preserve 风格：检查是否已有别名
-        if (aliasMap && aliasMap.has(trimmed)) {
+        const trimmed = raw.trim();
+        if (trimmed && aliasMap && aliasMap.has(trimmed)) {
             return aliasMap.get(trimmed);
         }
-        // 没有别名，保留原始 ID
-        return trimmed;
+        const value = trimmed || normalizeIdValueWithNative(undefined, true);
+        if (trimmed && aliasMap) {
+            aliasMap.set(trimmed, value);
+        }
+        return value;
     }
     /**
      * 批量规范化工具调用 ID
@@ -84,7 +88,7 @@ export class ToolCallIdManager {
      * @returns 规范化后的 ID 列表
      */
     normalizeIds(ids) {
-        return ids.map(id => this.normalizeId(id));
+        return ids.map((id) => this.normalizeId(id));
     }
     /**
      * 检查 ID 是否为有效的 fc_ 风格
@@ -106,7 +110,7 @@ export class ToolCallIdManager {
      * 重置计数器
      */
     resetCounter() {
-        this.counter = 0;
+        this.state = createToolCallIdTransformerWithNative(this.options.style);
     }
     /**
      * 获取当前配置
@@ -119,17 +123,7 @@ export class ToolCallIdManager {
      */
     updateOptions(options) {
         this.options = { ...this.options, ...options };
-    }
-    /**
-     * 生成 UUID（用于 preserve 风格）
-     */
-    generateUUID() {
-        // 简单的 UUID 生成（生产环境建议使用 crypto.randomUUID()）
-        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-            const r = Math.random() * 16 | 0;
-            const v = c === 'x' ? r : (r & 0x3 | 0x8);
-            return v.toString(16);
-        });
+        this.state = createToolCallIdTransformerWithNative(this.options.style);
     }
 }
 /**
@@ -140,16 +134,8 @@ export class ToolCallIdManager {
  * @returns 规范化后的 ID 字符串
  */
 export function normalizeIdValue(value, forceGenerate = false) {
-    if (forceGenerate) {
-        const manager = new ToolCallIdManager();
-        return manager.generateId();
-    }
-    if (typeof value === 'string' && value.trim()) {
-        return value.trim();
-    }
-    // 生成默认 ID
-    const manager = new ToolCallIdManager();
-    return manager.generateId();
+    assertToolCallIdManagerNativeAvailable();
+    return normalizeIdValueWithNative(value, forceGenerate);
 }
 /**
  * 从对象中提取工具调用 ID
@@ -158,16 +144,8 @@ export function normalizeIdValue(value, forceGenerate = false) {
  * @returns 提取的 ID
  */
 export function extractToolCallId(obj) {
-    if (!obj || typeof obj !== 'object') {
-        return undefined;
-    }
-    const record = obj;
-    // 按优先级查找：tool_call_id > call_id > id > tool_use_id
-    const id = record.tool_call_id ??
-        record.call_id ??
-        record.id ??
-        record.tool_use_id;
-    return typeof id === 'string' ? id : undefined;
+    assertToolCallIdManagerNativeAvailable();
+    return extractToolCallIdWithNative(obj);
 }
 /**
  * 创建工具调用 ID 转换器（用于 Responses 格式）
@@ -176,22 +154,15 @@ export function extractToolCallId(obj) {
  * @returns 转换器函数
  */
 export function createToolCallIdTransformer(style) {
-    const manager = new ToolCallIdManager({ style });
-    const aliasMap = new Map();
-    if (style === 'fc') {
-        return (id) => manager.normalizeId(id);
-    }
-    if (style === 'preserve') {
-        return (id) => {
-            const normalized = manager.normalizeIdWithAlias(id, aliasMap);
-            // 如果 ID 是新的，注册别名
-            if (!aliasMap.has(id)) {
-                aliasMap.set(id, normalized);
-            }
-            return normalized;
-        };
-    }
-    return null;
+    assertToolCallIdManagerNativeAvailable();
+    if (style !== 'fc' && style !== 'preserve')
+        return null;
+    const state = createToolCallIdTransformerWithNative(style);
+    return (id) => {
+        const output = transformToolCallIdWithNative(state, id);
+        Object.assign(state, output.state);
+        return output.id;
+    };
 }
 /**
  * 在消息列表中强制应用工具调用 ID 风格
@@ -200,30 +171,35 @@ export function createToolCallIdTransformer(style) {
  * @param transformer - ID 转换器
  */
 export function enforceToolCallIdStyle(messages, transformer) {
+    assertToolCallIdManagerNativeAvailable();
     if (!messages || !Array.isArray(messages)) {
         return;
     }
-    for (const message of messages) {
-        if (!message || typeof message !== 'object')
-            continue;
-        const role = message.role;
-        // 处理 assistant 消息的 tool_calls
-        if (role === 'assistant' && Array.isArray(message.tool_calls)) {
-            for (const call of message.tool_calls) {
-                if (!call || typeof call !== 'object')
-                    continue;
-                const id = extractToolCallId(call);
-                if (id) {
-                    call.id = transformer(id);
+    const state = createToolCallIdTransformerWithNative('fc');
+    const updated = enforceToolCallIdStyleWithNative(messages, state);
+    const nextMessages = updated.messages;
+    if (transformer && typeof transformer === 'function') {
+        for (const message of nextMessages) {
+            if (!message || typeof message !== 'object')
+                continue;
+            const role = message.role;
+            if (role === 'assistant' && Array.isArray(message.tool_calls)) {
+                for (const call of message.tool_calls) {
+                    if (!call || typeof call !== 'object')
+                        continue;
+                    const id = extractToolCallId(call);
+                    if (id) {
+                        call.id = transformer(id);
+                    }
                 }
             }
-        }
-        // 处理 tool 消息的 tool_call_id
-        if (role === 'tool') {
-            const id = extractToolCallId(message);
-            if (id) {
-                message.tool_call_id = transformer(id);
+            if (role === 'tool') {
+                const id = extractToolCallId(message);
+                if (id) {
+                    message.tool_call_id = transformer(id);
+                }
             }
         }
     }
+    messages.splice(0, messages.length, ...nextMessages);
 }