@jsonstudio/llms 0.4.2 → 0.4.4

package/dist/utils/request-utils.js

@@ -1,333 +0,0 @@
-/**
- * 请求工具函数
- */
-/**
- * 请求ID生成器
- */
-export class RequestIdGenerator {
-    static counter = 0;
-    static generate() {
-        const timestamp = Date.now();
-        const sequence = ++this.counter;
-        return `req_${timestamp}_${sequence}`;
-    }
-    static reset() {
-        this.counter = 0;
-    }
-}
-/**
- * 请求验证工具
- */
-export class RequestValidator {
-    /**
-     * 验证基础请求结构
-     */
-    static validateBasicRequest(request) {
-        const errors = [];
-        if (!request || typeof request !== 'object') {
-            errors.push('请求必须是一个对象');
-            return { valid: false, errors };
-        }
-        if (!request.model || typeof request.model !== 'string') {
-            errors.push('请求必须包含有效的model字段');
-        }
-        if (!request.messages || !Array.isArray(request.messages)) {
-            errors.push('请求必须包含有效的messages数组');
-        }
-        else {
-            // 验证消息结构
-            for (let i = 0; i < request.messages.length; i++) {
-                const message = request.messages[i];
-                if (!message.role || !['system', 'user', 'assistant'].includes(message.role)) {
-                    errors.push(`消息${i}的role字段无效`);
-                }
-                if (!message.content || typeof message.content !== 'string') {
-                    errors.push(`消息${i}的content字段无效`);
-                }
-            }
-        }
-        return { valid: errors.length === 0, errors };
-    }
-    /**
-     * 验证Chat请求
-     */
-    static validateChatRequest(request) {
-        const basicValidation = this.validateBasicRequest(request);
-        if (!basicValidation.valid) {
-            return basicValidation;
-        }
-        const errors = [];
-        // Chat特定验证
-        if (request.stream && typeof request.stream !== 'boolean') {
-            errors.push('stream字段必须是布尔值');
-        }
-        if (request.temperature !== undefined) {
-            if (typeof request.temperature !== 'number' ||
-                request.temperature < 0 ||
-                request.temperature > 2) {
-                errors.push('temperature必须是0-2之间的数字');
-            }
-        }
-        if (request.max_tokens !== undefined) {
-            if (typeof request.max_tokens !== 'number' ||
-                request.max_tokens <= 0) {
-                errors.push('max_tokens必须是正整数');
-            }
-        }
-        return { valid: errors.length === 0, errors };
-    }
-    /**
-     * 验证Responses请求
-     */
-    static validateResponsesRequest(request) {
-        const errors = [];
-        if (!request || typeof request !== 'object') {
-            errors.push('请求必须是一个对象');
-            return { valid: false, errors };
-        }
-        if (!request.input || typeof request.input !== 'string') {
-            errors.push('Responses请求必须包含有效的input字段');
-        }
-        // Responses特定验证
-        if (request.tools && !Array.isArray(request.tools)) {
-            errors.push('tools字段必须是数组');
-        }
-        if (request.temperature !== undefined) {
-            if (typeof request.temperature !== 'number' ||
-                request.temperature < 0 ||
-                request.temperature > 2) {
-                errors.push('temperature必须是0-2之间的数字');
-            }
-        }
-        return { valid: errors.length === 0, errors };
-    }
-    /**
-     * 验证Messages请求
-     */
-    static validateMessagesRequest(request) {
-        const errors = [];
-        if (!request || typeof request !== 'object') {
-            errors.push('请求必须是一个对象');
-            return { valid: false, errors };
-        }
-        if (!request.messages || !Array.isArray(request.messages)) {
-            errors.push('Messages请求必须包含有效的messages数组');
-        }
-        else {
-            // Anthropic特定验证
-            for (let i = 0; i < request.messages.length; i++) {
-                const message = request.messages[i];
-                if (!message.role || !['user', 'assistant'].includes(message.role)) {
-                    errors.push(`Messages消息${i}的role字段必须是user或assistant`);
-                }
-                if (message.role === 'user') {
-                    if (!message.content || (typeof message.content !== 'string' && !Array.isArray(message.content))) {
-                        errors.push(`Messages用户消息${i}的content字段无效`);
-                    }
-                }
-            }
-        }
-        // 验证system字段（如果有）
-        if (request.system && typeof request.system !== 'string') {
-            errors.push('system字段必须是字符串');
-        }
-        return { valid: errors.length === 0, errors };
-    }
-}
-/**
- * 请求转换工具
- */
-export class RequestTransformer {
-    /**
-     * 标准化请求格式
-     */
-    static normalizeRequest(request, targetProtocol) {
-        const normalized = { ...request };
-        // 根据目标协议调整格式
-        switch (targetProtocol) {
-            case 'openai-chat':
-                return this.normalizeToOpenAIChat(normalized);
-            case 'openai-responses':
-                return this.normalizeToOpenAIResponses(normalized);
-            case 'anthropic-messages':
-                return this.normalizeToAnthropicMessages(normalized);
-            default:
-                return normalized;
-        }
-    }
-    /**
-     * 转换为OpenAI Chat格式
-     */
-    static normalizeToOpenAIChat(request) {
-        const normalized = {
-            model: request.model,
-            messages: request.messages || [],
-            temperature: request.temperature,
-            max_tokens: request.max_tokens,
-            stream: request.stream || false,
-            tools: request.tools || undefined,
-            ...request
-        };
-        // 移除不需要的字段
-        delete normalized.input;
-        delete normalized.system;
-        return normalized;
-    }
-    /**
-     * 转换为OpenAI Responses格式
-     */
-    static normalizeToOpenAIResponses(request) {
-        // 如果已经是Responses格式，直接返回
-        if (request.input) {
-            return { ...request };
-        }
-        // 从Chat格式转换
-        const lastMessage = request.messages?.[request.messages.length - 1];
-        const userContent = lastMessage?.role === 'user' ? lastMessage.content : '';
-        return {
-            input: userContent,
-            instructions: request.messages?.find((m) => m.role === 'system')?.content,
-            tools: request.tools,
-            temperature: request.temperature,
-            max_tokens: request.max_tokens,
-            stream: request.stream,
-            ...request
-        };
-    }
-    /**
-     * 转换为Anthropic Messages格式
-     */
-    static normalizeToAnthropicMessages(request) {
-        const normalized = {
-            model: request.model,
-            messages: request.messages?.filter((m) => m.role !== 'system') || [],
-            max_tokens: request.max_tokens || 1024,
-            temperature: request.temperature,
-            stream: request.stream,
-            tools: request.tools
-        };
-        // 提取system消息
-        const systemMessage = request.messages?.find((m) => m.role === 'system');
-        if (systemMessage) {
-            normalized.system = systemMessage.content;
-        }
-        return normalized;
-    }
-}
-/**
- * 请求上下文工具
- */
-export class RequestContextBuilder {
-    /**
-     * 构建Hook上下文
-     */
-    static buildHookContext(requestId, endpoint, stage, additionalData) {
-        return {
-            executionId: `exec_${Date.now()}`,
-            stage: stage,
-            startTime: Date.now(),
-            requestId,
-            moduleId: 'request-utils',
-            endpoint: endpoint,
-            originalProtocol: 'openai-chat',
-            targetProtocol: 'openai-chat',
-            pathIdentifier: 'req-path',
-            processingMode: 'non-streaming',
-            hookSequence: 1,
-            totalHooks: 16,
-            metadata: {
-                processingStartTime: Date.now(),
-                userAgent: 'llmswitch-v2',
-                ...additionalData?.metadata
-            },
-            ...additionalData
-        };
-    }
-    /**
-     * 更新上下文元数据
-     */
-    static updateMetadata(context, updates) {
-        return {
-            ...context,
-            metadata: {
-                ...context.metadata,
-                ...updates,
-                lastUpdated: Date.now()
-            }
-        };
-    }
-    /**
-     * 添加性能指标
-     */
-    static addPerformanceMetrics(context, metrics) {
-        return this.updateMetadata(context, {
-            performance: {
-                ...(context.metadata?.performance || {}),
-                ...metrics
-            }
-        });
-    }
-}
-/**
- * 请求追踪工具
- */
-export class RequestTracker {
-    static activeRequests = new Map();
-    /**
-     * 开始追踪请求
-     */
-    static startTracking(requestId, endpoint, metadata) {
-        this.activeRequests.set(requestId, {
-            startTime: Date.now(),
-            endpoint,
-            metadata: metadata || {}
-        });
-    }
-    /**
-     * 结束追踪请求
-     */
-    static endTracking(requestId) {
-        const tracking = this.activeRequests.get(requestId);
-        if (!tracking) {
-            return null;
-        }
-        const duration = Date.now() - tracking.startTime;
-        this.activeRequests.delete(requestId);
-        return {
-            duration,
-            endpoint: tracking.endpoint,
-            metadata: tracking.metadata
-        };
-    }
-    /**
-     * 获取活跃请求统计
-     */
-    static getActiveRequestsStats() {
-        const byEndpoint = {};
-        let oldestRequest = Date.now();
-        for (const [requestId, tracking] of this.activeRequests) {
-            byEndpoint[tracking.endpoint] = (byEndpoint[tracking.endpoint] || 0) + 1;
-            oldestRequest = Math.min(oldestRequest, tracking.startTime);
-        }
-        return {
-            count: this.activeRequests.size,
-            byEndpoint,
-            oldestRequest: this.activeRequests.size > 0 ? oldestRequest : 0
-        };
-    }
-    /**
-     * 清理过期请求
-     */
-    static cleanupExpiredRequests(maxAge = 300000) {
-        const now = Date.now();
-        const expiredRequests = [];
-        for (const [requestId, tracking] of this.activeRequests) {
-            if (now - tracking.startTime > maxAge) {
-                expiredRequests.push(requestId);
-            }
-        }
-        for (const requestId of expiredRequests) {
-            this.activeRequests.delete(requestId);
-        }
-    }
-}

package/dist/utils/response-utils.d.ts

@@ -1,127 +0,0 @@
-/**
- * 响应工具函数
- */
-/**
- * 响应标准化工具
- */
-export declare class ResponseNormalizer {
-    /**
-     * 标准化响应格式
-     */
-    static normalizeResponse(response: any, sourceProtocol: string, targetProtocol: string): any;
-    /**
-     * 转换为OpenAI Chat格式
-     */
-    private static normalizeToOpenAIChat;
-    /**
-     * 转换为OpenAI Responses格式
-     */
-    private static normalizeToOpenAIResponses;
-    /**
-     * 转换为Anthropic Messages格式
-     */
-    private static normalizeToAnthropicMessages;
-    /**
-     * 标准化Chat消息
-     */
-    private static normalizeChatMessage;
-    /**
-     * 标准化使用信息
-     */
-    private static normalizeUsage;
-    /**
-     * 标准化Anthropic使用信息
-     */
-    private static normalizeAnthropicUsage;
-    /**
-     * 映射结束原因
-     */
-    private static mapFinishReason;
-    /**
-     * 生成响应ID
-     */
-    private static generateId;
-    /**
-     * 创建错误响应
-     */
-    private static createErrorResponse;
-}
-/**
- * 响应验证工具
- */
-export declare class ResponseValidator {
-    /**
-     * 验证响应结构
-     */
-    static validateResponse(response: any, expectedProtocol: string): {
-        valid: boolean;
-        errors: string[];
-    };
-    /**
-     * 验证OpenAI Chat响应
-     */
-    private static validateOpenAIChatResponse;
-    /**
-     * 验证OpenAI Responses响应
-     */
-    private static validateOpenAIResponsesResponse;
-    /**
-     * 验证Anthropic Messages响应
-     */
-    private static validateAnthropicMessagesResponse;
-}
-/**
- * 响应处理工具
- */
-export declare class ResponseProcessor {
-    /**
-     * 处理流式响应
-     */
-    static processStreamingResponse(response: any, onChunk: (chunk: any) => void, onComplete: () => void, onError: (error: Error) => void): void;
-    /**
-     * 处理流式响应体
-     */
-    private static processStreamBody;
-    /**
-     * 处理SSE数据
-     */
-    private static processSSEData;
-    /**
-     * 累积流式响应
-     */
-    static accumulateStreamingResponse(chunks: any[]): any;
-}
-/**
- * 响应缓存工具
- */
-export declare class ResponseCache {
-    private static cache;
-    /**
-     * 缓存响应
-     */
-    static set(key: string, response: any, ttl?: number): void;
-    /**
-     * 获取缓存响应
-     */
-    static get(key: string): any | null;
-    /**
-     * 删除缓存
-     */
-    static delete(key: string): boolean;
-    /**
-     * 清理过期缓存
-     */
-    static cleanup(): void;
-    /**
-     * 获取缓存统计
-     */
-    static getStats(): {
-        size: number;
-        hitRate: number;
-        memoryUsage: number;
-    };
-    /**
-     * 清空缓存
-     */
-    static clear(): void;
-}