@jsonstudio/llms 0.4.3 → 0.4.5

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

@@ -1,115 +0,0 @@
-/**
- * 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

@@ -1,218 +0,0 @@
-/**
- * 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

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