@jsonstudio/llms 0.4.2 → 0.4.4

package/dist/utils/token-counter.js

@@ -1,541 +0,0 @@
-/**
- * Token计数工具
- *
- * 基于OpenAI的标准token计算方法
- * 参考: https://github.com/openai/tiktoken
- */
-/**
- * 简化的Token计数器
- *
- * 注意：这是一个简化实现，准确的token计算需要使用tiktoken库
- * 这里提供基本的估算功能，在生产环境中应该集成实际的tiktoken
- */
-const ENABLE_TIKTOKEN = true; // 临时禁用 tiktoken，统一走估算路径
-export class TokenCounter {
-    /**
-     * 估算文本的token数量
-     *
-     * 基于OpenAI的经验法则：
-     * - 英文：1 token ≈ 4 characters
-     * - 中文：1 token ≈ 1.5-2 characters
-     * - 代码：1 token ≈ 3-4 characters
-     *
-     * @param text 要计算的文本
-     * @param language 语言类型 (optional)
-     * @returns 估算的token数量
-     */
-    static estimateTokens(text, language = 'auto') {
-        if (!text || typeof text !== 'string') {
-            return 0;
-        }
-        // 自动检测语言类型
-        if (language === 'auto') {
-            language = this.detectLanguage(text);
-        }
-        // 根据语言类型使用不同的计算比率
-        switch (language) {
-            case 'en':
-                return Math.ceil(text.length / 4); // 英文：约4个字符 = 1个token
-            case 'zh':
-                return Math.ceil(text.length / 1.5); // 中文：约1.5个字符 = 1个token
-            case 'code':
-                return Math.ceil(text.length / 3.5); // 代码：约3.5个字符 = 1个token
-            default:
-                return Math.ceil(text.length / 4); // 默认使用英文比率
-        }
-    }
-    /**
-     * 检测文本的主要语言类型
-     */
-    static detectLanguage(text) {
-        // 计算中文字符比例
-        const chineseChars = (text.match(/[\u4e00-\u9fff]/g) || []).length;
-        const chineseRatio = chineseChars / text.length;
-        // 计算代码特征比例（括号、分号、等号等）
-        const codeChars = (text.match(/[{}();=<>[\]]/g) || []).length;
-        const codeRatio = codeChars / text.length;
-        // 根据比例判断语言类型
-        if (chineseRatio > 0.3) {
-            return 'zh';
-        }
-        else if (codeRatio > 0.1) {
-            return 'code';
-        }
-        else {
-            return 'en';
-        }
-    }
-    /**
-     * 计算消息的token数量
-     */
-    static estimateMessageTokens(message, language = 'auto') {
-        if (!message) {
-            return 0;
-        }
-        let totalTokens = 0;
-        // 计算role的token数量（通常是1-2个token）
-        if (message.role) {
-            totalTokens += this.estimateTokens(message.role, language);
-        }
-        // 计算content的token数量
-        if (message.content) {
-            if (typeof message.content === 'string') {
-                totalTokens += this.estimateTokens(message.content, language);
-            }
-            else if (Array.isArray(message.content)) {
-                // 处理多模态内容（如图片 + 文本）
-                for (const contentItem of message.content) {
-                    if (contentItem.type === 'text' && contentItem.text) {
-                        totalTokens += this.estimateTokens(contentItem.text, language);
-                    }
-                    else if (contentItem.type === 'image') {
-                        // 图片通常需要额外的token，这里使用一个估算值
-                        // 具体数值取决于图片大小和模型，这里使用一个保守估计
-                        totalTokens += 85; // OpenAI的典型图片token成本
-                    }
-                }
-            }
-        }
-        // 计算tool_calls的token数量
-        if (message.tool_calls && Array.isArray(message.tool_calls)) {
-            for (const toolCall of message.tool_calls) {
-                // tool name: 约1-3个token
-                totalTokens += this.estimateTokens(toolCall.function?.name || '', language);
-                // arguments: 根据参数长度计算
-                totalTokens += this.estimateTokens(toolCall.function?.arguments || '{}', language);
-                // tool调用本身的一些固定开销
-                totalTokens += 5;
-            }
-        }
-        // 每个消息格式的一些固定开销
-        totalTokens += 3;
-        return totalTokens;
-    }
-    /**
-     * 计算工具定义的token数量
-     */
-    static estimateToolTokens(tool) {
-        if (!tool || !tool.function) {
-            return 0;
-        }
-        let tokens = 0;
-        // function name
-        tokens += this.estimateTokens(tool.function.name || '', 'en');
-        // function description
-        tokens += this.estimateTokens(tool.function.description || '', 'en');
-        // function parameters (JSON schema)
-        if (tool.function.parameters) {
-            const paramStr = JSON.stringify(tool.function.parameters);
-            tokens += this.estimateTokens(paramStr, 'code');
-        }
-        // 工具定义的一些固定开销
-        tokens += 10;
-        return tokens;
-    }
-    /**
-     * 计算完整请求的token数量
-     */
-    static estimateRequestTokens(request) {
-        if (!request) {
-            return { inputTokens: 0 };
-        }
-        let inputTokens = 0;
-        let toolTokens = 0;
-        // 计算model的token数量
-        if (request.model) {
-            inputTokens += this.estimateTokens(request.model, 'en');
-        }
-        // 计算系统指令的token数量
-        if (request.system || request.messages?.[0]?.role === 'system') {
-            const systemContent = request.system || request.messages[0].content;
-            inputTokens += this.estimateTokens(systemContent, 'auto');
-        }
-        // 计算消息的token数量
-        if (request.messages && Array.isArray(request.messages)) {
-            for (const message of request.messages) {
-                if (message.role !== 'system') { // 系统消息已经计算过了
-                    inputTokens += this.estimateMessageTokens(message, 'auto');
-                }
-            }
-        }
-        // 计算工具定义的token数量
-        if (request.tools && Array.isArray(request.tools)) {
-            for (const tool of request.tools) {
-                toolTokens += this.estimateToolTokens(tool);
-            }
-        }
-        // 请求格式的固定开销
-        inputTokens += 10;
-        return {
-            inputTokens,
-            ...(toolTokens > 0 && { toolTokens })
-        };
-    }
-    /**
-     * 计算响应的token数量
-     */
-    static estimateResponseTokens(response) {
-        if (!response) {
-            return 0;
-        }
-        let tokens = 0;
-        // 计算response content的token数量
-        if (response.choices && response.choices[0]) {
-            const choice = response.choices[0];
-            if (choice.message) {
-                // 计算文本内容
-                if (choice.message.content) {
-                    tokens += this.estimateTokens(choice.message.content, 'auto');
-                }
-                // 计算工具调用的token数量
-                if (choice.message.tool_calls && Array.isArray(choice.message.tool_calls)) {
-                    for (const toolCall of choice.message.tool_calls) {
-                        tokens += this.estimateTokens(toolCall.function?.name || '', 'en');
-                        tokens += this.estimateTokens(toolCall.function?.arguments || '{}', 'code');
-                        tokens += 5; // 工具调用固定开销
-                    }
-                }
-            }
-            // 响应格式的固定开销
-            tokens += 5;
-        }
-        else if (response.content && Array.isArray(response.content)) {
-            // Anthropic Messages格式
-            for (const contentItem of response.content) {
-                if (contentItem.type === 'text' && contentItem.text) {
-                    tokens += this.estimateTokens(contentItem.text, 'auto');
-                }
-                else if (contentItem.type === 'tool_use') {
-                    tokens += this.estimateTokens(contentItem.name || '', 'en');
-                    tokens += this.estimateTokens(JSON.stringify(contentItem.input || {}), 'code');
-                    tokens += 5; // 工具使用固定开销
-                }
-            }
-        }
-        return tokens;
-    }
-    /**
-     * 精确计算token数量（使用tiktoken库）
-     *
-     * 使用tiktoken库进行精确的token计算
-     */
-    static async calculateTokensExact(text, model = 'gpt-3.5-turbo') {
-        if (!ENABLE_TIKTOKEN) {
-            return this.estimateTokens(text);
-        }
-        try {
-            // 动态导入tiktoken
-            const { encoding_for_model } = await import('tiktoken');
-            // 获取模型对应的编码器
-            const encoding = encoding_for_model(model);
-            // 计算token数量
-            const tokens = encoding.encode(text);
-            const tokenCount = tokens.length;
-            // 释放编码器资源
-            encoding.free();
-            return tokenCount;
-        }
-        catch (error) {
-            // 如果tiktoken计算失败，回退到估算方法
-            console.warn('tiktoken calculation failed, using estimation:', error);
-            return this.estimateTokens(text);
-        }
-    }
-    /**
-     * 检查tiktoken库是否可用
-     */
-    static async isTiktokenAvailable() {
-        if (!ENABLE_TIKTOKEN)
-            return false;
-        try {
-            // 尝试导入tiktoken来检查可用性
-            await import('tiktoken');
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * 智能token计算（优先使用tiktoken，回退到估算）
-     */
-    static async calculateTokens(text, model = 'gpt-3.5-turbo') {
-        // 如果tiktoken可用，使用精确计算
-        if (await this.isTiktokenAvailable()) {
-            return await this.calculateTokensExact(text, model);
-        }
-        // 否则使用估算方法
-        return this.estimateTokens(text);
-    }
-    /**
-     * 计算消息的精确token数量（使用tiktoken）
-     */
-    static async calculateMessageTokensExact(message, model = 'gpt-3.5-turbo') {
-        if (!ENABLE_TIKTOKEN) {
-            return this.estimateMessageTokens(message);
-        }
-        try {
-            const { encoding_for_model } = await import('tiktoken');
-            const encoding = encoding_for_model(model);
-            let totalTokens = 0;
-            // 计算role的token数量
-            if (message.role) {
-                totalTokens += encoding.encode(message.role).length;
-            }
-            // 计算content的token数量
-            if (message.content) {
-                if (typeof message.content === 'string') {
-                    totalTokens += encoding.encode(message.content).length;
-                }
-                else if (Array.isArray(message.content)) {
-                    for (const contentItem of message.content) {
-                        if (contentItem.type === 'text' && contentItem.text) {
-                            totalTokens += encoding.encode(contentItem.text).length;
-                        }
-                        else if (contentItem.type === 'image') {
-                            // 图片token成本（使用OpenAI的典型值）
-                            totalTokens += 85;
-                        }
-                    }
-                }
-            }
-            // 计算tool_calls的token数量
-            if (message.tool_calls && Array.isArray(message.tool_calls)) {
-                for (const toolCall of message.tool_calls) {
-                    // tool name
-                    if (toolCall.function?.name) {
-                        totalTokens += encoding.encode(toolCall.function.name).length;
-                    }
-                    // arguments
-                    const args = toolCall.function?.arguments || '{}';
-                    totalTokens += encoding.encode(args).length;
-                    // tool调用固定开销
-                    totalTokens += 5;
-                }
-            }
-            // 每个消息的固定开销
-            totalTokens += 3;
-            encoding.free();
-            return totalTokens;
-        }
-        catch (error) {
-            console.warn('tiktoken message calculation failed, using estimation:', error);
-            return this.estimateMessageTokens(message);
-        }
-    }
-    /**
-     * 计算工具定义的精确token数量（使用tiktoken）
-     */
-    static async calculateToolTokensExact(tool, model = 'gpt-3.5-turbo') {
-        if (!ENABLE_TIKTOKEN) {
-            return this.estimateToolTokens(tool);
-        }
-        try {
-            const { encoding_for_model } = await import('tiktoken');
-            const encoding = encoding_for_model(model);
-            let tokens = 0;
-            if (tool?.function) {
-                // function name
-                if (tool.function.name) {
-                    tokens += encoding.encode(tool.function.name).length;
-                }
-                // function description
-                if (tool.function.description) {
-                    tokens += encoding.encode(tool.function.description).length;
-                }
-                // function parameters (JSON schema)
-                if (tool.function.parameters) {
-                    const paramStr = JSON.stringify(tool.function.parameters);
-                    tokens += encoding.encode(paramStr).length;
-                }
-            }
-            // 工具定义固定开销
-            tokens += 10;
-            encoding.free();
-            return tokens;
-        }
-        catch (error) {
-            console.warn('tiktoken tool calculation failed, using estimation:', error);
-            return this.estimateToolTokens(tool);
-        }
-    }
-    /**
-     * 计算请求的精确token数量（使用tiktoken）
-     *
-     * 非严格版本：若tiktoken不可用或出错，则回退到估算方法。
-     * 注意：路由/长上下文判断应优先使用 calculateRequestTokensStrict，禁止静默回退。
-     */
-    static async calculateRequestTokensExact(request, model = 'gpt-3.5-turbo') {
-        if (!ENABLE_TIKTOKEN) {
-            return this.estimateRequestTokens(request);
-        }
-        try {
-            return await this.calculateRequestTokensStrict(request, model);
-        }
-        catch (error) {
-            console.warn('tiktoken request calculation failed, using estimation:', error);
-            return this.estimateRequestTokens(request);
-        }
-    }
-    /**
-     * 计算请求的精确token数量（使用tiktoken，严格模式：禁止回退）
-     *
-     * 任何错误直接抛出，由调用方决定是否Fail Fast。
-     */
-    static async calculateRequestTokensStrict(request, model = 'gpt-3.5-turbo') {
-        const { get_encoding } = await import('tiktoken');
-        let inputTokens = 0;
-        let toolTokens = 0;
-        // 使用统一的cl100k_base编码，避免对非OpenAI模型抛出Invalid model错误
-        const encoding = get_encoding('cl100k_base');
-        const encodeText = (text) => {
-            if (!text || typeof text !== 'string')
-                return 0;
-            return encoding.encode(text).length;
-        };
-        try {
-            // 计算model的token数量
-            if (request.model) {
-                inputTokens += encodeText(request.model);
-            }
-            // 计算系统指令的token数量
-            if (request.system || request.messages?.[0]?.role === 'system') {
-                const systemContent = request.system || request.messages?.[0]?.content || '';
-                inputTokens += encodeText(systemContent);
-            }
-            // 计算消息的token数量
-            if (request.messages && Array.isArray(request.messages)) {
-                for (const message of request.messages) {
-                    if (!message || typeof message !== 'object')
-                        continue;
-                    if (message.role === 'system')
-                        continue; // 系统消息已单独计算
-                    // role
-                    if (message.role) {
-                        inputTokens += encodeText(message.role);
-                    }
-                    // content
-                    const content = message.content;
-                    if (typeof content === 'string') {
-                        inputTokens += encodeText(content);
-                    }
-                    else if (Array.isArray(content)) {
-                        for (const part of content) {
-                            if (part && typeof part === 'object') {
-                                if (part.type === 'text' && typeof part.text === 'string') {
-                                    inputTokens += encodeText(part.text);
-                                }
-                                else if (part.type === 'image_url') {
-                                    // 使用与 estimateMessageTokens 相同的图片成本基准
-                                    inputTokens += 85;
-                                }
-                            }
-                        }
-                    }
-                    // tool_calls
-                    if (Array.isArray(message.tool_calls)) {
-                        for (const tc of message.tool_calls) {
-                            const fn = tc?.function;
-                            if (fn?.name) {
-                                inputTokens += encodeText(fn.name);
-                            }
-                            const args = typeof fn?.arguments === 'string' ? fn.arguments : JSON.stringify(fn?.arguments ?? {});
-                            inputTokens += encodeText(args);
-                            inputTokens += 5; // 固定开销
-                        }
-                    }
-                    // 每个消息的固定开销
-                    inputTokens += 3;
-                }
-            }
-            // 计算工具定义的token数量
-            if (request.tools && Array.isArray(request.tools)) {
-                for (const tool of request.tools) {
-                    if (!tool || typeof tool !== 'object')
-                        continue;
-                    const fn = tool.function || {};
-                    if (fn.name) {
-                        toolTokens += encodeText(fn.name);
-                    }
-                    if (fn.description) {
-                        toolTokens += encodeText(fn.description);
-                    }
-                    if (fn.parameters) {
-                        toolTokens += encodeText(JSON.stringify(fn.parameters));
-                    }
-                    // 工具定义固定开销
-                    toolTokens += 10;
-                }
-            }
-            // 请求格式的固定开销
-            inputTokens += 10;
-            return {
-                inputTokens,
-                ...(toolTokens > 0 && { toolTokens })
-            };
-        }
-        finally {
-            try {
-                encoding.free();
-            }
-            catch {
-                // ignore
-            }
-        }
-    }
-    /**
-     * 计算响应的精确token数量（使用tiktoken）
-     */
-    static async calculateResponseTokensExact(response, model = 'gpt-3.5-turbo') {
-        if (!ENABLE_TIKTOKEN) {
-            return this.estimateResponseTokens(response);
-        }
-        try {
-            let tokens = 0;
-            // 计算response content的token数量
-            if (response.choices && response.choices[0]) {
-                const choice = response.choices[0];
-                if (choice.message) {
-                    // 计算文本内容
-                    if (choice.message.content) {
-                        tokens += await this.calculateTokensExact(choice.message.content, model);
-                    }
-                    // 计算工具调用的token数量
-                    if (choice.message.tool_calls && Array.isArray(choice.message.tool_calls)) {
-                        for (const toolCall of choice.message.tool_calls) {
-                            if (toolCall.function?.name) {
-                                tokens += await this.calculateTokensExact(toolCall.function.name, model);
-                            }
-                            const args = toolCall.function?.arguments || '{}';
-                            tokens += await this.calculateTokensExact(args, model);
-                            tokens += 5; // 工具调用固定开销
-                        }
-                    }
-                }
-                // 响应格式的固定开销
-                tokens += 5;
-            }
-            else if (response.content && Array.isArray(response.content)) {
-                // Anthropic Messages格式
-                for (const contentItem of response.content) {
-                    if (contentItem.type === 'text' && contentItem.text) {
-                        tokens += await this.calculateTokensExact(contentItem.text, model);
-                    }
-                    else if (contentItem.type === 'tool_use') {
-                        if (contentItem.name) {
-                            tokens += await this.calculateTokensExact(contentItem.name, model);
-                        }
-                        const input = JSON.stringify(contentItem.input || {});
-                        tokens += await this.calculateTokensExact(input, model);
-                        tokens += 5; // 工具使用固定开销
-                    }
-                }
-            }
-            return tokens;
-        }
-        catch (error) {
-            console.warn('tiktoken response calculation failed, using estimation:', error);
-            return this.estimateResponseTokens(response);
-        }
-    }
-}