@jsonstudio/llms 0.4.2

package/dist/utils/response-utils.js

@@ -0,0 +1,516 @@
+/**
+ * 响应工具函数
+ */
+/**
+ * 响应标准化工具
+ */
+export class ResponseNormalizer {
+    /**
+     * 标准化响应格式
+     */
+    static normalizeResponse(response, sourceProtocol, targetProtocol) {
+        if (!response) {
+            return this.createErrorResponse('Empty response', 'invalid_response');
+        }
+        try {
+            switch (targetProtocol) {
+                case 'openai-chat':
+                    return this.normalizeToOpenAIChat(response, sourceProtocol);
+                case 'openai-responses':
+                    return this.normalizeToOpenAIResponses(response, sourceProtocol);
+                case 'anthropic-messages':
+                    return this.normalizeToAnthropicMessages(response, sourceProtocol);
+                default:
+                    return response;
+            }
+        }
+        catch (error) {
+            return this.createErrorResponse(`Response normalization failed: ${error instanceof Error ? error.message : 'Unknown error'}`, 'normalization_error');
+        }
+    }
+    /**
+     * 转换为OpenAI Chat格式
+     */
+    static normalizeToOpenAIChat(response, sourceProtocol) {
+        const baseResponse = {
+            id: response.id || this.generateId(),
+            object: 'chat.completion',
+            created: response.created || Date.now(),
+            model: response.model || 'unknown',
+            choices: [],
+            usage: this.normalizeUsage(response.usage || {}),
+            system_fingerprint: response.system_fingerprint || null
+        };
+        // 处理choices
+        if (response.choices && Array.isArray(response.choices)) {
+            baseResponse.choices = response.choices.map((choice) => ({
+                index: choice.index || 0,
+                message: this.normalizeChatMessage(choice.message),
+                finish_reason: choice.finish_reason || 'stop'
+            }));
+        }
+        else if (response.content || response.text) {
+            // 简单响应转换为choice格式
+            baseResponse.choices = [{
+                    index: 0,
+                    message: {
+                        role: 'assistant',
+                        content: response.content || response.text
+                    },
+                    finish_reason: 'stop'
+                }];
+        }
+        return baseResponse;
+    }
+    /**
+     * 转换为OpenAI Responses格式
+     */
+    static normalizeToOpenAIResponses(response, sourceProtocol) {
+        if (sourceProtocol === 'openai-responses' && response.id) {
+            // 已经是Responses格式
+            return response;
+        }
+        // 从Chat格式转换
+        const choice = response.choices?.[0];
+        const content = choice?.message?.content || response.content || '';
+        return {
+            id: response.id || this.generateId(),
+            object: 'response',
+            created: response.created || Date.now(),
+            model: response.model || 'unknown',
+            output: [{
+                    type: 'message',
+                    id: this.generateId(),
+                    role: 'assistant',
+                    content: [{
+                            type: 'text',
+                            text: content
+                        }]
+                }],
+            output_text: content,
+            usage: this.normalizeUsage(response.usage || {}),
+            tool_calls: choice?.message?.tool_calls || []
+        };
+    }
+    /**
+     * 转换为Anthropic Messages格式
+     */
+    static normalizeToAnthropicMessages(response, sourceProtocol) {
+        const baseResponse = {
+            id: response.id || this.generateId(),
+            type: 'message',
+            role: 'assistant',
+            content: [],
+            model: response.model || 'unknown',
+            stop_reason: this.mapFinishReason(response.choices?.[0]?.finish_reason),
+            stop_sequence: null,
+            usage: this.normalizeAnthropicUsage(response.usage || {})
+        };
+        // 处理内容
+        const choice = response.choices?.[0];
+        if (choice?.message?.content) {
+            baseResponse.content.push({
+                type: 'text',
+                text: choice.message.content
+            });
+        }
+        // 处理工具调用
+        if (choice?.message?.tool_calls) {
+            for (const toolCall of choice.message.tool_calls) {
+                baseResponse.content.push({
+                    type: 'tool_use',
+                    id: toolCall.id,
+                    name: toolCall.function.name,
+                    input: JSON.parse(toolCall.function.arguments)
+                });
+            }
+        }
+        return baseResponse;
+    }
+    /**
+     * 标准化Chat消息
+     */
+    static normalizeChatMessage(message) {
+        if (!message) {
+            return { role: 'assistant', content: '' };
+        }
+        return {
+            role: message.role || 'assistant',
+            content: message.content || '',
+            tool_calls: message.tool_calls || [],
+            refusal: message.refusal || null
+        };
+    }
+    /**
+     * 标准化使用信息
+     */
+    static normalizeUsage(usage) {
+        return {
+            prompt_tokens: usage.prompt_tokens || 0,
+            completion_tokens: usage.completion_tokens || 0,
+            total_tokens: usage.total_tokens || (usage.prompt_tokens || 0) + (usage.completion_tokens || 0)
+        };
+    }
+    /**
+     * 标准化Anthropic使用信息
+     */
+    static normalizeAnthropicUsage(usage) {
+        return {
+            input_tokens: usage.input_tokens || usage.prompt_tokens || 0,
+            output_tokens: usage.output_tokens || usage.completion_tokens || 0
+        };
+    }
+    /**
+     * 映射结束原因
+     */
+    static mapFinishReason(reason) {
+        const mapping = {
+            'stop': 'end_turn',
+            'length': 'max_tokens',
+            'tool_calls': 'tool_use',
+            'content_filter': 'stop_sequence',
+            'function_call': 'tool_use'
+        };
+        return mapping[reason] || 'end_turn';
+    }
+    /**
+     * 生成响应ID
+     */
+    static generateId() {
+        return `resp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * 创建错误响应
+     */
+    static createErrorResponse(message, type) {
+        return {
+            error: {
+                message,
+                type,
+                code: 'response_processing_error'
+            },
+            id: this.generateId(),
+            object: 'error',
+            created: Date.now()
+        };
+    }
+}
+/**
+ * 响应验证工具
+ */
+export class ResponseValidator {
+    /**
+     * 验证响应结构
+     */
+    static validateResponse(response, expectedProtocol) {
+        const errors = [];
+        if (!response || typeof response !== 'object') {
+            errors.push('响应必须是一个对象');
+            return { valid: false, errors };
+        }
+        switch (expectedProtocol) {
+            case 'openai-chat':
+                return this.validateOpenAIChatResponse(response);
+            case 'openai-responses':
+                return this.validateOpenAIResponsesResponse(response);
+            case 'anthropic-messages':
+                return this.validateAnthropicMessagesResponse(response);
+            default:
+                return { valid: true, errors: [] };
+        }
+    }
+    /**
+     * 验证OpenAI Chat响应
+     */
+    static validateOpenAIChatResponse(response) {
+        const errors = [];
+        if (!response.id || typeof response.id !== 'string') {
+            errors.push('响应缺少有效的id字段');
+        }
+        if (response.object !== 'chat.completion') {
+            errors.push('响应object字段应为chat.completion');
+        }
+        if (!response.choices || !Array.isArray(response.choices) || response.choices.length === 0) {
+            errors.push('响应必须包含有效的choices数组');
+        }
+        else {
+            const choice = response.choices[0];
+            if (!choice.message || typeof choice.message !== 'object') {
+                errors.push('choices[0]必须包含有效的message对象');
+            }
+        }
+        if (!response.usage || typeof response.usage !== 'object') {
+            errors.push('响应必须包含有效的usage对象');
+        }
+        return { valid: errors.length === 0, errors };
+    }
+    /**
+     * 验证OpenAI Responses响应
+     */
+    static validateOpenAIResponsesResponse(response) {
+        const errors = [];
+        if (!response.id || typeof response.id !== 'string') {
+            errors.push('响应缺少有效的id字段');
+        }
+        if (response.object !== 'response') {
+            errors.push('响应object字段应为response');
+        }
+        if (!response.output || !Array.isArray(response.output)) {
+            errors.push('响应必须包含有效的output数组');
+        }
+        return { valid: errors.length === 0, errors };
+    }
+    /**
+     * 验证Anthropic Messages响应
+     */
+    static validateAnthropicMessagesResponse(response) {
+        const errors = [];
+        if (!response.id || typeof response.id !== 'string') {
+            errors.push('响应缺少有效的id字段');
+        }
+        if (response.type !== 'message') {
+            errors.push('响应type字段应为message');
+        }
+        if (response.role !== 'assistant') {
+            errors.push('响应role字段应为assistant');
+        }
+        if (!response.content || !Array.isArray(response.content)) {
+            errors.push('响应必须包含有效的content数组');
+        }
+        return { valid: errors.length === 0, errors };
+    }
+}
+/**
+ * 响应处理工具
+ */
+export class ResponseProcessor {
+    /**
+     * 处理流式响应
+     */
+    static processStreamingResponse(response, onChunk, onComplete, onError) {
+        try {
+            if (response.body) {
+                // 处理流式响应体
+                this.processStreamBody(response.body, onChunk, onComplete, onError);
+            }
+            else if (response.data) {
+                // 处理SSE格式的数据
+                this.processSSEData(response.data, onChunk, onComplete, onError);
+            }
+            else {
+                // 处理单个响应
+                onChunk(response);
+                onComplete();
+            }
+        }
+        catch (error) {
+            onError(error instanceof Error ? error : new Error('Unknown streaming error'));
+        }
+    }
+    /**
+     * 处理流式响应体
+     */
+    static async processStreamBody(body, onChunk, onComplete, onError) {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    onComplete();
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (line.startsWith('data: ')) {
+                        const data = line.slice(6);
+                        if (data === '[DONE]') {
+                            onComplete();
+                            return;
+                        }
+                        try {
+                            const chunk = JSON.parse(data);
+                            onChunk(chunk);
+                        }
+                        catch (e) {
+                            // 忽略解析错误的行
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            onError(error instanceof Error ? error : new Error('Stream processing error'));
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    /**
+     * 处理SSE数据
+     */
+    static processSSEData(data, onChunk, onComplete, onError) {
+        try {
+            const lines = data.split('\n');
+            for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                    const chunkData = line.slice(6);
+                    if (chunkData === '[DONE]') {
+                        onComplete();
+                        return;
+                    }
+                    try {
+                        const chunk = JSON.parse(chunkData);
+                        onChunk(chunk);
+                    }
+                    catch (e) {
+                        // 忽略解析错误的行
+                    }
+                }
+            }
+            onComplete();
+        }
+        catch (error) {
+            onError(error instanceof Error ? error : new Error('SSE processing error'));
+        }
+    }
+    /**
+     * 累积流式响应
+     */
+    static accumulateStreamingResponse(chunks) {
+        if (chunks.length === 0) {
+            return null;
+        }
+        const firstChunk = chunks[0];
+        const lastChunk = chunks[chunks.length - 1];
+        // 累积内容
+        let accumulatedContent = '';
+        let accumulatedToolCalls = [];
+        let usage = {};
+        for (const chunk of chunks) {
+            if (chunk.choices && chunk.choices[0]) {
+                const choice = chunk.choices[0];
+                // 累积文本内容
+                if (choice.delta?.content) {
+                    accumulatedContent += choice.delta.content;
+                }
+                // 累积工具调用
+                if (choice.delta?.tool_calls) {
+                    for (const toolCall of choice.delta.tool_calls) {
+                        const existingCall = accumulatedToolCalls.find(tc => tc.index === toolCall.index);
+                        if (existingCall) {
+                            if (toolCall.id)
+                                existingCall.id = toolCall.id;
+                            if (toolCall.function?.name)
+                                existingCall.function.name += toolCall.function.name;
+                            if (toolCall.function?.arguments)
+                                existingCall.function.arguments += toolCall.function.arguments;
+                        }
+                        else {
+                            accumulatedToolCalls.push({
+                                index: toolCall.index,
+                                id: toolCall.id,
+                                function: {
+                                    name: toolCall.function?.name || '',
+                                    arguments: toolCall.function?.arguments || ''
+                                }
+                            });
+                        }
+                    }
+                }
+            }
+            // 获取usage信息（通常在最后一个chunk中）
+            if (chunk.usage) {
+                usage = chunk.usage;
+            }
+        }
+        // 构建累积的响应
+        return {
+            id: lastChunk.id || firstChunk.id,
+            object: 'chat.completion',
+            created: firstChunk.created || Date.now(),
+            model: firstChunk.model || 'unknown',
+            choices: [{
+                    index: 0,
+                    message: {
+                        role: 'assistant',
+                        content: accumulatedContent,
+                        tool_calls: accumulatedToolCalls.length > 0 ? accumulatedToolCalls : undefined
+                    },
+                    finish_reason: lastChunk.choices?.[0]?.finish_reason || 'stop'
+                }],
+            usage: usage || {
+                prompt_tokens: 0,
+                completion_tokens: 0,
+                total_tokens: 0
+            }
+        };
+    }
+}
+/**
+ * 响应缓存工具
+ */
+export class ResponseCache {
+    static cache = new Map();
+    /**
+     * 缓存响应
+     */
+    static set(key, response, ttl = 300000) {
+        this.cache.set(key, {
+            response,
+            timestamp: Date.now(),
+            ttl
+        });
+    }
+    /**
+     * 获取缓存响应
+     */
+    static get(key) {
+        const cached = this.cache.get(key);
+        if (!cached) {
+            return null;
+        }
+        // 检查是否过期
+        if (Date.now() - cached.timestamp > cached.ttl) {
+            this.cache.delete(key);
+            return null;
+        }
+        return cached.response;
+    }
+    /**
+     * 删除缓存
+     */
+    static delete(key) {
+        return this.cache.delete(key);
+    }
+    /**
+     * 清理过期缓存
+     */
+    static cleanup() {
+        const now = Date.now();
+        for (const [key, cached] of this.cache) {
+            if (now - cached.timestamp > cached.ttl) {
+                this.cache.delete(key);
+            }
+        }
+    }
+    /**
+     * 获取缓存统计
+     */
+    static getStats() {
+        return {
+            size: this.cache.size,
+            hitRate: 0, // 需要额外实现命中率统计
+            memoryUsage: JSON.stringify([...this.cache]).length
+        };
+    }
+    /**
+     * 清空缓存
+     */
+    static clear() {
+        this.cache.clear();
+    }
+}

package/dist/utils/token-counter.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Token计数工具
+ *
+ * 基于OpenAI的标准token计算方法
+ * 参考: https://github.com/openai/tiktoken
+ */
+export declare 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: string, language?: 'en' | 'zh' | 'code' | 'auto'): number;
+    /**
+     * 检测文本的主要语言类型
+     */
+    private static detectLanguage;
+    /**
+     * 计算消息的token数量
+     */
+    static estimateMessageTokens(message: any, language?: 'en' | 'zh' | 'code' | 'auto'): number;
+    /**
+     * 计算工具定义的token数量
+     */
+    static estimateToolTokens(tool: any): number;
+    /**
+     * 计算完整请求的token数量
+     */
+    static estimateRequestTokens(request: any): {
+        inputTokens: number;
+        toolTokens?: number;
+    };
+    /**
+     * 计算响应的token数量
+     */
+    static estimateResponseTokens(response: any): number;
+    /**
+     * 精确计算token数量（使用tiktoken库）
+     *
+     * 使用tiktoken库进行精确的token计算
+     */
+    static calculateTokensExact(text: string, model?: string): Promise<number>;
+    /**
+     * 检查tiktoken库是否可用
+     */
+    static isTiktokenAvailable(): Promise<boolean>;
+    /**
+     * 智能token计算（优先使用tiktoken，回退到估算）
+     */
+    static calculateTokens(text: string, model?: string): Promise<number>;
+    /**
+     * 计算消息的精确token数量（使用tiktoken）
+     */
+    static calculateMessageTokensExact(message: any, model?: string): Promise<number>;
+    /**
+     * 计算工具定义的精确token数量（使用tiktoken）
+     */
+    static calculateToolTokensExact(tool: any, model?: string): Promise<number>;
+    /**
+     * 计算请求的精确token数量（使用tiktoken）
+     *
+     * 非严格版本：若tiktoken不可用或出错，则回退到估算方法。
+     * 注意：路由/长上下文判断应优先使用 calculateRequestTokensStrict，禁止静默回退。
+     */
+    static calculateRequestTokensExact(request: any, model?: string): Promise<{
+        inputTokens: number;
+        toolTokens?: number;
+    }>;
+    /**
+     * 计算请求的精确token数量（使用tiktoken，严格模式：禁止回退）
+     *
+     * 任何错误直接抛出，由调用方决定是否Fail Fast。
+     */
+    static calculateRequestTokensStrict(request: any, model?: string): Promise<{
+        inputTokens: number;
+        toolTokens?: number;
+    }>;
+    /**
+     * 计算响应的精确token数量（使用tiktoken）
+     */
+    static calculateResponseTokensExact(response: any, model?: string): Promise<number>;
+}