@jsonstudio/llms 0.4.2 → 0.4.4

package/dist/utils/response-utils.js

@@ -1,516 +0,0 @@
-/**
- * 响应工具函数
- */
-/**
- * 响应标准化工具
- */
-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

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