@jsonstudio/llms 0.6.3275 → 0.6.3379

package/dist/conversion/shared/thought-signature-validator.js

@@ -4,13 +4,15 @@
  * 提供严格的 thoughtSignature 验证功能，用于 Claude/Gemini thinking 块的签名验证。
  * 参考 gcli2api 的实现，确保与上游 API 的兼容性。
  */
-import { sanitizeReasoningTaggedTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
-const DEFAULT_OPTIONS = {
-    // Antigravity-Manager alignment: treat short signatures as noise.
-    minLength: 50,
-    allowEmptyThinkingWithSignature: true,
-    convertToTextOnFailure: true
-};
+import { filterInvalidThinkingBlocksWithNative, hasValidThoughtSignatureWithNative, removeTrailingUnsignedThinkingBlocksWithNative, sanitizeThinkingBlockWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+function assertThoughtSignatureValidatorNativeAvailable() {
+    if (typeof hasValidThoughtSignatureWithNative !== 'function' ||
+        typeof sanitizeThinkingBlockWithNative !== 'function' ||
+        typeof filterInvalidThinkingBlocksWithNative !== 'function' ||
+        typeof removeTrailingUnsignedThinkingBlocksWithNative !== 'function') {
+        throw new Error('[thought-signature-validator] native bindings unavailable');
+    }
+}
 /**
  * 检查 thinking 块是否有有效的 thoughtSignature
  *
@@ -19,26 +21,8 @@ const DEFAULT_OPTIONS = {
  * @returns 是否有效
  */
 export function hasValidThoughtSignature(block, options) {
-    if (!block || typeof block !== 'object') {
-        return true; // 非 thinking 块默认有效
-    }
-    const obj = block;
-    const blockType = obj.type;
-    if (blockType !== 'thinking' && blockType !== 'reasoning' && blockType !== 'redacted_thinking') {
-        return true; // 非 thinking 块默认有效
-    }
-    const opts = { ...DEFAULT_OPTIONS, ...options };
-    const thinking = sanitizeReasoningTaggedTextWithNative(String(obj.thinking || obj.text || ''));
-    const signature = coerceThoughtSignature(obj.thoughtSignature || obj.signature);
-    // 空 thinking + 任意签名 = 有效 (trailing signature case)
-    if (!thinking.trim() && signature !== undefined && opts.allowEmptyThinkingWithSignature) {
-        return true;
-    }
-    // 有内容 + 足够长度的 signature = 有效
-    if (signature && signature.length >= opts.minLength) {
-        return true;
-    }
-    return false;
+    assertThoughtSignatureValidatorNativeAvailable();
+    return hasValidThoughtSignatureWithNative(block, options);
 }
 /**
  * 清理 thinking 块，移除额外字段，保留有效签名
@@ -47,23 +31,8 @@ export function hasValidThoughtSignature(block, options) {
  * @returns 清理后的块
  */
 export function sanitizeThinkingBlock(block) {
-    if (!block || typeof block !== 'object') {
-        return block;
-    }
-    const obj = block;
-    const blockType = obj.type;
-    if (blockType !== 'thinking' && blockType !== 'reasoning' && blockType !== 'redacted_thinking') {
-        return obj;
-    }
-    const sanitized = {
-        type: blockType,
-        thinking: sanitizeReasoningTaggedTextWithNative(String(obj.thinking || obj.text || ''))
-    };
-    const signature = coerceThoughtSignature(obj.thoughtSignature || obj.signature);
-    if (signature) {
-        sanitized.thoughtSignature = signature;
-    }
-    return sanitized;
+    assertThoughtSignatureValidatorNativeAvailable();
+    return sanitizeThinkingBlockWithNative(block);
 }
 /**
  * 过滤消息中的无效 thinking 块
@@ -72,58 +41,9 @@ export function sanitizeThinkingBlock(block) {
  * @param options - 验证选项
  */
 export function filterInvalidThinkingBlocks(messages, options) {
-    const opts = { ...DEFAULT_OPTIONS, ...options };
-    let totalFiltered = 0;
-    for (const msg of messages) {
-        if (!msg || typeof msg !== 'object')
-            continue;
-        const msgObj = msg;
-        const role = msgObj.role;
-        // 只处理 assistant 和 model 消息
-        if (role !== 'assistant' && role !== 'model')
-            continue;
-        const content = msgObj.content;
-        if (!Array.isArray(content))
-            continue;
-        const originalLen = content.length;
-        const newBlocks = [];
-        for (const block of content) {
-            if (!block || typeof block !== 'object') {
-                newBlocks.push(block);
-                continue;
-            }
-            const blockType = block.type;
-            if (blockType !== 'thinking' && blockType !== 'reasoning' && blockType !== 'redacted_thinking') {
-                newBlocks.push(block);
-                continue;
-            }
-            // 检查 thinking 块的有效性
-            if (hasValidThoughtSignature(block, opts)) {
-                // 有效签名，清理后保留
-                newBlocks.push(sanitizeThinkingBlock(block));
-            }
-            else {
-                // 无效签名
-                const thinkingText = String(block.thinking || block.text || '');
-                if (thinkingText.trim() && opts.convertToTextOnFailure) {
-                    // 有内容，转换为文本
-                    newBlocks.push({ type: 'text', text: thinkingText });
-                }
-                // 否则丢弃（空 thinking + 无效签名）
-            }
-        }
-        msgObj.content = newBlocks;
-        const filteredCount = originalLen - newBlocks.length;
-        totalFiltered += filteredCount;
-        // 如果过滤后为空，添加一个空文本块以保持消息有效
-        if (!newBlocks.length) {
-            msgObj.content = [{ type: 'text', text: '' }];
-        }
-    }
-    if (totalFiltered > 0) {
-        // 可以在这里添加日志记录
-        console.debug(`[ThoughtSignatureValidator] Filtered ${totalFiltered} invalid thinking block(s)`);
-    }
+    assertThoughtSignatureValidatorNativeAvailable();
+    const normalized = filterInvalidThinkingBlocksWithNative(messages, options);
+    messages.splice(0, messages.length, ...normalized);
 }
 /**
  * 移除末尾未签名的 thinking 块
@@ -132,41 +52,7 @@ export function filterInvalidThinkingBlocks(messages, options) {
  * @param options - 验证选项
  */
 export function removeTrailingUnsignedThinkingBlocks(blocks, options) {
-    if (!Array.isArray(blocks) || !blocks.length)
-        return;
-    const opts = { ...DEFAULT_OPTIONS, ...options };
-    let end_index = blocks.length;
-    // 从末尾向前查找第一个有效签名的 thinking 块
-    for (let i = blocks.length - 1; i >= 0; i--) {
-        const block = blocks[i];
-        if (!block || typeof block !== 'object')
-            continue;
-        const blockType = block.type;
-        if (blockType === 'thinking' || blockType === 'reasoning' || blockType === 'redacted_thinking') {
-            if (!hasValidThoughtSignature(block, opts)) {
-                end_index = i;
-            }
-            else {
-                break; // 遇到有效签名的 thinking 块，停止
-            }
-        }
-        else {
-            break; // 遇到非 thinking 块，停止
-        }
-    }
-    // 移除末尾未签名的 thinking 块
-    if (end_index < blocks.length) {
-        const removed = blocks.length - end_index;
-        blocks.splice(end_index);
-        console.debug(`[ThoughtSignatureValidator] Removed ${removed} trailing unsigned thinking block(s)`);
-    }
-}
-/**
- * 提取并强制转换 thoughtSignature
- */
-function coerceThoughtSignature(value) {
-    if (typeof value === 'string' && value.trim().length) {
-        return value.trim();
-    }
-    return undefined;
+    assertThoughtSignatureValidatorNativeAvailable();
+    const normalized = removeTrailingUnsignedThinkingBlocksWithNative(blocks, options);
+    blocks.splice(0, blocks.length, ...normalized);
 }

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