@jsonstudio/llms 0.4.2

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

@@ -0,0 +1,115 @@
+/**
+ * Chat端点处理器
+ *
+ * 处理/v1/chat/completions端点的请求和响应
+ */
+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';
+/**
+ * Chat请求格式
+ */
+export interface ChatRequest {
+    model: string;
+    messages: Array<{
+        role: 'system' | 'user' | 'assistant' | 'tool';
+        content: string | any[];
+        tool_call_id?: string;
+        tool_calls?: any[];
+    }>;
+    tools?: any[];
+    tool_choice?: string | any;
+    temperature?: number;
+    max_tokens?: number;
+    stream?: boolean;
+    stop?: string | string[];
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    logit_bias?: Record<string, number>;
+    user?: string;
+    response_format?: any;
+    seed?: number;
+}
+/**
+ * Chat响应格式
+ */
+export interface ChatResponse {
+    id: string;
+    object: 'chat.completion' | 'chat.completion.chunk';
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        message?: {
+            role: 'assistant';
+            content?: string;
+            tool_calls?: any[];
+        };
+        delta?: {
+            role?: string;
+            content?: string;
+            tool_calls?: any[];
+        };
+        finish_reason?: 'stop' | 'length' | 'tool_calls' | 'content_filter';
+    }>;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+/**
+ * Chat端点处理器
+ */
+export declare class ChatEndpointHandler extends BaseEndpointHandler {
+    constructor(hooksAdapter: HooksIntegration);
+    /**
+     * 处理Chat端点请求预处理 - llmswitch-core只负责预处理
+     */
+    protected processEndpointRequest(request: ChatRequest, context: LLMSwitchHookContext): Promise<LLMSwitchProcessingResult>;
+    /**
+     * 验证Chat请求格式
+     */
+    private validateChatRequest;
+    /**
+     * 预处理请求 - 工具调用规范化、协议转换等
+     */
+    private preprocessChatRequest;
+    /**
+     * 处理流式请求预处理 - 生成预处理后的流式请求
+     */
+    protected processStreamingEndpointRequest(request: ChatRequest, context: LLMSwitchHookContext): AsyncIterable<SSEEvent>;
+    /**
+     * 规范化工具调用
+     */
+    private normalizeTools;
+    /**
+     * 规范化消息
+     */
+    private normalizeMessages;
+    /**
+     * 处理工具调用结果
+     */
+    private processToolCallResults;
+    /**
+     * 验证响应格式
+     */
+    private validateResponse;
+    /**
+     * 估算Token数量
+     */
+    private estimateTokens;
+    /**
+     * 计算请求的token数量
+     */
+    private calculateRequestTokens;
+    /**
+     * 生成路径标识符
+     */
+    protected generatePathIdentifier(request: ChatRequest): string;
+    /**
+     * 检测处理模式
+     */
+    protected detectProcessingMode(request: ChatRequest): ProcessingMode;
+}

package/dist/endpoints/chat-endpoint-handler.js

@@ -0,0 +1,218 @@
+/**
+ * Chat端点处理器
+ *
+ * 处理/v1/chat/completions端点的请求和响应
+ */
+import { BaseEndpointHandler } from './base-endpoint-handler.js';
+import { TokenCounter } from '../utils/token-counter.js';
+import { RequestLogicProcessor } from '../utils/request-processor.js';
+/**
+ * Chat端点处理器
+ */
+export class ChatEndpointHandler extends BaseEndpointHandler {
+    constructor(hooksAdapter) {
+        const config = {
+            endpoint: 'chat',
+            protocol: 'openai-chat',
+            enabled: true,
+            sse: {
+                enabled: true,
+                accumulateMs: 500,
+                maxEvents: 100,
+                timeout: 30000
+            },
+            hooks: {
+                enabled: true,
+                stages: [
+                    'request_1_validation_pre',
+                    'request_1_validation_post',
+                    'request_2_routing_pre',
+                    'request_2_routing_post',
+                    'request_3_conversion_pre',
+                    'request_3_conversion_post',
+                    'request_4_tools_pre',
+                    'request_4_tools_post',
+                    'request_5_sse_pre',
+                    'request_5_sse_post',
+                    'request_6_snapshot_pre',
+                    'request_6_snapshot_post',
+                    'request_7_monitoring_pre',
+                    'request_7_monitoring_post',
+                    'request_8_validation_pre',
+                    'request_8_validation_post',
+                    'response_1_receive_pre',
+                    'response_1_receive_post',
+                    'response_2_conversion_pre',
+                    'response_2_conversion_post',
+                    'response_3_tools_pre',
+                    'response_3_tools_post',
+                    'response_4_sse_pre',
+                    'response_4_sse_post',
+                    'response_5_formatting_pre',
+                    'response_5_formatting_post',
+                    'response_6_snapshot_pre',
+                    'response_6_snapshot_post',
+                    'response_7_quality_pre',
+                    'response_7_quality_post',
+                    'response_8_monitoring_pre',
+                    'response_8_monitoring_post'
+                ],
+                timeout: 5000
+            },
+            conversion: {
+                autoDetect: true,
+                fallbackToOriginal: true
+            }
+        };
+        super(config, hooksAdapter);
+    }
+    /**
+     * 处理Chat端点请求预处理 - llmswitch-core只负责预处理
+     */
+    async processEndpointRequest(request, context) {
+        const startTime = Date.now();
+        try {
+            // 1. 验证请求格式
+            this.validateChatRequest(request);
+            // 2. 预处理请求（工具调用规范化、协议转换等）
+            const processedRequest = await this.preprocessChatRequest(request, context);
+            // 3. 返回预处理后的请求，传递给workflow
+            return {
+                success: true,
+                data: processedRequest, // 预处理后的请求，给workflow处理
+                executionTime: Date.now() - startTime,
+                metadata: {
+                    endpoint: 'chat',
+                    originalProtocol: this.config.protocol,
+                    targetProtocol: this.config.protocol,
+                    processingMode: context.processingMode,
+                    stage: 'chat_request_preprocessing_completed'
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error,
+                executionTime: Date.now() - startTime,
+                metadata: {
+                    endpoint: 'chat',
+                    originalProtocol: this.config.protocol,
+                    targetProtocol: this.config.protocol,
+                    processingMode: context.processingMode,
+                    stage: 'chat_request_preprocessing_failed'
+                }
+            };
+        }
+    }
+    /**
+     * 验证Chat请求格式
+     */
+    validateChatRequest(request) {
+        // 验证请求格式（V2）
+        const validation = RequestLogicProcessor.validateRequest(request, 'chat');
+        if (!validation.valid) {
+            throw new Error(`Chat请求验证失败: ${validation.errors.join(', ')}`);
+        }
+    }
+    /**
+     * 预处理请求 - 工具调用规范化、协议转换等
+     */
+    async preprocessChatRequest(request, context) {
+        // 使用V2逻辑处理请求规范化
+        return RequestLogicProcessor.normalizeChatRequest(request);
+    }
+    /**
+     * 处理流式请求预处理 - 生成预处理后的流式请求
+     */
+    async *processStreamingEndpointRequest(request, context) {
+        // 验证请求格式
+        this.validateChatRequest(request);
+        // 预处理请求
+        const processedRequest = await this.preprocessRequest(request, context);
+        // 生成预处理完成事件，将处理后的请求传递给workflow
+        yield {
+            id: `chat_preprocess_${Date.now()}`,
+            event: 'request_preprocessed',
+            data: JSON.stringify({
+                endpoint: 'chat',
+                stage: 'preprocessing_completed',
+                processedRequest: processedRequest,
+                metadata: {
+                    originalProtocol: this.config.protocol,
+                    targetProtocol: this.config.protocol,
+                    processingMode: 'streaming'
+                }
+            }),
+            timestamp: Date.now()
+        };
+    }
+    /**
+     * 规范化工具调用
+     */
+    async normalizeTools(request) {
+        // 这里可以实现工具调用的规范化逻辑
+        // 例如：参数验证、格式转换等
+        return request;
+    }
+    /**
+     * 规范化消息
+     */
+    async normalizeMessages(request) {
+        // 这里可以实现消息的规范化逻辑
+        // 例如：内容清理、格式转换等
+        return request;
+    }
+    /**
+     * 处理工具调用结果
+     */
+    async processToolCallResults(response) {
+        // 这里可以实现工具调用结果的处理逻辑
+        return response;
+    }
+    /**
+     * 验证响应格式
+     */
+    validateResponse(response) {
+        if (!response.id) {
+            throw new Error('Response missing required field: id');
+        }
+        if (!response.object) {
+            throw new Error('Response missing required field: object');
+        }
+        if (!response.choices || !Array.isArray(response.choices) || response.choices.length === 0) {
+            throw new Error('Response missing required field: choices');
+        }
+    }
+    /**
+     * 估算Token数量
+     */
+    estimateTokens(text) {
+        return TokenCounter.estimateTokens(text);
+    }
+    /**
+     * 计算请求的token数量
+     */
+    calculateRequestTokens(request) {
+        const { inputTokens, toolTokens } = TokenCounter.estimateRequestTokens(request);
+        return inputTokens + (toolTokens || 0);
+    }
+    /**
+     * 生成路径标识符
+     */
+    generatePathIdentifier(request) {
+        // 使用模型名和消息数量生成标识符
+        const messageCount = request.messages?.length || 0;
+        const toolCount = request.tools?.length || 0;
+        return `chat-${request.model.replace(/[^a-zA-Z0-9]/g, '-')}-${messageCount}msg-${toolCount}tools`;
+    }
+    /**
+     * 检测处理模式
+     */
+    detectProcessingMode(request) {
+        if (request.stream === true) {
+            return 'streaming';
+        }
+        return 'non-streaming';
+    }
+}

package/dist/endpoints/endpoint-router.d.ts

@@ -0,0 +1,127 @@
+/**
+ * 端点路由器
+ *
+ * 根据请求路径和协议自动路由到对应的端点处理器
+ */
+import type { EndpointType, ProtocolType, LLMSwitchProcessingResult, SSEEvent } from '../api/llmswitch-types.js';
+import type { EndpointHandlerConfig } from './base-endpoint-handler.js';
+import type { HooksIntegration } from '../hooks/hooks-integration.js';
+import { BaseEndpointHandler } from './base-endpoint-handler.js';
+/**
+ * 路由配置
+ */
+export interface RouterConfig {
+    defaultEndpoint: EndpointType;
+    endpointConfigs: Record<EndpointType, EndpointHandlerConfig>;
+    autoDetect: boolean;
+    fallbackEnabled: boolean;
+}
+/**
+ * 路由规则
+ */
+export interface RoutingRule {
+    pathPattern: RegExp;
+    method: string;
+    endpoint: EndpointType;
+    protocol: ProtocolType;
+    priority: number;
+}
+/**
+ * 端点路由器
+ */
+export declare class EndpointRouter {
+    private handlers;
+    private routingRules;
+    private hooksAdapter;
+    private config;
+    constructor(hooksAdapter: HooksIntegration, config: RouterConfig);
+    /**
+     * 路由请求到对应端点
+     */
+    routeRequest(path: string, method: string, request: any, headers?: Record<string, string>): Promise<LLMSwitchProcessingResult>;
+    /**
+     * 路由流式请求
+     */
+    routeStreamingRequest(path: string, method: string, request: any, headers?: Record<string, string>): Promise<AsyncIterable<SSEEvent>>;
+    /**
+     * 检测端点类型
+     */
+    private detectEndpoint;
+    /**
+     * 从请求结构检测端点
+     */
+    private detectEndpointFromRequestStructure;
+    /**
+     * 执行自动检测
+     */
+    private performAutoDetection;
+    /**
+     * 初始化处理器
+     */
+    private initializeHandlers;
+    /**
+     * 初始化路由规则
+     */
+    private initializeRoutingRules;
+    /**
+     * 提取请求ID
+     */
+    private extractRequestId;
+    /**
+     * 添加路由规则
+     */
+    addRoutingRule(rule: RoutingRule): void;
+    /**
+     * 移除路由规则
+     */
+    removeRoutingRule(pattern: string, method: string): boolean;
+    /**
+     * 获取所有路由规则
+     */
+    getRoutingRules(): RoutingRule[];
+    /**
+     * 获取端点处理器
+     */
+    getHandler(endpoint: EndpointType): BaseEndpointHandler | undefined;
+    /**
+     * 获取所有端点处理器
+     */
+    getAllHandlers(): Map<EndpointType, BaseEndpointHandler>;
+    /**
+     * 更新端点配置
+     */
+    updateEndpointConfig(endpoint: EndpointType, config: Partial<EndpointHandlerConfig>): void;
+    /**
+     * 启用/禁用端点
+     */
+    setEndpointEnabled(endpoint: EndpointType, enabled: boolean): void;
+    /**
+     * 健康检查所有端点
+     */
+    healthCheck(): Promise<Record<EndpointType, boolean>>;
+    /**
+     * 获取路由统计信息
+     */
+    getRoutingStats(): {
+        totalEndpoints: number;
+        enabledEndpoints: number;
+        totalRules: number;
+        endpointStatus: Record<EndpointType, boolean>;
+    };
+    /**
+     * 初始化路由器
+     */
+    initialize(): Promise<void>;
+    /**
+     * 启动路由器
+     */
+    start(): Promise<void>;
+    /**
+     * 停止路由器
+     */
+    stop(): Promise<void>;
+    /**
+     * 销毁路由器
+     */
+    destroy(): Promise<void>;
+}