@jsonstudio/llms 0.4.2

package/dist/utils/token-counter.js

@@ -0,0 +1,541 @@
+/**
+ * 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);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@jsonstudio/llms",
+  "version": "0.4.2",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "build:dev": "tsc -p tsconfig.json",
+    "postbuild": "node scripts/tests/run-matrix-ci.mjs",
+    "verif": "node scripts/tests/run-matrix-ci.mjs",
+    "verif:bridge": "node scripts/tests/run-cross-bridge-ci.mjs",
+    "test:looprt:chat": "npm run build && node scripts/tests/loop-rt-chat.mjs",
+    "test:looprt:responses": "npm run build && node scripts/tests/loop-rt-responses.mjs",
+    "test:looprt:anthropic": "npm run build && node scripts/tests/loop-rt-anthropic.mjs",
+    "test:looprt:all": "npm run build:dev && node scripts/tests/loop-rt-all.mjs",
+    "capture:chat:lmstudio": "node scripts/tools/capture-chat-golden-lmstudio.mjs",
+    "capture:chat:modelscope": "node scripts/tools/capture-chat-golden-modelscope.mjs",
+    "test:matrix": "npm run build:dev && node scripts/tests/run-matrix-ci.mjs",
+    "test:phase2": "npm run build && node scripts/tests/run-phase2a.mjs",
+    "test:phase3-sse": "npm run build && node scripts/tests/sse-node-roundtrip.mjs",
+    "test:anthropic-sse": "npm run build && node scripts/tests/anthropic-sse-node-roundtrip.mjs",
+    "test:anthropic-node": "npm run build && node scripts/tests/anthropic-node-roundtrip.mjs",
+    "capture:anthropic:golden": "node scripts/tools/capture-anthropic-golden.mjs --config $HOME/.routecodex/provider/glm-anthropic/config.json --prompt 'Say hi in one sentence'",
+    "test:anthropic-golden": "npm run build && node scripts/tests/anthropic-golden-roundtrip.mjs",
+    "test:looprt:gemini": "npm run build && node scripts/tests/loop-rt-gemini.mjs",
+    "replay:responses:chat-sse": "node scripts/exp3-responses-sse-to-chat-sse.mjs",
+    "replay:responses:loop": "node scripts/exp4-responses-sse-loop.mjs",
+    "replay:chat:bridge": "node scripts/exp5-chat-direct-bridge.mjs",
+    "test:virtual-router": "npm run build:dev && node scripts/tests/virtual-router-dry-run.mjs",
+    "test:virtual-router-health": "npm run build:dev && node scripts/tests/virtual-router-health.mjs"
+  },
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "openai": "^6.9.1",
+    "tiktoken": "^1.0.22"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./sse": {
+      "import": "./dist/sse/index.js",
+      "types": "./dist/sse/index.d.ts"
+    },
+    "./conversion": {
+      "import": "./dist/conversion/index.js",
+      "types": "./dist/conversion/index.d.ts"
+    },
+    "./guidance": {
+      "import": "./dist/guidance/index.js",
+      "types": "./dist/guidance/index.d.ts"
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.25",
+    "typescript": "^5.4.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}