@jsonstudio/llms 0.4.2

package/dist/utils/request-utils.js

@@ -0,0 +1,333 @@
+/**
+ * 请求工具函数
+ */
+/**
+ * 请求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

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