@jsonstudio/llms 0.4.2

package/dist/core/llmswitch-factory-v2.d.ts

@@ -0,0 +1,123 @@
+/**
+ * LLMSwitch V2 工厂类
+ *
+ * 提供创建和配置LLMSwitch V2实例的工厂方法
+ */
+import type { LLMSwitchV2Config } from '../api/llmswitch-types.js';
+import { LLMSwitchEngineV2 } from './llmswitch-engine-v2.js';
+/**
+ * LLMSwitch V2 工厂类
+ */
+export declare class LLMSwitchFactoryV2 {
+    private static instances;
+    private static defaultInstance;
+    /**
+     * 创建LLMSwitch V2实例
+     */
+    static create(config?: Partial<LLMSwitchV2Config>, instanceId?: string): Promise<LLMSwitchEngineV2>;
+    /**
+     * 获取默认实例
+     */
+    static getDefault(): Promise<LLMSwitchEngineV2>;
+    /**
+     * 获取指定实例
+     */
+    static getInstance(instanceId: string): Promise<LLMSwitchEngineV2>;
+    /**
+     * 创建多个实例
+     */
+    static createMultiple(configs: Array<{
+        id: string;
+        config: Partial<LLMSwitchV2Config>;
+    }>): Promise<Map<string, LLMSwitchEngineV2>>;
+    /**
+     * 从配置文件创建实例
+     */
+    static fromConfigFile(configPath: string): Promise<LLMSwitchEngineV2>;
+    /**
+     * 从环境变量创建实例
+     */
+    static fromEnvironment(): Promise<LLMSwitchEngineV2>;
+    /**
+     * 创建开发环境实例
+     */
+    static createDevelopment(): Promise<LLMSwitchEngineV2>;
+    /**
+     * 创建生产环境实例
+     */
+    static createProduction(): Promise<LLMSwitchEngineV2>;
+    /**
+     * 创建测试环境实例
+     */
+    static createTest(): Promise<LLMSwitchEngineV2>;
+    /**
+     * 销毁指定实例
+     */
+    static destroy(instanceId: string): Promise<void>;
+    /**
+     * 销毁所有实例
+     */
+    static destroyAll(): Promise<void>;
+    /**
+     * 获取所有实例状态
+     */
+    static getInstancesStatus(): Promise<Array<{
+        id: string;
+        healthy: boolean;
+        uptime: number;
+        metrics: any;
+    }>>;
+    /**
+     * 重新加载配置
+     */
+    static reloadConfig(instanceId: string, newConfig: Partial<LLMSwitchV2Config>): Promise<LLMSwitchEngineV2>;
+    /**
+     * 克隆实例
+     */
+    static cloneInstance(sourceId: string, targetId?: string): Promise<LLMSwitchEngineV2>;
+    /**
+     * 批量健康检查
+     */
+    static healthCheckAll(): Promise<Map<string, boolean>>;
+    /**
+     * 批量重启不健康的实例
+     */
+    static restartUnhealthy(): Promise<number>;
+    /**
+     * 获取实例统计信息
+     */
+    static getStats(): {
+        totalInstances: number;
+        runningInstances: number;
+        instanceIds: string[];
+        memoryUsage?: NodeJS.MemoryUsage;
+    };
+    /**
+     * 私有方法：合并配置
+     */
+    private static mergeConfig;
+    /**
+     * 私有方法：深度合并对象
+     */
+    private static deepMerge;
+}
+/**
+ * 便捷创建函数
+ */
+export declare function createLLMSwitchV2(config?: Partial<LLMSwitchV2Config>, instanceId?: string): Promise<LLMSwitchEngineV2>;
+/**
+ * 便捷创建函数：开发环境
+ */
+export declare function createLLMSwitchV2Development(): Promise<LLMSwitchEngineV2>;
+/**
+ * 便捷创建函数：生产环境
+ */
+export declare function createLLMSwitchV2Production(): Promise<LLMSwitchEngineV2>;
+/**
+ * 便捷创建函数：测试环境
+ */
+export declare function createLLMSwitchV2Test(): Promise<LLMSwitchEngineV2>;
+/**
+ * 便捷函数：获取默认实例
+ */
+export declare function getDefaultLLMSwitchV2(): Promise<LLMSwitchEngineV2>;

package/dist/core/llmswitch-factory-v2.js

@@ -0,0 +1,521 @@
+/**
+ * LLMSwitch V2 工厂类
+ *
+ * 提供创建和配置LLMSwitch V2实例的工厂方法
+ */
+import { DEFAULT_LLSWITCH_CONFIG, validateLLMSwitchConfig } from '../api/llmswitch-config.js';
+import { LLMSwitchEngineV2 } from './llmswitch-engine-v2.js';
+import { ErrorHandler, ErrorFactory } from '../utils/error-utils.js';
+/**
+ * LLMSwitch V2 工厂类
+ */
+export class LLMSwitchFactoryV2 {
+    static instances = new Map();
+    static defaultInstance = null;
+    /**
+     * 创建LLMSwitch V2实例
+     */
+    static async create(config = {}, instanceId) {
+        const id = instanceId || 'default';
+        // 验证配置
+        const fullConfig = this.mergeConfig(config);
+        const validation = validateLLMSwitchConfig(fullConfig);
+        if (!validation.valid) {
+            throw ErrorFactory.configurationError(`Invalid configuration: ${validation.errors.join(', ')}`, undefined, { validationErrors: validation.errors });
+        }
+        if (validation.warnings.length > 0) {
+            console.warn('Configuration warnings:', validation.warnings);
+        }
+        // 创建实例
+        const instance = new LLMSwitchEngineV2(fullConfig);
+        // 初始化实例
+        await instance.initialize();
+        await instance.start();
+        // 缓存实例
+        this.instances.set(id, instance);
+        // 设置默认实例
+        if (id === 'default') {
+            this.defaultInstance = instance;
+        }
+        console.log(`LLMSwitch V2 instance created: ${id}`);
+        return instance;
+    }
+    /**
+     * 获取默认实例
+     */
+    static async getDefault() {
+        if (!this.defaultInstance) {
+            this.defaultInstance = await this.create();
+        }
+        return this.defaultInstance;
+    }
+    /**
+     * 获取指定实例
+     */
+    static async getInstance(instanceId) {
+        let instance = this.instances.get(instanceId);
+        if (!instance) {
+            instance = await this.create(undefined, instanceId);
+        }
+        return instance;
+    }
+    /**
+     * 创建多个实例
+     */
+    static async createMultiple(configs) {
+        const instances = new Map();
+        for (const { id, config } of configs) {
+            try {
+                const instance = await this.create(config, id);
+                instances.set(id, instance);
+            }
+            catch (error) {
+                const handledError = ErrorHandler.handle(error, {
+                    stage: 'factory_create_multiple',
+                    endpoint: id
+                });
+                console.error(`Failed to create instance ${id}:`, handledError);
+                throw handledError;
+            }
+        }
+        return instances;
+    }
+    /**
+     * 从配置文件创建实例
+     */
+    static async fromConfigFile(configPath) {
+        try {
+            const fs = await import('fs/promises');
+            const path = await import('path');
+            const configData = await fs.readFile(path.resolve(configPath), 'utf-8');
+            const config = JSON.parse(configData);
+            return await this.create(config);
+        }
+        catch (error) {
+            throw ErrorHandler.handle(error, {
+                requestId: `config-load-${Date.now()}`,
+                stage: 'factory_from_config_file'
+            });
+        }
+    }
+    /**
+     * 从环境变量创建实例
+     */
+    static async fromEnvironment() {
+        const config = {};
+        // 从环境变量读取配置
+        if (process.env.LLSWITCH_DEBUG) {
+            config.enabled = process.env.LLSWITCH_DEBUG === 'true';
+        }
+        if (process.env.LLSWITCH_DEFAULT_PROTOCOL) {
+            config.defaultProtocol = process.env.LLSWITCH_DEFAULT_PROTOCOL;
+        }
+        // 性能配置
+        if (process.env.LLSWITCH_MAX_CONCURRENT_REQUESTS) {
+            config.performance = {
+                maxConcurrentRequests: parseInt(process.env.LLSWITCH_MAX_CONCURRENT_REQUESTS),
+                requestTimeout: parseInt(process.env.LLSWITCH_REQUEST_TIMEOUT || '30000'),
+                responseTimeout: parseInt(process.env.LLSWITCH_RESPONSE_TIMEOUT || '60000'),
+                processingTimeout: parseInt(process.env.LLSWITCH_PROCESSING_TIMEOUT || '45000'),
+                retryAttempts: parseInt(process.env.LLSWITCH_RETRY_ATTEMPTS || '3'),
+                retryDelay: parseInt(process.env.LLSWITCH_RETRY_DELAY || '1000')
+            };
+        }
+        // 快照配置
+        if (process.env.LLSWITCH_SNAPSHOT_PATH) {
+            config.hooks = {
+                enabled: true,
+                stages: [],
+                snapshot: {
+                    enabled: true,
+                    basePath: process.env.LLSWITCH_SNAPSHOT_PATH,
+                    endpointIsolation: {
+                        enabled: true,
+                        pathStructure: 'endpoint/request'
+                    },
+                    pathGeneration: {
+                        includeRequestId: process.env.LLSWITCH_INCLUDE_REQUEST_ID === 'true',
+                        includeStage: process.env.LLSWITCH_INCLUDE_STAGE === 'true',
+                        includeTimestamp: process.env.LLSWITCH_INCLUDE_TIMESTAMP === 'true'
+                    },
+                    format: process.env.LLSWITCH_SNAPSHOT_FORMAT || 'json',
+                    compression: process.env.LLSWITCH_SNAPSHOT_COMPRESSION || 'gzip',
+                    retention: {
+                        maxFiles: parseInt(process.env.LLSWITCH_SNAPSHOT_MAX_FILES || '1000'),
+                        maxAge: parseInt(process.env.LLSWITCH_SNAPSHOT_MAX_AGE || '604800000')
+                    }
+                }
+            };
+        }
+        return await this.create(config);
+    }
+    /**
+     * 创建开发环境实例
+     */
+    static async createDevelopment() {
+        const devConfig = {
+            enabled: true,
+            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'
+                ],
+                snapshot: {
+                    enabled: true,
+                    level: 'verbose',
+                    basePath: '~/.routecodex/snapshots/llmswitch-core/dev',
+                    endpointIsolation: {
+                        enabled: true,
+                        pathStructure: 'endpoint/request'
+                    },
+                    pathGeneration: {
+                        includeRequestId: true,
+                        includeStage: true,
+                        includeTimestamp: true
+                    },
+                    format: 'json',
+                    compression: 'none',
+                    retention: {
+                        maxFiles: 100,
+                        maxAge: 86400000 // 1天
+                    }
+                }
+            },
+            performance: {
+                maxConcurrentRequests: 10,
+                requestTimeout: 10000,
+                responseTimeout: 20000,
+                processingTimeout: 15000,
+                retryAttempts: 1,
+                retryDelay: 500
+            }
+        };
+        return await this.create(devConfig, 'development');
+    }
+    /**
+     * 创建生产环境实例
+     */
+    static async createProduction() {
+        const prodConfig = {
+            enabled: true,
+            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'
+                ],
+                snapshot: {
+                    enabled: false,
+                    basePath: '~/.routecodex/snapshots/llmswitch-core/prod',
+                    endpointIsolation: {
+                        enabled: true,
+                        pathStructure: 'endpoint/request'
+                    },
+                    pathGeneration: {
+                        includeRequestId: true,
+                        includeStage: true,
+                        includeTimestamp: true
+                    },
+                    format: 'json',
+                    compression: 'gzip',
+                    retention: {
+                        maxFiles: 10000,
+                        maxAge: 2592000000 // 30天
+                    }
+                }
+            },
+            performance: {
+                maxConcurrentRequests: 200,
+                requestTimeout: 60000,
+                responseTimeout: 120000,
+                processingTimeout: 90000,
+                retryAttempts: 5,
+                retryDelay: 2000
+            }
+        };
+        return await this.create(prodConfig, 'production');
+    }
+    /**
+     * 创建测试环境实例
+     */
+    static async createTest() {
+        const testConfig = {
+            enabled: true,
+            hooks: {
+                enabled: false, // 测试环境可以关闭hooks
+                stages: [],
+                snapshot: {
+                    enabled: false,
+                    basePath: '~/.routecodex/snapshots/llmswitch-core/test',
+                    endpointIsolation: {
+                        enabled: true,
+                        pathStructure: 'endpoint/request'
+                    },
+                    pathGeneration: {
+                        includeRequestId: false,
+                        includeStage: false,
+                        includeTimestamp: false
+                    },
+                    format: 'json',
+                    compression: 'none',
+                    retention: {
+                        maxFiles: 10,
+                        maxAge: 3600000 // 1小时
+                    }
+                }
+            },
+            performance: {
+                maxConcurrentRequests: 5,
+                requestTimeout: 5000,
+                responseTimeout: 10000,
+                processingTimeout: 7500,
+                retryAttempts: 0,
+                retryDelay: 0
+            }
+        };
+        return await this.create(testConfig, 'test');
+    }
+    /**
+     * 销毁指定实例
+     */
+    static async destroy(instanceId) {
+        const instance = this.instances.get(instanceId);
+        if (instance) {
+            await instance.shutdown();
+            this.instances.delete(instanceId);
+            if (this.defaultInstance === instance) {
+                this.defaultInstance = null;
+            }
+            console.log(`LLMSwitch V2 instance destroyed: ${instanceId}`);
+        }
+    }
+    /**
+     * 销毁所有实例
+     */
+    static async destroyAll() {
+        const destroyPromises = Array.from(this.instances.keys()).map(id => this.destroy(id));
+        await Promise.all(destroyPromises);
+        this.instances.clear();
+        this.defaultInstance = null;
+        console.log('All LLMSwitch V2 instances destroyed');
+    }
+    /**
+     * 获取所有实例状态
+     */
+    static async getInstancesStatus() {
+        const statusPromises = Array.from(this.instances.entries()).map(async ([id, instance]) => {
+            try {
+                const health = await instance.healthCheck();
+                const metrics = instance.getMetrics();
+                return {
+                    id,
+                    healthy: health.healthy,
+                    uptime: health.uptime,
+                    metrics
+                };
+            }
+            catch (error) {
+                return {
+                    id,
+                    healthy: false,
+                    uptime: 0,
+                    metrics: null
+                };
+            }
+        });
+        return Promise.all(statusPromises);
+    }
+    /**
+     * 重新加载配置
+     */
+    static async reloadConfig(instanceId, newConfig) {
+        // 销毁旧实例
+        await this.destroy(instanceId);
+        // 创建新实例
+        return await this.create(newConfig, instanceId);
+    }
+    /**
+     * 克隆实例
+     */
+    static async cloneInstance(sourceId, targetId) {
+        const sourceInstance = this.instances.get(sourceId);
+        if (!sourceInstance) {
+            throw ErrorFactory.endpointNotFound(sourceId, {
+                availableInstances: Array.from(this.instances.keys()),
+                operation: 'clone_instance'
+            });
+        }
+        const sourceConfig = sourceInstance.getConfig();
+        return await this.create(sourceConfig, targetId);
+    }
+    /**
+     * 批量健康检查
+     */
+    static async healthCheckAll() {
+        const healthResults = new Map();
+        for (const [id, instance] of this.instances) {
+            try {
+                const health = await instance.healthCheck();
+                healthResults.set(id, health.healthy);
+            }
+            catch (error) {
+                healthResults.set(id, false);
+                console.error(`Health check failed for instance ${id}:`, error);
+            }
+        }
+        return healthResults;
+    }
+    /**
+     * 批量重启不健康的实例
+     */
+    static async restartUnhealthy() {
+        const healthResults = await this.healthCheckAll();
+        const unhealthyIds = Array.from(healthResults.entries()).filter(([_, healthy]) => !healthy);
+        let restartedCount = 0;
+        for (const [id] of unhealthyIds) {
+            try {
+                await this.reloadConfig(id, this.instances.get(id)?.getConfig() || {});
+                restartedCount++;
+                console.log(`Restarted unhealthy instance: ${id}`);
+            }
+            catch (error) {
+                console.error(`Failed to restart instance ${id}:`, error);
+            }
+        }
+        return restartedCount;
+    }
+    /**
+     * 获取实例统计信息
+     */
+    static getStats() {
+        const stats = {
+            totalInstances: this.instances.size,
+            runningInstances: 0,
+            instanceIds: Array.from(this.instances.keys())
+        };
+        // 尝试获取内存使用情况
+        try {
+            if (typeof process !== 'undefined' && process.memoryUsage) {
+                stats.memoryUsage = process.memoryUsage();
+            }
+        }
+        catch (error) {
+            // 忽略内存使用获取错误
+        }
+        return stats;
+    }
+    /**
+     * 私有方法：合并配置
+     */
+    static mergeConfig(userConfig) {
+        const defaultConfig = DEFAULT_LLSWITCH_CONFIG;
+        // 深度合并配置
+        return this.deepMerge(defaultConfig, userConfig);
+    }
+    /**
+     * 私有方法：深度合并对象
+     */
+    static deepMerge(target, source) {
+        const result = { ...target };
+        for (const key in source) {
+            if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+                result[key] = this.deepMerge(target[key] || {}, source[key]);
+            }
+            else {
+                result[key] = source[key];
+            }
+        }
+        return result;
+    }
+}
+/**
+ * 便捷创建函数
+ */
+export async function createLLMSwitchV2(config, instanceId) {
+    return LLMSwitchFactoryV2.create(config, instanceId);
+}
+/**
+ * 便捷创建函数：开发环境
+ */
+export async function createLLMSwitchV2Development() {
+    return LLMSwitchFactoryV2.createDevelopment();
+}
+/**
+ * 便捷创建函数：生产环境
+ */
+export async function createLLMSwitchV2Production() {
+    return LLMSwitchFactoryV2.createProduction();
+}
+/**
+ * 便捷创建函数：测试环境
+ */
+export async function createLLMSwitchV2Test() {
+    return LLMSwitchFactoryV2.createTest();
+}
+/**
+ * 便捷函数：获取默认实例
+ */
+export async function getDefaultLLMSwitchV2() {
+    return LLMSwitchFactoryV2.getDefault();
+}