@scenemesh/entity-engine-aimodule 1.0.0

package/dist/chunk-J323UTPE.mjs

@@ -0,0 +1,650 @@
+// src/core/ai-provider.ts
+import { EventEmitter } from "events";
+import {
+  customProvider,
+  wrapLanguageModel,
+  createProviderRegistry,
+  defaultSettingsMiddleware
+} from "ai";
+var AIProviderManagement = class extends EventEmitter {
+  // AISettingsManager - 延迟初始化
+  constructor() {
+    super();
+    this.initialized = false;
+    this.registry = null;
+    this.customProviders = /* @__PURE__ */ new Map();
+    this.modelAliases = /* @__PURE__ */ new Map();
+    this.healthStatus = /* @__PURE__ */ new Map();
+    this.usageStats = /* @__PURE__ */ new Map();
+    this.defaultLanguageModel = null;
+    this.defaultEmbeddingModel = null;
+    this.globalProvider = null;
+    // 新增：嵌入和设置管理相关属性
+    this.embeddingModelConfigs = /* @__PURE__ */ new Map();
+    this.modelSettingsPresets = /* @__PURE__ */ new Map();
+    this.embeddingsIntegration = null;
+    this.settingsManagement = null;
+  }
+  /**
+   * 初始化
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    try {
+      this.emit("ai_provider:initializing");
+      const { AIEmbeddingsIntegration } = await import("./ai-embeddings-5ED5LDXX.mjs");
+      const { AISettingsManagement } = await import("./ai-settings-DTXEAB64.mjs");
+      this.embeddingsIntegration = new AIEmbeddingsIntegration();
+      this.settingsManagement = new AISettingsManagement();
+      await this.embeddingsIntegration.initialize();
+      await this.settingsManagement.initialize();
+      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 {
+      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) {
+        return;
+      }
+      const { createOpenAICompatible } = await import("@ai-sdk/openai-compatible");
+      const qwenProvider = createOpenAICompatible({
+        name: "qwen",
+        baseURL: qwenBaseUrl,
+        apiKey: qwenApiKey
+      });
+      const registryConfig = {
+        providers: {
+          qwen: qwenProvider
+        },
+        options: {
+          separator: ":"
+        }
+      };
+      this.registry = createProviderRegistry(
+        registryConfig.providers,
+        registryConfig.options
+      );
+      this.defaultLanguageModel = this.registry.languageModel("qwen:qwen-plus-2025-01-25");
+      try {
+        this.defaultEmbeddingModel = this.registry.textEmbeddingModel("qwen:text-embedding-v1");
+      } catch {
+      }
+      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,
+        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);
+    this.emit("ai_provider:model_alias_created", aliasConfig);
+    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 {
+      if (!modelId && this.defaultLanguageModel) {
+        return this.defaultLanguageModel;
+      }
+      if (this.registry && modelId) {
+        try {
+          const model = this.registry.languageModel(modelId);
+          this.recordModelUsage(modelId);
+          return model;
+        } catch (registryError) {
+        }
+      }
+      if (modelId) {
+        const qwenProvider = this.customProviders.get("qwen");
+        if (qwenProvider && qwenProvider.languageModel) {
+          const model = qwenProvider.languageModel(modelId);
+          if (model) {
+            this.recordModelUsage(modelId);
+            return 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;
+            }
+          }
+        }
+      }
+      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 {
+      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) {
+    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 {
+      const provider = this.customProviders.get(providerId);
+      const isHealthy = !!provider;
+      const status = {
+        providerId,
+        isHealthy,
+        latency: Date.now() - startTime,
+        lastCheck: /* @__PURE__ */ 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: /* @__PURE__ */ 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 = /* @__PURE__ */ new Date();
+    } else {
+      this.usageStats.set(statsKey, {
+        modelId,
+        providerId,
+        totalCalls: 1,
+        totalTokens: 0,
+        averageLatency: 0,
+        errorRate: 0,
+        lastUsed: /* @__PURE__ */ new Date()
+      });
+    }
+  }
+  // Model Selection and Fallback
+  /**
+   * Smart model selection based on health and load
+   */
+  async selectBestModel(modelIds, criteria = {}) {
+    if (modelIds.length === 0) return null;
+    const modelHealth = /* @__PURE__ */ 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);
+      }
+    }
+    const healthyModels = modelIds.filter((id) => {
+      const [providerId] = id.includes(":") ? id.split(":") : ["unknown"];
+      const health = modelHealth.get(id);
+      if (process.env.NODE_ENV === "development") {
+      }
+      return health?.isHealthy !== false;
+    });
+    if (healthyModels.length === 0) {
+      return modelIds[0];
+    }
+    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];
+    }
+    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);
+            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
+            });
+            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() {
+    await Promise.all(
+      Array.from(this.customProviders.values()).map(async (provider) => {
+        try {
+          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;
+    if (additionalSettings) {
+      finalSettings = this.settingsManagement.mergeSettings(
+        preset.settings,
+        additionalSettings
+      );
+    }
+    const validation = this.settingsManagement.validateSettings(finalSettings);
+    if (!validation.isValid) {
+      throw new Error(`Invalid settings: ${validation.errors.map((e) => e.message).join(", ")}`);
+    }
+    this.modelSettingsPresets.set(modelId, finalSettings);
+    this.settingsManagement.recordSettingsUsage(finalSettings, {
+      modelId,
+      presetName,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    this.emit("ai_provider:settings_preset_applied", {
+      modelId,
+      presetName,
+      finalSettings,
+      validation
+    });
+    return finalSettings;
+  }
+  /**
+   * Create model instance with custom settings
+   */
+  createModelWithCustomSettings(baseModel, settings) {
+    const validation = this.settingsManagement.validateSettings(settings);
+    if (!validation.isValid) {
+      this.emit("ai_provider:settings_validation_warning", {
+        errors: validation.errors,
+        warnings: validation.warnings
+      });
+    }
+    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();
+    this.customProviders.clear();
+    this.modelAliases.clear();
+    this.healthStatus.clear();
+    this.usageStats.clear();
+    this.registry = null;
+    this.globalProvider = null;
+    this.embeddingModelConfigs.clear();
+    this.modelSettingsPresets.clear();
+    this.embeddingsIntegration.destroy();
+    this.settingsManagement.destroy();
+    this.removeAllListeners();
+    this.initialized = false;
+  }
+};
+var ai_provider_default = AIProviderManagement;
+
+export {
+  customProvider,
+  wrapLanguageModel,
+  createProviderRegistry,
+  defaultSettingsMiddleware,
+  AIProviderManagement,
+  ai_provider_default
+};
+//# sourceMappingURL=chunk-J323UTPE.mjs.map