@scenemesh/entity-engine-aimodule 1.0.0 → 1.0.1

package/dist/core/ai-provider.js

@@ -0,0 +1,707 @@
+/**
+ * AI Provider and Model Management
+ *
+ * Manages custom providers, model registry, and global configuration.
+ * Includes model aliases, settings, and limitations.
+ */
+import { EventEmitter } from 'events';
+import { customProvider, wrapLanguageModel, createProviderRegistry, defaultSettingsMiddleware } from 'ai';
+// Core Provider Management Class
+/**
+ * AI Provider Management Integration Class
+ */
+export class AIProviderManagement extends EventEmitter {
+    constructor() {
+        super();
+        this.initialized = false;
+        this.registry = null;
+        this.customProviders = new Map();
+        this.modelAliases = new Map();
+        this.healthStatus = new Map();
+        this.usageStats = new Map();
+        this.defaultLanguageModel = null;
+        this.defaultEmbeddingModel = null;
+        this.globalProvider = null;
+        // 新增：嵌入和设置管理相关属性
+        this.embeddingModelConfigs = new Map();
+        this.modelSettingsPresets = new Map();
+        // 延迟初始化以避免循环依赖
+        this.embeddingsIntegration = null;
+        this.settingsManagement = null;
+    }
+    /**
+     * 初始化
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        try {
+            this.emit('ai_provider:initializing');
+            // 环境变量应该在模块初始化阶段加载，不在这里处理
+            // 2. 延迟导入以避免循环依赖
+            const { AIEmbeddingsIntegration } = await import('./ai-embeddings');
+            const { AISettingsManagement } = await import('./ai-settings');
+            // 3. 初始化子系统
+            this.embeddingsIntegration = new AIEmbeddingsIntegration();
+            this.settingsManagement = new AISettingsManagement();
+            await this.embeddingsIntegration.initialize();
+            await this.settingsManagement.initialize();
+            // 4. 创建和注册默认Qwen Provider
+            await this.setupDefaultProviders();
+            this.initialized = true;
+            this.emit('ai_provider:initialized');
+        }
+        catch (error) {
+            this.emit('ai_provider:initialization_failed', { error });
+            throw error;
+        }
+    }
+    /**
+     * 设置默认提供商 - 从环境变量加载配置
+     */
+    async setupDefaultProviders() {
+        try {
+            // 检查环境变量
+            // 使用EEAI_前缀的环境变量
+            const qwenApiKey = process.env.EEAI_QWEN_API_KEY;
+            const qwenBaseUrl = process.env.EEAI_QWEN_BASE_URL || 'https://dashscope.aliyuncs.com/compatible-mode/v1';
+            if (!qwenApiKey) {
+                // 环境变量在 EntityAIModule 中加载，这里如果找不到就跳过
+                return;
+            }
+            // 导入 OpenAI Compatible Provider
+            const { createOpenAICompatible } = await import('@ai-sdk/openai-compatible');
+            // 创建Qwen Provider实例
+            const qwenProvider = createOpenAICompatible({
+                name: 'qwen',
+                baseURL: qwenBaseUrl,
+                apiKey: qwenApiKey
+            });
+            // 创建Provider Registry with Qwen
+            const registryConfig = {
+                providers: {
+                    qwen: qwenProvider
+                },
+                options: {
+                    separator: ':'
+                }
+            };
+            // 注册Provider Registry - 直接使用AI SDK的createProviderRegistry
+            this.registry = createProviderRegistry(registryConfig.providers, registryConfig.options);
+            // 设置默认语言模型
+            this.defaultLanguageModel = this.registry.languageModel('qwen:qwen-plus-2025-01-25');
+            // 尝试设置默认嵌入模型（如果Qwen支持的话）
+            try {
+                this.defaultEmbeddingModel = this.registry.textEmbeddingModel('qwen:text-embedding-v1');
+            }
+            catch {
+                // Ignore embedding model setup errors
+            }
+            this.emit('ai_provider:default_providers_setup', {
+                providers: ['qwen'],
+                defaultModel: 'qwen:qwen-plus-2025-01-25',
+                embeddingModel: 'qwen:text-embedding-v1'
+            });
+        }
+        catch (error) {
+            console.error('Failed to setup default providers:', error);
+            this.emit('ai_provider:default_providers_setup_failed', { error: error.message });
+        }
+    }
+    // Custom Providers
+    /**
+     * Create custom provider
+     */
+    createCustomProvider(id, config) {
+        if (!this.initialized) {
+            throw new Error('AIProviderManagement not initialized. Call initialize() first.');
+        }
+        try {
+            this.emit('ai_provider:custom_provider_creating', { id, config });
+            // 处理语言模型配置
+            const languageModels = {};
+            if (config.languageModels) {
+                Object.entries(config.languageModels).forEach(([modelId, modelConfig]) => {
+                    if (modelConfig && typeof modelConfig === 'object' && 'model' in modelConfig) {
+                        // 带中间件和设置的复杂配置
+                        languageModels[modelId] = wrapLanguageModel({
+                            model: modelConfig.model,
+                            middleware: modelConfig.middleware || defaultSettingsMiddleware({
+                                settings: modelConfig.settings || {}
+                            })
+                        });
+                    }
+                    else if (modelConfig) {
+                        // 简单的模型引用
+                        languageModels[modelId] = modelConfig;
+                    }
+                });
+            }
+            // 创建自定义提供商
+            const customProviderInstance = customProvider({
+                languageModels: languageModels,
+                embeddingModels: config.embeddingModels,
+                imageModels: config.imageModels,
+                fallbackProvider: config.fallbackProvider
+            });
+            this.customProviders.set(id, customProviderInstance);
+            this.emit('ai_provider:custom_provider_created', {
+                id,
+                languageModels: Object.keys(languageModels),
+                embeddingModels: Object.keys(config.embeddingModels || {}),
+                imageModels: Object.keys(config.imageModels || {}),
+                hasFallback: !!config.fallbackProvider
+            });
+            return customProviderInstance;
+        }
+        catch (error) {
+            this.emit('ai_provider:custom_provider_creation_failed', { id, error: error.message });
+            throw error;
+        }
+    }
+    /**
+     * Create model alias
+     */
+    createModelAlias(aliasConfig) {
+        const provider = this.customProviders.get(aliasConfig.providerId);
+        if (!provider) {
+            throw new Error(`Provider '${aliasConfig.providerId}' not found`);
+        }
+        this.modelAliases.set(aliasConfig.alias, aliasConfig);
+        // Create model instance
+        this.emit('ai_provider:model_alias_created', aliasConfig);
+        // Return language model instance
+        return provider.languageModel?.(aliasConfig.modelId);
+    }
+    /**
+     * Create model with predefined settings
+     */
+    createModelWithSettings(originalModel, settings) {
+        return wrapLanguageModel({
+            model: originalModel,
+            middleware: defaultSettingsMiddleware({
+                settings
+            })
+        });
+    }
+    // Provider Registry
+    /**
+     * Create provider registry
+     */
+    createProviderRegistry(config) {
+        if (!this.initialized) {
+            throw new Error('AIProviderManagement not initialized. Call initialize() first.');
+        }
+        try {
+            this.emit('ai_provider:registry_creating', {
+                providers: Object.keys(config.providers),
+                separator: config.options?.separator || ':'
+            });
+            // 创建注册表
+            this.registry = createProviderRegistry(config.providers, config.options);
+            this.emit('ai_provider:registry_created', {
+                providerCount: Object.keys(config.providers).length,
+                separator: config.options?.separator || ':'
+            });
+            return this.registry;
+        }
+        catch (error) {
+            this.emit('ai_provider:registry_creation_failed', { error: error.message });
+            throw error;
+        }
+    }
+    /**
+     * Get language model from registry
+     */
+    getLanguageModel(modelId) {
+        try {
+            // Return default model if no model ID specified
+            if (!modelId && this.defaultLanguageModel) {
+                return this.defaultLanguageModel;
+            }
+            // Use registry if available
+            if (this.registry && modelId) {
+                try {
+                    const model = this.registry.languageModel(modelId);
+                    this.recordModelUsage(modelId);
+                    return model;
+                }
+                catch (registryError) {
+                    // Registry failed, try direct provider access
+                }
+            }
+            // Try direct access from Qwen provider
+            if (modelId) {
+                const qwenProvider = this.customProviders.get('qwen');
+                if (qwenProvider && qwenProvider.languageModel) {
+                    const model = qwenProvider.languageModel(modelId);
+                    if (model) {
+                        this.recordModelUsage(modelId);
+                        return model;
+                    }
+                }
+                // Try prefixed model name (provider:model)
+                if (modelId.includes(':')) {
+                    const [providerId, actualModelId] = modelId.split(':');
+                    const provider = this.customProviders.get(providerId);
+                    if (provider && provider.languageModel) {
+                        const model = provider.languageModel(actualModelId);
+                        if (model) {
+                            this.recordModelUsage(modelId);
+                            return model;
+                        }
+                    }
+                }
+            }
+            // Return default model as fallback
+            if (this.defaultLanguageModel) {
+                return this.defaultLanguageModel;
+            }
+            return null;
+        }
+        catch (error) {
+            this.emit('ai_provider:model_access_failed', { modelId, error: error.message });
+            return this.defaultLanguageModel;
+        }
+    }
+    /**
+     * Get text embedding model from registry
+     */
+    getTextEmbeddingModel(modelId) {
+        try {
+            // Return default embedding model if no model ID specified
+            if (!modelId && this.defaultEmbeddingModel) {
+                return this.defaultEmbeddingModel;
+            }
+            if (!this.registry) {
+                throw new Error('Provider registry not created. Call initialize() first.');
+            }
+            if (!modelId) {
+                throw new Error('Model ID is required when no default embedding model is available');
+            }
+            const model = this.registry.textEmbeddingModel(modelId);
+            // 记录使用统计
+            this.recordModelUsage(modelId);
+            return model;
+        }
+        catch (error) {
+            this.emit('ai_provider:embedding_model_access_failed', { modelId, error: error.message });
+            // 尝试使用默认模型作为回退
+            if (modelId && this.defaultEmbeddingModel) {
+                return this.defaultEmbeddingModel;
+            }
+            return null;
+        }
+    }
+    /**
+     * 从注册表获取图像模型 - 官方用法
+     */
+    getImageModel(modelId) {
+        if (!this.registry) {
+            throw new Error('Provider registry not created. Call createProviderRegistry() first.');
+        }
+        try {
+            const model = this.registry.imageModel(modelId);
+            // 记录使用统计
+            this.recordModelUsage(modelId);
+            return model;
+        }
+        catch (error) {
+            this.emit('ai_provider:image_model_access_failed', { modelId, error: error.message });
+            return null;
+        }
+    }
+    // Global Provider Management
+    /**
+     * Set global default provider
+     */
+    setGlobalProvider(provider) {
+        // Set global provider
+        globalThis.AI_SDK_DEFAULT_PROVIDER = provider;
+        this.globalProvider = provider;
+        this.emit('ai_provider:global_provider_set', {
+            providerId: provider.providerId || 'unknown'
+        });
+    }
+    /**
+     * Get current global provider
+     */
+    getGlobalProvider() {
+        return this.globalProvider || globalThis.AI_SDK_DEFAULT_PROVIDER || null;
+    }
+    // Health Monitoring
+    /**
+     * Check provider health status
+     */
+    async checkProviderHealth(providerId) {
+        const startTime = Date.now();
+        try {
+            // Simplified health check - could call provider test endpoint in production
+            const provider = this.customProviders.get(providerId);
+            const isHealthy = !!provider;
+            const status = {
+                providerId,
+                isHealthy,
+                latency: Date.now() - startTime,
+                lastCheck: new Date()
+            };
+            this.healthStatus.set(providerId, status);
+            this.emit('ai_provider:health_check_completed', status);
+            return status;
+        }
+        catch (error) {
+            const status = {
+                providerId,
+                isHealthy: false,
+                latency: Date.now() - startTime,
+                error: error.message,
+                lastCheck: new Date()
+            };
+            this.healthStatus.set(providerId, status);
+            this.emit('ai_provider:health_check_failed', status);
+            return status;
+        }
+    }
+    /**
+     * Check health status of all providers
+     */
+    async checkAllProvidersHealth() {
+        const providerIds = Array.from(this.customProviders.keys());
+        const results = await Promise.all(providerIds.map(id => this.checkProviderHealth(id)));
+        this.emit('ai_provider:bulk_health_check_completed', {
+            total: results.length,
+            healthy: results.filter(r => r.isHealthy).length,
+            unhealthy: results.filter(r => !r.isHealthy).length
+        });
+        return results;
+    }
+    /**
+     * Record model usage statistics
+     */
+    recordModelUsage(modelId) {
+        const [providerId] = modelId.includes(':') ? modelId.split(':') : ['unknown', modelId];
+        const statsKey = `${providerId}:${modelId}`;
+        const existing = this.usageStats.get(statsKey);
+        if (existing) {
+            existing.totalCalls += 1;
+            existing.lastUsed = new Date();
+        }
+        else {
+            this.usageStats.set(statsKey, {
+                modelId,
+                providerId,
+                totalCalls: 1,
+                totalTokens: 0,
+                averageLatency: 0,
+                errorRate: 0,
+                lastUsed: new Date()
+            });
+        }
+    }
+    // Model Selection and Fallback
+    /**
+     * Smart model selection based on health and load
+     */
+    async selectBestModel(modelIds, criteria = {}) {
+        if (modelIds.length === 0)
+            return null;
+        // Get health status for all models
+        const modelHealth = new Map();
+        for (const modelId of modelIds) {
+            const [providerId] = modelId.includes(':') ? modelId.split(':') : ['unknown'];
+            const health = this.healthStatus.get(providerId);
+            if (health) {
+                modelHealth.set(modelId, health);
+            }
+        }
+        // Simple selection logic - prioritize healthy providers
+        const healthyModels = modelIds.filter(id => {
+            // Extract provider ID for health check
+            const [providerId] = id.includes(':') ? id.split(':') : ['unknown'];
+            const health = modelHealth.get(id);
+            // Log health check status (development)
+            if (process.env.NODE_ENV === 'development') {
+                // Health check logging would go here
+            }
+            return health?.isHealthy !== false;
+        });
+        if (healthyModels.length === 0) {
+            // Return first model as last resort if none are healthy
+            return modelIds[0];
+        }
+        // If prioritizing latency, select lowest latency model
+        if (criteria.prioritizeLatency) {
+            const sorted = healthyModels.sort((a, b) => {
+                const healthA = modelHealth.get(a);
+                const healthB = modelHealth.get(b);
+                return (healthA?.latency || Infinity) - (healthB?.latency || Infinity);
+            });
+            return sorted[0];
+        }
+        // Default: return first healthy model
+        return healthyModels[0];
+    }
+    /**
+     * Create model chain with fallback
+     */
+    createModelChain(primaryModelId, fallbackModelIds) {
+        return {
+            execute: async (operation) => {
+                const modelIds = [primaryModelId, ...fallbackModelIds];
+                for (let i = 0; i < modelIds.length; i++) {
+                    const modelId = modelIds[i];
+                    try {
+                        const model = this.getLanguageModel(modelId);
+                        if (!model)
+                            continue;
+                        const result = await operation(model);
+                        // Record successful usage
+                        this.emit('ai_provider:model_chain_success', {
+                            attemptedModel: modelId,
+                            attempt: i + 1,
+                            totalModels: modelIds.length
+                        });
+                        return result;
+                    }
+                    catch (error) {
+                        this.emit('ai_provider:model_chain_attempt_failed', {
+                            attemptedModel: modelId,
+                            attempt: i + 1,
+                            error: error.message,
+                            willTryNext: i < modelIds.length - 1
+                        });
+                        // Throw error if last model also failed
+                        if (i === modelIds.length - 1) {
+                            throw error;
+                        }
+                    }
+                }
+                throw new Error('All models in chain failed');
+            }
+        };
+    }
+    // Utility Methods
+    /**
+     * Get all registered providers
+     */
+    getRegisteredProviders() {
+        return Array.from(this.customProviders.keys());
+    }
+    /**
+     * Get model aliases
+     */
+    getModelAliases() {
+        const aliases = {};
+        this.modelAliases.forEach((config, alias) => {
+            aliases[alias] = config;
+        });
+        return aliases;
+    }
+    /**
+     * Get usage statistics
+     */
+    getUsageStats() {
+        return Array.from(this.usageStats.values());
+    }
+    /**
+     * Get health status report
+     */
+    getHealthReport() {
+        const statuses = Array.from(this.healthStatus.values());
+        return {
+            totalProviders: statuses.length,
+            healthyProviders: statuses.filter(s => s.isHealthy).length,
+            unhealthyProviders: statuses.filter(s => !s.isHealthy).length,
+            statuses
+        };
+    }
+    /**
+     * Clean up resources
+     */
+    async cleanup() {
+        // Clean up MCP connections and other resources
+        await Promise.all(Array.from(this.customProviders.values()).map(async (provider) => {
+            try {
+                // Call cleanup method if provider has one
+                if (typeof provider.cleanup === 'function') {
+                    await provider.cleanup();
+                }
+            }
+            catch (error) {
+                this.emit('ai_provider:cleanup_error', { error });
+            }
+        }));
+    }
+    /**
+     * Check initialization status
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return {
+            isInitialized: this.initialized,
+            customProviders: this.customProviders.size,
+            modelAliases: this.modelAliases.size,
+            totalUsage: Array.from(this.usageStats.values()).reduce((sum, stat) => sum + stat.totalCalls, 0),
+            hasRegistry: !!this.registry,
+            hasGlobalProvider: !!this.globalProvider
+        };
+    }
+    // Embedding Model Management
+    /**
+     * Get embeddings integration instance
+     */
+    getEmbeddingsIntegration() {
+        return this.embeddingsIntegration;
+    }
+    /**
+     * Configure embedding model parameters
+     */
+    configureEmbeddingModel(providerId, modelId, config) {
+        const key = `${providerId}:${modelId}`;
+        this.embeddingModelConfigs.set(key, config);
+        this.emit('ai_provider:embedding_model_configured', {
+            providerId,
+            modelId,
+            config
+        });
+    }
+    /**
+     * Get embedding model configuration
+     */
+    getEmbeddingModelConfig(providerId, modelId) {
+        const key = `${providerId}:${modelId}`;
+        return this.embeddingModelConfigs.get(key) || null;
+    }
+    /**
+     * Get all supported embedding models
+     */
+    getSupportedEmbeddingModels() {
+        return this.embeddingsIntegration.getSupportedModels();
+    }
+    /**
+     * Get embedding models by provider
+     */
+    getEmbeddingModelsByProvider(provider) {
+        return this.embeddingsIntegration.getModelsByProvider(provider);
+    }
+    // Settings Management
+    /**
+     * Get settings management instance
+     */
+    getSettingsManagement() {
+        return this.settingsManagement;
+    }
+    /**
+     * Apply settings preset to model configuration
+     */
+    applySettingsPreset(modelId, presetName, additionalSettings) {
+        const preset = this.settingsManagement.getPreset(presetName);
+        if (!preset) {
+            throw new Error(`Settings preset '${presetName}' not found`);
+        }
+        let finalSettings = preset.settings;
+        // Merge additional settings
+        if (additionalSettings) {
+            finalSettings = this.settingsManagement.mergeSettings(preset.settings, additionalSettings);
+        }
+        // Validate settings
+        const validation = this.settingsManagement.validateSettings(finalSettings);
+        if (!validation.isValid) {
+            throw new Error(`Invalid settings: ${validation.errors.map((e) => e.message).join(', ')}`);
+        }
+        // Store applied settings
+        this.modelSettingsPresets.set(modelId, finalSettings);
+        // Record usage history
+        this.settingsManagement.recordSettingsUsage(finalSettings, {
+            modelId,
+            presetName,
+            timestamp: new Date()
+        });
+        this.emit('ai_provider:settings_preset_applied', {
+            modelId,
+            presetName,
+            finalSettings,
+            validation
+        });
+        return finalSettings;
+    }
+    /**
+     * Create model instance with custom settings
+     */
+    createModelWithCustomSettings(baseModel, settings) {
+        // Validate settings
+        const validation = this.settingsManagement.validateSettings(settings);
+        if (!validation.isValid) {
+            this.emit('ai_provider:settings_validation_warning', {
+                errors: validation.errors,
+                warnings: validation.warnings
+            });
+        }
+        // Apply settings using middleware system
+        return wrapLanguageModel({
+            model: baseModel,
+            middleware: defaultSettingsMiddleware({
+                settings
+            })
+        });
+    }
+    /**
+     * Get model applied settings
+     */
+    getModelSettings(modelId) {
+        return this.modelSettingsPresets.get(modelId) || null;
+    }
+    /**
+     * Create optimized model for specific use case
+     */
+    createOptimizedModel(baseModel, useCase) {
+        const presetMap = {
+            creative: 'CREATIVE',
+            analytical: 'PRECISE',
+            deterministic: 'DETERMINISTIC',
+            fast: 'FAST_RESPONSE',
+            'long-form': 'LONG_FORM',
+            code: 'CODE_GENERATION'
+        };
+        const presetName = presetMap[useCase];
+        const preset = this.settingsManagement.getPreset(presetName);
+        if (!preset) {
+            throw new Error(`No preset found for use case: ${useCase}`);
+        }
+        return this.createModelWithCustomSettings(baseModel, preset.settings);
+    }
+    /**
+     * Destroy instance - enhanced version
+     */
+    async destroy() {
+        await this.cleanup();
+        // Clear main data
+        this.customProviders.clear();
+        this.modelAliases.clear();
+        this.healthStatus.clear();
+        this.usageStats.clear();
+        this.registry = null;
+        this.globalProvider = null;
+        // Clear additional data
+        this.embeddingModelConfigs.clear();
+        this.modelSettingsPresets.clear();
+        // Destroy subsystems
+        this.embeddingsIntegration.destroy();
+        this.settingsManagement.destroy();
+        this.removeAllListeners();
+        this.initialized = false;
+    }
+}
+// Exports
+export { customProvider, wrapLanguageModel, 
+// Core functions
+createProviderRegistry, defaultSettingsMiddleware };
+// Default export
+export default AIProviderManagement;
+//# sourceMappingURL=ai-provider.js.map