adaptive-memory-multi-model-router 2.2.6 → 2.2.8

package/dist/providers/registry.js

@@ -1,138 +1,140 @@
 "use strict";
 /**
- * TMLPD Provider Registry
- *
- * Manages provider configurations, API keys, and base URLs.
+ * A3M Router - Generic Provider Registry
+ * 
+ * Dynamically discovers and manages available LLM providers.
+ * Users configure providers via:
+ * - Environment variables (*_API_KEY patterns)
+ * - ~/.config/a3m-router/providers.json
+ * - Runtime registration via registerProvider()
+ * 
+ * No hardcoded provider references - all loaded from providerConfig.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProviderRegistry = void 0;
-const DEFAULT_PROVIDER_CONFIG = {
-    providers: ["openai", "openrouter", "groq", "cerebras", "mistral", "xai", "zai", "anthropic", "google"],
-    modelPriority: ["openai/gpt-4o", "groq/llama-3.3-70b-versatile", "cerebras/llama-3.3-70b"],
-    useOpenclawFallback: false,
-    maxTokens: 4096,
-};
+
+const { getAvailableProviders, loadConfig, healthCheck, registerProvider, deregisterProvider } = require("./providerConfig");
+const { routeQuery, routeBatch, recommendForTask, extractQueryFeatures, MODEL_PROFILES } = require("../routing/advancedRouter");
+
 class ProviderRegistry {
-    providers = new Map();
-    config;
-    modelPriority;
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_PROVIDER_CONFIG, ...config };
-        this.modelPriority = this.config.modelPriority;
-        this.initializeProviders();
-    }
-    initializeProviders() {
-        // Initialize from environment
-        const envVars = {
-            openai: { key: "OPENAI_API_KEY", url: "OPENAI_OPENAI_BASE_URL", mode: "openai" },
-            openrouter: { key: "OPENROUTER_API_KEY", url: "OPENROUTER_OPENAI_BASE_URL", mode: "openai" },
-            groq: { key: "GROQ_API_KEY", url: "GROQ_OPENAI_BASE_URL", mode: "openai" },
-            cerebras: { key: "CEREBRAS_API_KEY", url: "CEREBRAS_OPENAI_BASE_URL", mode: "openai" },
-            mistral: { key: "MISTRAL_API_KEY", url: "MISTRAL_OPENAI_BASE_URL", mode: "openai" },
-            xai: { key: "XAI_API_KEY", url: "XAI_OPENAI_BASE_URL", mode: "openai" },
-            zai: { key: "ZAI_API_KEY", url: "ZAI_OPENAI_BASE_URL", mode: "anthropic" },
-            anthropic: { key: "ANTHROPIC_API_KEY", url: "ANTHROPIC_BASE_URL", mode: "anthropic" },
-            google: { key: "GOOGLE_API_KEY", url: "GOOGLE_GEMINI_BASE_URL", mode: "gemini" },
-        };
-        for (const [name, env] of Object.entries(envVars)) {
-            const apiKey = process.env[env.key] || "";
-            const baseUrl = process.env[env.url] || "";
-            this.providers.set(name, {
-                name,
-                apiKey,
-                baseUrl,
-                mode: env.mode,
-                priority: this.modelPriority.findIndex((m) => m.startsWith(name + "/")),
-                enabled: Boolean(apiKey),
-                cooldownUntil: 0,
-                failureCount: 0,
-                lastError: null,
-                lastStatus: null,
-            });
-        }
+  constructor(config = {}) {
+    this.config = config;
+    this.providers = new Map();
+    this.readyCache = [];
+    this.cacheTime = 0;
+    this.cacheDuration = 60000; // 1 minute
+    
+    // Load configuration from env vars and config files
+    loadConfig();
+    this.initializeProviders();
+  }
+
+  initializeProviders() {
+    const available = getAvailableProviders();
+    
+    for (const [name, provider] of Object.entries(available)) {
+      this.providers.set(name, {
+        name,
+        apiKey: provider.apiKey || null,
+        baseUrl: provider.baseUrl || null,
+        models: provider.models,
+        type: provider.type,
+        priority: provider.priority,
+        enabled: true,
+        cooldownUntil: 0,
+        failureCount: 0,
+      });
     }
-    /**
-     * Check if provider is ready (has API key, not in cooldown)
-     */
-    isProviderReady(name) {
-        const provider = this.providers.get(name);
-        if (!provider || !provider.enabled)
-            return false;
-        if (Date.now() < provider.cooldownUntil)
-            return false;
-        return true;
+  }
+
+  isProviderReady(name) {
+    const provider = this.providers.get(name);
+    if (!provider || !provider.enabled) return false;
+    if (Date.now() < provider.cooldownUntil) return false;
+    return true;
+  }
+
+  getReadyProviders() {
+    const now = Date.now();
+    if (now - this.cacheTime < this.cacheDuration && this.readyCache.length > 0) {
+      return this.readyCache;
     }
-    /**
-     * Get best available model from priority list
-     */
-    selectModel() {
-        for (const model of this.modelPriority) {
-            const providerName = model.split("/")[0];
-            if (this.isProviderReady(providerName)) {
-                return model;
-            }
+    
+    this.readyCache = Array.from(this.providers.entries())
+      .filter(([_, p]) => this.isProviderReady(p.name))
+      .map(([name]) => name);
+    this.cacheTime = now;
+    return this.readyCache;
+  }
+
+  selectModel() {
+    const available = getAvailableProviders();
+    const sorted = Object.entries(available).sort(([, a], [, b]) => a.priority - b.priority);
+    
+    for (const [name, provider] of sorted) {
+      for (const model of provider.models) {
+        const modelKey = model.includes('/') ? model : name + '/' + model;
+        if (this.isProviderReady(name)) {
+          return modelKey;
         }
-        return null;
+      }
     }
-    /**
-     * Get all providers sorted by priority
-     */
-    getReadyProviders() {
-        return Array.from(this.providers.entries())
-            .filter(([_, p]) => this.isProviderReady(p.name))
-            .sort((a, b) => a[1].priority - b[1].priority)
-            .map(([name]) => name);
+    return null;
+  }
+
+  recordSuccess(name) {
+    const provider = this.providers.get(name);
+    if (provider) {
+      provider.failureCount = 0;
+      provider.cooldownUntil = 0;
     }
-    /**
-     * Record provider success
-     */
-    recordSuccess(name) {
-        const provider = this.providers.get(name);
-        if (provider) {
-            provider.cooldownUntil = 0;
-            provider.failureCount = 0;
-            provider.lastError = null;
-            provider.lastStatus = null;
-        }
+  }
+
+  recordFailure(name) {
+    const provider = this.providers.get(name);
+    if (provider) {
+      provider.failureCount++;
+      if (provider.failureCount >= 3) {
+        provider.cooldownUntil = Date.now() + 60000;
+      }
     }
-    /**
-     * Record provider failure
-     */
-    recordFailure(name, statusCode, error) {
-        const provider = this.providers.get(name);
-        if (!provider)
-            return;
-        provider.failureCount++;
-        provider.lastError = error;
-        provider.lastStatus = statusCode;
-        // Apply exponential backoff cooldown
-        const baseDelay = statusCode === 429 ? 60000 : statusCode === 403 ? 300000 : 30000;
-        const multiplier = Math.min(4, Math.pow(2, Math.max(0, provider.failureCount - 1)));
-        provider.cooldownUntil = Date.now() + baseDelay * multiplier;
-    }
-    /**
-     * Get provider status summary
-     */
-    getStatus() {
-        const status = {};
-        for (const [name, provider] of this.providers.entries()) {
-            status[name] = {
-                enabled: provider.enabled,
-                mode: provider.mode,
-                ready: this.isProviderReady(name),
-                cooldownUntil: provider.cooldownUntil ? new Date(provider.cooldownUntil).toISOString() : null,
-                lastError: provider.lastError,
-                lastStatus: provider.lastStatus,
-                failureCount: provider.failureCount,
-            };
-        }
-        return {
-            modelPriority: this.modelPriority,
-            readyProviders: this.getReadyProviders(),
-            providers: status,
-            timestamp: new Date().toISOString(),
-        };
+  }
+
+  getStatus() {
+    const available = getAvailableProviders();
+    return {
+      providers: Array.from(this.providers.keys()),
+      available: Object.keys(available),
+      ready: this.getReadyProviders(),
+      modelPriority: this.selectModel(),
+    };
+  }
+
+  // Dynamic provider management
+  addProvider(id, config) {
+    registerProvider(id, config);
+    this.initializeProviders();
+  }
+
+  removeProvider(id) {
+    deregisterProvider(id);
+    this.initializeProviders();
+  }
+
+  async checkHealth() {
+    const results = {};
+    for (const [name] of this.providers) {
+      results[name] = await healthCheck(name);
     }
+    return results;
+  }
 }
-exports.ProviderRegistry = ProviderRegistry;
-//# sourceMappingURL=registry.js.map
+
+const _routing = require("../routing/advancedRouter");
+
+module.exports = {
+  ProviderRegistry,
+  routeQuery: _routing.routeQuery,
+  routeBatch: _routing.routeBatch,
+  recommendForTask: _routing.recommendForTask,
+  extractQueryFeatures: _routing.extractQueryFeatures,
+  MODEL_PROFILES: _routing.MODEL_PROFILES,
+};