@jsonstudio/llms 0.4.2 → 0.4.4

package/dist/endpoints/endpoint-router.js

@@ -1,438 +0,0 @@
-/**
- * 端点路由器
- *
- * 根据请求路径和协议自动路由到对应的端点处理器
- */
-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

@@ -1,13 +0,0 @@
-/**
- * 端点处理器模块导出
- */
-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

@@ -1,11 +0,0 @@
-/**
- * 端点处理器模块导出
- */
-// 基础处理器
-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

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