@jsonstudio/llms 0.4.2

package/dist/endpoints/endpoint-router.js

@@ -0,0 +1,438 @@
+/**
+ * 端点路由器
+ *
+ * 根据请求路径和协议自动路由到对应的端点处理器
+ */
+import { ChatEndpointHandler } from './chat-endpoint-handler.js';
+import { ResponsesEndpointHandler } from './responses-endpoint-handler.js';
+import { MessagesEndpointHandler } from './messages-endpoint-handler.js';
+import { ErrorHandler, ErrorFactory } from '../utils/error-utils.js';
+/**
+ * 端点路由器
+ */
+export class EndpointRouter {
+    handlers = new Map();
+    routingRules = [];
+    hooksAdapter;
+    config;
+    constructor(hooksAdapter, config) {
+        this.hooksAdapter = hooksAdapter;
+        this.config = config;
+        this.initializeHandlers();
+        this.initializeRoutingRules();
+    }
+    /**
+     * 路由请求到对应端点
+     */
+    async routeRequest(path, method, request, headers) {
+        let endpoint;
+        try {
+            // 检测端点类型
+            endpoint = this.detectEndpoint(path, method, headers);
+            if (!endpoint) {
+                if (this.config.fallbackEnabled) {
+                    endpoint = this.config.defaultEndpoint;
+                }
+                else {
+                    throw ErrorFactory.endpointNotFound(`${path} ${method}`, {
+                        path,
+                        method,
+                        availableEndpoints: Array.from(this.handlers.keys()),
+                        fallbackEnabled: false
+                    });
+                }
+            }
+            // 获取处理器
+            const endpointType = endpoint;
+            const handler = this.handlers.get(endpointType);
+            if (!handler) {
+                throw ErrorFactory.internalError(`No handler found for endpoint: ${endpoint}`, undefined, {
+                    endpoint: endpointType,
+                    availableHandlers: Array.from(this.handlers.keys()),
+                    stage: 'routing_handler_lookup'
+                });
+            }
+            // 检查处理器是否启用
+            const endpointInfo = handler.getEndpointInfo();
+            if (!endpointInfo.enabled) {
+                throw ErrorFactory.endpointUnavailable(endpointType, 'Endpoint is disabled', {
+                    path,
+                    method,
+                    endpointInfo,
+                    stage: 'routing_endpoint_disabled'
+                });
+            }
+            // 路由到对应处理器
+            return await handler.processRequest(request, {
+                requestId: this.extractRequestId(headers),
+                metadata: {
+                    originalPath: path,
+                    method,
+                    headers
+                }
+            });
+        }
+        catch (error) {
+            const requestId = this.extractRequestId(headers);
+            const handledError = ErrorHandler.handle(error, {
+                requestId,
+                endpoint: endpoint || undefined,
+                stage: 'route_request'
+            });
+            return {
+                success: false,
+                error: handledError,
+                executionTime: 0,
+                metadata: {
+                    endpoint: (endpoint || 'chat'),
+                    originalProtocol: 'openai-chat',
+                    targetProtocol: 'openai-chat',
+                    processingMode: 'non-streaming',
+                    stage: 'routing_failed'
+                }
+            };
+        }
+    }
+    /**
+     * 路由流式请求
+     */
+    async routeStreamingRequest(path, method, request, headers) {
+        const requestId = this.extractRequestId(headers);
+        try {
+            // 检测端点类型
+            const endpoint = this.detectEndpoint(path, method, headers);
+            if (!endpoint) {
+                if (this.config.fallbackEnabled) {
+                    throw ErrorFactory.endpointUnavailable(`${path} ${method}`, 'Streaming fallback not supported', {
+                        path,
+                        method,
+                        fallbackEnabled: true,
+                        streaming: true
+                    });
+                }
+                else {
+                    throw ErrorFactory.endpointNotFound(`${path} ${method}`, {
+                        path,
+                        method,
+                        availableEndpoints: Array.from(this.handlers.keys()),
+                        streaming: true
+                    });
+                }
+            }
+            // 获取处理器
+            const handler = this.handlers.get(endpoint);
+            if (!handler) {
+                throw ErrorFactory.internalError(`No handler found for endpoint: ${endpoint}`, undefined, {
+                    endpoint,
+                    availableHandlers: Array.from(this.handlers.keys()),
+                    streaming: true,
+                    stage: 'streaming_handler_lookup'
+                });
+            }
+            // 检查处理器是否启用
+            const endpointInfo = handler.getEndpointInfo();
+            if (!endpointInfo.enabled) {
+                throw ErrorFactory.endpointUnavailable(endpoint, 'Endpoint is disabled for streaming', {
+                    path,
+                    method,
+                    endpointInfo,
+                    streaming: true,
+                    stage: 'streaming_endpoint_disabled'
+                });
+            }
+            // 路由到对应处理器
+            return await handler.preprocessStreamingRequest(request, {
+                requestId,
+                metadata: {
+                    originalPath: path,
+                    method,
+                    headers
+                }
+            });
+        }
+        catch (error) {
+            const handledError = ErrorHandler.handle(error, {
+                requestId,
+                stage: 'route_streaming_request'
+            });
+            // 将错误重新抛出，让调用者处理
+            throw handledError;
+        }
+    }
+    /**
+     * 检测端点类型
+     */
+    detectEndpoint(path, method, headers) {
+        // 1. 基于路径模式的精确匹配
+        for (const rule of this.routingRules) {
+            if (rule.pathPattern.test(path) && rule.method.toUpperCase() === method.toUpperCase()) {
+                return rule.endpoint;
+            }
+        }
+        // 2. 基于路径的模糊匹配
+        if (path.includes('/chat/completions')) {
+            return 'chat';
+        }
+        if (path.includes('/responses')) {
+            return 'responses';
+        }
+        if (path.includes('/messages')) {
+            return 'messages';
+        }
+        // 3. 基于Content-Type的检测
+        const contentType = headers?.['content-type'] || headers?.['Content-Type'];
+        if (contentType) {
+            if (contentType.includes('application/json')) {
+                // 进一步分析请求内容
+                return this.detectEndpointFromRequestStructure(path);
+            }
+        }
+        // 4. 自动检测模式
+        if (this.config.autoDetect) {
+            return this.performAutoDetection(path, method, headers);
+        }
+        return null;
+    }
+    /**
+     * 从请求结构检测端点
+     */
+    detectEndpointFromRequestStructure(path) {
+        // 这里可以基于请求体的结构来检测端点类型
+        // 由于这里只看到路径，返回默认的chat端点
+        if (path.includes('/v1/')) {
+            return 'chat';
+        }
+        return null;
+    }
+    /**
+     * 执行自动检测
+     */
+    performAutoDetection(path, method, headers) {
+        // 优先级顺序：Chat > Responses > Messages
+        if (path.includes('chat') || method === 'POST' && path.includes('/completions')) {
+            return 'chat';
+        }
+        if (path.includes('responses') || path.includes('response')) {
+            return 'responses';
+        }
+        if (path.includes('messages') || path.includes('message')) {
+            return 'messages';
+        }
+        return null;
+    }
+    /**
+     * 初始化处理器
+     */
+    initializeHandlers() {
+        for (const [endpoint, config] of Object.entries(this.config.endpointConfigs)) {
+            const endpointType = endpoint;
+            switch (endpointType) {
+                case 'chat':
+                    this.handlers.set(endpointType, new ChatEndpointHandler(this.hooksAdapter));
+                    break;
+                case 'responses':
+                    this.handlers.set(endpointType, new ResponsesEndpointHandler(this.hooksAdapter));
+                    break;
+                case 'messages':
+                    this.handlers.set(endpointType, new MessagesEndpointHandler(this.hooksAdapter));
+                    break;
+                default:
+                    console.warn(`Unknown endpoint type: ${endpointType}`);
+            }
+        }
+    }
+    /**
+     * 初始化路由规则
+     */
+    initializeRoutingRules() {
+        this.routingRules = [
+            // Chat端点规则
+            {
+                pathPattern: /^\/v1\/chat\/completions$/,
+                method: 'POST',
+                endpoint: 'chat',
+                protocol: 'openai-chat',
+                priority: 1
+            },
+            {
+                pathPattern: /^\/chat\/completions$/,
+                method: 'POST',
+                endpoint: 'chat',
+                protocol: 'openai-chat',
+                priority: 1
+            },
+            // Responses端点规则
+            {
+                pathPattern: /^\/v1\/responses$/,
+                method: 'POST',
+                endpoint: 'responses',
+                protocol: 'openai-responses',
+                priority: 2
+            },
+            {
+                pathPattern: /^\/responses$/,
+                method: 'POST',
+                endpoint: 'responses',
+                protocol: 'openai-responses',
+                priority: 2
+            },
+            // Messages端点规则
+            {
+                pathPattern: /^\/v1\/messages$/,
+                method: 'POST',
+                endpoint: 'messages',
+                protocol: 'anthropic-messages',
+                priority: 3
+            },
+            {
+                pathPattern: /^\/messages$/,
+                method: 'POST',
+                endpoint: 'messages',
+                protocol: 'anthropic-messages',
+                priority: 3
+            }
+        ];
+        // 按优先级排序
+        this.routingRules.sort((a, b) => a.priority - b.priority);
+    }
+    /**
+     * 提取请求ID
+     */
+    extractRequestId(headers) {
+        // 尝试从各种头部字段中提取请求ID
+        const idHeaders = [
+            'x-request-id',
+            'request-id',
+            'x-trace-id',
+            'trace-id',
+            'x-correlation-id',
+            'correlation-id'
+        ];
+        for (const header of idHeaders) {
+            const id = headers?.[header] || headers?.[header.toLowerCase()];
+            if (id) {
+                return id;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * 添加路由规则
+     */
+    addRoutingRule(rule) {
+        this.routingRules.push(rule);
+        // 重新排序
+        this.routingRules.sort((a, b) => a.priority - b.priority);
+    }
+    /**
+     * 移除路由规则
+     */
+    removeRoutingRule(pattern, method) {
+        const index = this.routingRules.findIndex(rule => rule.pathPattern.source === pattern && rule.method === method);
+        if (index >= 0) {
+            this.routingRules.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * 获取所有路由规则
+     */
+    getRoutingRules() {
+        return [...this.routingRules];
+    }
+    /**
+     * 获取端点处理器
+     */
+    getHandler(endpoint) {
+        return this.handlers.get(endpoint);
+    }
+    /**
+     * 获取所有端点处理器
+     */
+    getAllHandlers() {
+        return new Map(this.handlers);
+    }
+    /**
+     * 更新端点配置
+     */
+    updateEndpointConfig(endpoint, config) {
+        const handler = this.handlers.get(endpoint);
+        if (handler) {
+            handler.updateConfig(config);
+        }
+    }
+    /**
+     * 启用/禁用端点
+     */
+    setEndpointEnabled(endpoint, enabled) {
+        this.updateEndpointConfig(endpoint, { enabled });
+    }
+    /**
+     * 健康检查所有端点
+     */
+    async healthCheck() {
+        const results = {};
+        for (const [endpoint, handler] of this.handlers) {
+            try {
+                results[endpoint] = await handler.healthCheck();
+            }
+            catch (error) {
+                results[endpoint] = false;
+            }
+        }
+        return results;
+    }
+    /**
+     * 获取路由统计信息
+     */
+    getRoutingStats() {
+        const endpointStatus = {};
+        let enabledCount = 0;
+        for (const [endpoint, handler] of this.handlers) {
+            const status = handler.getEndpointInfo().enabled;
+            endpointStatus[endpoint] = status;
+            if (status)
+                enabledCount++;
+        }
+        return {
+            totalEndpoints: this.handlers.size,
+            enabledEndpoints: enabledCount,
+            totalRules: this.routingRules.length,
+            endpointStatus: endpointStatus
+        };
+    }
+    /**
+     * 初始化路由器
+     */
+    async initialize() {
+        console.log('EndpointRouter initialized');
+    }
+    /**
+     * 启动路由器
+     */
+    async start() {
+        console.log('EndpointRouter started');
+    }
+    /**
+     * 停止路由器
+     */
+    async stop() {
+        console.log('EndpointRouter stopped');
+    }
+    /**
+     * 销毁路由器
+     */
+    async destroy() {
+        // 清理所有处理器
+        for (const handler of this.handlers.values()) {
+            // 如果处理器有清理方法，调用它
+            if ('destroy' in handler && typeof handler.destroy === 'function') {
+                await handler.destroy();
+            }
+        }
+        this.handlers.clear();
+        this.routingRules.length = 0;
+        console.log('EndpointRouter destroyed');
+    }
+}

package/dist/endpoints/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 端点处理器模块导出
+ */
+export { BaseEndpointHandler } from './base-endpoint-handler.js';
+export type { EndpointHandlerConfig } from './base-endpoint-handler.js';
+export { ChatEndpointHandler } from './chat-endpoint-handler.js';
+export type { ChatRequest, ChatResponse } from './chat-endpoint-handler.js';
+export { ResponsesEndpointHandler } from './responses-endpoint-handler.js';
+export type { ResponsesRequest, ResponsesResponse } from './responses-endpoint-handler.js';
+export { MessagesEndpointHandler } from './messages-endpoint-handler.js';
+export type { MessagesRequest, MessagesResponse } from './messages-endpoint-handler.js';
+export { EndpointRouter } from './endpoint-router.js';
+export type { RouterConfig, RoutingRule } from './endpoint-router.js';

package/dist/endpoints/index.js

@@ -0,0 +1,11 @@
+/**
+ * 端点处理器模块导出
+ */
+// 基础处理器
+export { BaseEndpointHandler } from './base-endpoint-handler.js';
+// 具体端点处理器
+export { ChatEndpointHandler } from './chat-endpoint-handler.js';
+export { ResponsesEndpointHandler } from './responses-endpoint-handler.js';
+export { MessagesEndpointHandler } from './messages-endpoint-handler.js';
+// 端点路由器
+export { EndpointRouter } from './endpoint-router.js';

package/dist/endpoints/messages-endpoint-handler.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Messages端点处理器
+ *
+ * 处理/v1/messages端点的请求和响应 (Anthropic Messages API)
+ */
+import type { LLMSwitchHookContext, LLMSwitchProcessingResult, ProcessingMode, SSEEvent } from '../api/llmswitch-types.js';
+import { BaseEndpointHandler } from './base-endpoint-handler.js';
+import type { HooksIntegration } from '../hooks/hooks-integration.js';
+/**
+ * Anthropic Messages请求接口
+ */
+export interface MessagesRequest {
+    model: string;
+    messages: Array<{
+        role: 'user' | 'assistant';
+        content: string | Array<{
+            type: 'text' | 'image';
+            text?: string;
+            source?: {
+                type: 'base64';
+                media_type: string;
+                data: string;
+            };
+        }>;
+    }>;
+    system?: string;
+    max_tokens: number;
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    stop_sequences?: string[];
+    stream?: boolean;
+    tools?: any[];
+    tool_choice?: any;
+    metadata?: any;
+}
+/**
+ * Anthropic Messages响应接口
+ */
+export interface MessagesResponse {
+    id: string;
+    type: 'message';
+    role: 'assistant';
+    content: Array<{
+        type: 'text' | 'tool_use' | 'tool_result';
+        text?: string;
+        id?: string;
+        name?: string;
+        input?: any;
+        content?: any;
+        is_error?: boolean;
+    }>;
+    model: string;
+    stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use';
+    stop_sequence?: string | null;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+    error?: any;
+}
+/**
+ * Messages请求格式 (Anthropic)
+ */
+export interface MessagesRequest {
+    model: string;
+    messages: Array<{
+        role: 'user' | 'assistant';
+        content: string | Array<{
+            type: 'text' | 'image';
+            text?: string;
+            source?: {
+                type: 'base64';
+                media_type: string;
+                data: string;
+            };
+        }>;
+    }>;
+    system?: string;
+    max_tokens: number;
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    stop_sequences?: string[];
+    stream?: boolean;
+    tools?: any[];
+    tool_choice?: any;
+    metadata?: any;
+}
+/**
+ * Messages响应格式 (Anthropic)
+ */
+export interface MessagesResponse {
+    id: string;
+    type: 'message';
+    role: 'assistant';
+    content: Array<{
+        type: 'text' | 'tool_use' | 'tool_result';
+        text?: string;
+        id?: string;
+        name?: string;
+        input?: any;
+        content?: any;
+        is_error?: boolean;
+    }>;
+    model: string;
+    stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use';
+    stop_sequence?: string | null;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}
+/**
+ * Messages端点处理器
+ */
+export declare class MessagesEndpointHandler extends BaseEndpointHandler {
+    constructor(hooksAdapter: HooksIntegration);
+    /**
+     * 处理Messages端点请求预处理 - llmswitch-core只负责预处理
+     */
+    protected processEndpointRequest(request: any, context: LLMSwitchHookContext): Promise<LLMSwitchProcessingResult>;
+    /**
+     * 处理流式Messages请求
+     */
+    protected processStreamingEndpointRequest(request: any, context: LLMSwitchHookContext): AsyncIterable<SSEEvent>;
+    /**
+     * 验证Messages请求格式
+     */
+    private validateMessagesRequest;
+    /**
+     * 预处理请求 - 协议转换、工具调用规范化等
+     */
+    protected preprocessRequest(request: any, context: LLMSwitchHookContext): Promise<any>;
+    /**
+     * 规范化工具调用
+     */
+    private normalizeTools;
+    /**
+     * 规范化消息
+     */
+    private normalizeMessages;
+    /**
+     * 处理内容项
+     */
+    private processContentItems;
+    /**
+     * 验证响应格式
+     */
+    private validateResponse;
+    /**
+     * 生成模拟响应内容
+     */
+    private generateMockResponse;
+    /**
+     * 计算Token数量（使用精确计算）
+     */
+    private calculateTokens;
+    /**
+     * 计算请求的token数量（使用精确计算）
+     */
+    private calculateRequestTokens;
+    /**
+     * 生成路径标识符
+     */
+    protected generatePathIdentifier(request: any): string;
+    /**
+     * 检测处理模式
+     */
+    protected detectProcessingMode(request: any): ProcessingMode;
+}