mindforge-cc 8.1.0 → 8.2.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/models/cloud-broker.js

@@ -0,0 +1,161 @@
+/**
+ * MindForge — CloudBroker (Pillar V: Multi-Cloud Arbitrage & Hedging)
+ * Dynamically routes tasks across multiple cloud providers (Vertex, Bedrock, Azure).
+ */
+'use strict';
+ 
+const fs = require('fs');
+const path = require('path');
+
+class CloudBroker {
+  constructor(config = {}) {
+    this.providers = config.providers || ['anthropic', 'google', 'aws', 'azure'];
+    this.statsPath = config.statsPath || path.join(__dirname, 'performance-stats.json');
+    this.blacklist = new Map(); // provider -> expiry (Date)
+    this.failureWindow = new Map(); // provider:taskType -> count
+    this.state = {
+      'anthropic': { latency: 450, costMultiplier: 1.0, healthy: true },
+      'google': { latency: 600, costMultiplier: 0.85, healthy: true },
+      'aws': { latency: 550, costMultiplier: 0.95, healthy: true },
+      'azure': { latency: 650, costMultiplier: 1.1, healthy: true }
+    };
+    this.reloadStats();
+  }
+
+  /**
+   * Loads performance stats from persistent storage and applies decay (0.95 factor).
+   */
+  reloadStats() {
+    try {
+      if (fs.existsSync(this.statsPath)) {
+        const raw = JSON.parse(fs.readFileSync(this.statsPath, 'utf8'));
+        
+        // v5 Pillar V: Metrics Decay (Hyper-Enterprise Hardening)
+        // Ensure historical data doesn't anchor the model if recent performance shifts.
+        this.performanceStats = {};
+        for (const [provider, tasks] of Object.entries(raw)) {
+          this.performanceStats[provider] = {};
+          for (const [task, stats] of Object.entries(tasks)) {
+            this.performanceStats[provider][task] = {
+              success: stats.success * 0.95,
+              failure: stats.failure * 0.95
+            };
+          }
+        }
+      } else {
+        this.performanceStats = {};
+      }
+    } catch (e) {
+      console.warn(`[MCA-WARN] Failed to load performance stats: ${e.message}`);
+      this.performanceStats = {};
+    }
+  }
+
+  /**
+   * Selects the optimal provider based on weighted latency, cost, and historical success.
+   * @param {Object} requirements - Task requirements (maxLatency, budgetConstraint, taskType)
+   * @returns {string} - Best provider ID
+   */
+  getBestProvider(requirements = {}) {
+    this.reloadStats(); // Just-In-Time refresh for latest feedback loop data
+    const taskType = requirements.taskType || 'default';
+
+    const scored = Object.entries(this.state)
+      .filter(([id, data]) => {
+        // v5 Pillar V: Circuit Breaker Verification
+        if (!data.healthy) return false;
+        const blacklistExpiry = this.blacklist.get(id);
+        if (blacklistExpiry && blacklistExpiry > new Date()) {
+          return false; // Circuit is OPEN (Blacklisted)
+        }
+        return true;
+      })
+      .map(([id, data]) => {
+        // Calculate Success Probability for this task
+        const stats = this.performanceStats[id]?.[taskType] || { success: 1, failure: 0 };
+        const totalTasks = stats.success + stats.failure;
+        const successProb = totalTasks > 0 ? (stats.success / totalTasks) : 0.5;
+
+        // Score Calculation (The "Affinity" Algorithm)
+        const latencyWeight = 0.2;
+        const costWeight = 0.3;
+        const affinityWeight = 0.5; 
+
+        const score = (data.latency * latencyWeight) + 
+                      (data.costMultiplier * 1000 * costWeight) + 
+                      ((1.0 - successProb) * 2000 * affinityWeight);
+
+        return { id, score, successProb: successProb.toFixed(2) };
+      });
+
+    scored.sort((a, b) => a.score - b.score);
+    
+    if (scored.length > 0) {
+      console.log(`[MCA-ROUTE] Selected provider: ${scored[0].id} (Affinity: ${scored[0].successProb} for '${taskType}')`);
+    }
+
+    return scored[0]?.id || 'anthropic';
+  }
+
+  /**
+   * Implements the Provider Fallback Protocol.
+   * Switches to the "Shadow Model" on the next best healthy provider.
+   * @param {string} failedProvider - The provider that just failed
+   * @returns {string} - Fallback provider ID
+   */
+  getFallbackProvider(failedProvider) {
+    if (this.state[failedProvider]) {
+      this.state[failedProvider].healthy = false;
+    }
+
+    const fallback = Object.entries(this.state)
+      .filter(([id, data]) => id !== failedProvider && data.healthy)
+      .sort((a, b) => a[1].latency - b[1].latency)[0];
+
+    return fallback ? fallback[0] : 'google'; // Default fallback
+  }
+
+  /**
+   * Retrieves provider-specific model mapping.
+   */
+  mapToProviderModel(provider, modelGroup) {
+    const mappings = {
+      'anthropic': { 'sonnet': 'claude-3-5-sonnet', 'opus': 'claude-3-opus', 'haiku': 'claude-3-haiku' },
+      'google': { 'sonnet': 'gemini-1.5-pro', 'haiku': 'gemini-1.5-flash' },
+      'aws': { 'sonnet': 'anthropic.claude-3-5-sonnet-v2:0', 'haiku': 'anthropic.claude-3-haiku-v1:0' },
+      'azure': { 'sonnet': 'gpt-4o', 'haiku': 'gpt-35-turbo' }
+    };
+
+    return mappings[provider]?.[modelGroup] || mappings[provider]?.['sonnet'];
+  }
+
+  /**
+   * Records a task failure and manages the circuit breaker.
+   */
+  recordFailure(provider, taskType = 'default') {
+    const key = `${provider}:${taskType}`;
+    const failures = (this.failureWindow.get(key) || 0) + 1;
+    this.failureWindow.set(key, failures);
+
+    if (failures >= 3) {
+      const expiry = new Date(Date.now() + 10 * 60 * 1000); // 10 min blacklist
+      this.blacklist.set(provider, expiry);
+      console.warn(`[MCA-CIRCUIT-OPEN] Provider '${provider}' blacklisted for 10 min due to consecutive failures on '${taskType}'.`);
+      this.failureWindow.set(key, 0); // Reset window upon blacklisting
+    }
+  }
+
+  /**
+   * Hardening: Simulate provider failures to verify Fallback Protocol.
+   */
+  startChaosMode() {
+    console.log('[ENTERPRISE-RESILIENCE] CloudBroker Chaos Mode ACTIVE. Simulating jitter and provider dropouts...');
+    setInterval(() => {
+      const providers = Object.keys(this.latencyMap);
+      const randomProvider = providers[Math.floor(Math.random() * providers.length)];
+      this.latencyMap[randomProvider] = Math.random() > 0.7 ? 5000 : 100; // Spike latency
+    }, 10000);
+  }
+}
+
+module.exports = CloudBroker;

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/models/cost-tracker.js

@@ -0,0 +1,118 @@
+/**
+ * MindForge v2 — Cost Tracker
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const METRICS_DIR = path.join(process.cwd(), '.mindforge', 'metrics');
+const USAGE_LOG = path.join(METRICS_DIR, 'token-usage.jsonl');
+
+function ensureDir() {
+  if (!fs.existsSync(METRICS_DIR)) {
+    fs.mkdirSync(METRICS_DIR, { recursive: true });
+  }
+}
+
+let _dailyCache = { value: 0, computed_at: 0 };
+
+function getTodaySpend() {
+  if (!fs.existsSync(USAGE_LOG)) return 0;
+  
+  const today = new Date().toISOString().slice(0, 10);
+  const content = fs.readFileSync(USAGE_LOG, 'utf8');
+  const lines = content.trim().split('\n');
+  
+  let total = 0;
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.date === today) {
+        total += entry.cost_usd || 0;
+      }
+    } catch (e) {
+      process.stderr.write('[cost-tracker] Skipped malformed entry\n');
+    }
+  }
+  return total;
+}
+
+function getTodaySpendCached() {
+  const AGE_MS = Date.now() - _dailyCache.computed_at;
+  if (AGE_MS > 60_000) {
+    _dailyCache.value = getTodaySpend();
+    _dailyCache.computed_at = Date.now();
+  }
+  return _dailyCache.value;
+}
+
+async function preflight(estimatedCost = 0) {
+  const settings = require('./model-router').getAllSettings();
+  const hardLimit = parseFloat(settings.MODEL_COST_HARD_LIMIT_USD || '0.0');
+  
+  if (hardLimit <= 0) return;
+
+  const todaySpend = getTodaySpendCached();
+  const projected = todaySpend + estimatedCost;
+
+  if (projected >= hardLimit) {
+    throw Object.assign(
+      new Error(`Daily cost limit $${hardLimit} reached (Today: $${todaySpend.toFixed(4)})`),
+      { code: 'COST_LIMIT_REACHED', spend: todaySpend, limit: hardLimit }
+    );
+  }
+}
+
+async function record(entry) {
+  ensureDir();
+  const enriched = {
+    ...entry,
+    date: new Date().toISOString().slice(0, 10),
+    timestamp: new Date().toISOString()
+  };
+  fs.appendFileSync(USAGE_LOG, JSON.stringify(enriched) + '\n');
+  _dailyCache.computed_at = 0; // Invalidate cache
+}
+
+function getSummary(params = { days: 7 }) {
+  if (!fs.existsSync(USAGE_LOG)) return { total_usd: 0, by_model: {} };
+  
+  const cutoffDate = new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - params.days);
+  const cutoffStr = cutoffDate.toISOString().slice(0, 10);
+
+  const content = fs.readFileSync(USAGE_LOG, 'utf8');
+  const lines = content.trim().split('\n');
+  
+  const result = {
+    total_usd: 0,
+    by_model: {},
+    by_phase: {},
+    calls: 0
+  };
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.date >= cutoffStr) {
+        const cost = entry.cost_usd || 0;
+        result.total_usd += cost;
+        result.calls++;
+        
+        const model = entry.model || 'unknown';
+        if (!result.by_model[model]) result.by_model[model] = { cost: 0, calls: 0, tokens: 0 };
+        result.by_model[model].cost += cost;
+        result.by_model[model].calls++;
+        result.by_model[model].tokens += (entry.input_tokens || 0) + (entry.output_tokens || 0);
+
+        const phase = entry.phase || 'unknown';
+        if (!result.by_phase[phase]) result.by_phase[phase] = 0;
+        result.by_phase[phase] += cost;
+      }
+    } catch (e) { /* ignore parse errors for summary */ }
+  }
+  return result;
+}
+
+module.exports = { record, preflight, getTodaySpend, getTodaySpendCached, getSummary };

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/models/finops-hub.js

@@ -0,0 +1,79 @@
+/**
+ * MindForge — FinOps Hub (Pillar V: Autonomous FinOps Hub)
+ * Enterprise-grade monitoring and budget enforcement for agentic workloads.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class FinOpsHub {
+  constructor(config = {}) {
+    this.projectRoot = config.projectRoot || process.cwd();
+    this.budgetLimit = config.budgetLimit || 100.00; // $100.00 USD Default
+    this.monthlyUsage = 0.00;
+  }
+
+  /**
+   * Initializes the FinOps state and budget monitoring.
+   */
+  async init() {
+    const roiPath = path.join(this.projectRoot, '.planning', 'ROI.jsonl');
+    if (fs.existsSync(roiPath)) {
+      const logs = fs.readFileSync(roiPath, 'utf8').split('\n').filter(Boolean);
+      logs.forEach(line => {
+        try {
+          const entry = JSON.parse(line);
+          this.monthlyUsage += entry.estimatedCostUSD || 0;
+        } catch (e) {
+          // Skip malformed lines
+        }
+      });
+    }
+  }
+
+  /**
+   * Checks if the task is within budget constraints.
+   * @param {Object} task - Task details (difficulty, priority)
+   * @returns {Object} - Budget check result (status, reasoning)
+   */
+  checkBudget(task) {
+    if (this.monthlyUsage >= this.budgetLimit) {
+      return { status: 'DENIED', reason: `Monthly budget limit ($${this.budgetLimit}) reached.` };
+    }
+
+    if (this.monthlyUsage >= this.budgetLimit * 0.9) {
+      return { status: 'WARNING', reason: `Project has consumed 90% of the allocated budget ($${this.monthlyUsage.toFixed(2)} / $${this.budgetLimit.toFixed(2)}).` };
+    }
+
+    return { status: 'APPROVED', usage: this.monthlyUsage };
+  }
+
+  /**
+   * Generates a "Spending Profile" for the project.
+   * Used for the Nexus Dashboard to visualize ROI.
+   */
+  getSpendingProfile() {
+    const roiPath = path.join(this.projectRoot, '.planning', 'ROI.jsonl');
+    if (!fs.existsSync(roiPath)) return { totalSpend: 0, goalsAchieved: 0, roi: 0 };
+
+    const logs = fs.readFileSync(roiPath, 'utf8').split('\n').filter(Boolean).map(JSON.parse);
+    const totalSpend = logs.reduce((acc, l) => acc + (l.estimatedCostUSD || 0), 0);
+    const goalsAchieved = logs.reduce((acc, l) => acc + (l.goalAchieved || 0), 0);
+
+    return {
+      totalSpend: totalSpend.toFixed(2),
+      goalsAchieved,
+      roi: totalSpend > 0 ? (goalsAchieved / totalSpend).toFixed(2) : 0,
+      tokenEfficiency: logs.length > 0 ? (totalSpend / logs.length).toFixed(4) : 0,
+    };
+  }
+
+  /**
+   * Resets the usage counter (system-level call).
+   */
+  resetMonthlyUsage() {
+    this.monthlyUsage = 0.00;
+  }
+}
+
+module.exports = FinOpsHub;

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/models/gemini-provider.js

@@ -0,0 +1,79 @@
+/**
+ * MindForge v2 — Gemini Provider
+ * Using header-based auth for security.
+ */
+'use strict';
+
+const https = require('https');
+
+class GeminiProvider {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+
+  async complete(params) {
+    const { model, systemPrompt, userMessage, maxTokens = 8192, temperature = 0.2 } = params;
+
+    const data = JSON.stringify({
+      system_instruction: { parts: [{ text: systemPrompt }] },
+      contents: [{ parts: [{ text: userMessage }] }],
+      generationConfig: {
+        maxOutputTokens: maxTokens,
+        temperature,
+      },
+    });
+
+    const modelId = model.startsWith('models/') ? model : `models/${model}`;
+
+    return new Promise((resolve, reject) => {
+      const req = https.request({
+        hostname: 'generativelanguage.googleapis.com',
+        path: `/v1beta/${modelId}:generateContent`,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-goog-api-key': this.apiKey, // Header auth
+          'Content-Length': Buffer.byteLength(data),
+        },
+        timeout: 180_000,
+      }, res => {
+        let body = '';
+        res.on('data', chunk => body += chunk);
+        res.on('end', () => {
+          try {
+            const json = JSON.parse(body);
+            if (res.statusCode !== 200) {
+              return reject(Object.assign(new Error(json.error?.message || 'Gemini API error'), { status: res.statusCode }));
+            }
+
+            // Gemini 1.5 Pro billing is complex; using $1.25 / 1M input as baseline
+            const inputTokens = json.usageMetadata.promptTokenCount;
+            const outputTokens = json.usageMetadata.candidatesTokenCount;
+            const cost = (inputTokens * 0.00000125) + (outputTokens * 0.00000375);
+
+            resolve({
+              model: modelId,
+              content: json.candidates[0].content.parts[0].text,
+              input_tokens: inputTokens,
+              output_tokens: outputTokens,
+              cost_usd: cost,
+              provider: 'google'
+            });
+          } catch (e) {
+            reject(new Error('Failed to parse Gemini response: ' + e.message));
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(Object.assign(new Error('Gemini timeout'), { status: 408 }));
+      });
+      req.write(data);
+      req.end();
+    });
+  }
+}
+
+module.exports = GeminiProvider;

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/models/model-broker.js

@@ -0,0 +1,129 @@
+const CloudBroker = require('./cloud-broker');
+
+class ModelBroker {
+  constructor(config = {}) {
+    this.projectRoot = config.projectRoot || process.cwd();
+    this.cloudBroker = new CloudBroker(config.cloud);
+    this.defaults = {
+      EXECUTOR_MODEL: 'sonnet',
+      PLANNER_MODEL: 'sonnet',
+      SECURITY_MODEL: 'opus',
+      QA_MODEL: 'sonnet',
+      RESEARCH_MODEL: 'sonnet',
+      DEBUG_MODEL: 'sonnet',
+      QUICK_MODEL: 'haiku',
+    };
+  }
+
+  /**
+   * Resolves the optimal model for a given task (v5 Multi-Cloud Arbitrage).
+   * @param {Object} context - Task context (persona, difficulty, tier)
+   * @returns {Object} - Resolved model details (modelId, provider, costTier, reasoning)
+   */
+  resolveModel(context) {
+    const { persona, difficulty, tier } = context;
+    let modelGroup = this.defaults.EXECUTOR_MODEL;
+    let reasoningParts = [];
+
+    // 1. Check Security Tier (T3 requires premium models)
+    if (tier === 3) {
+      modelGroup = this.defaults.SECURITY_MODEL;
+      reasoningParts.push('Tier 3 (Principal) action requires high-trust model (Opus).');
+    } else {
+      // 2. Map Persona to Base Model
+      const personaMap = {
+        'executor': 'EXECUTOR_MODEL',
+        'planner': 'PLANNER_MODEL',
+        'security-reviewer': 'SECURITY_MODEL',
+        'qa-engineer': 'QA_MODEL',
+        'researcher': 'RESEARCH_MODEL',
+        'debug-specialist': 'DEBUG_MODEL',
+      };
+      if (personaMap[persona]) {
+        modelGroup = this.defaults[personaMap[persona]];
+      }
+    }
+
+    // 3. Complexity-based Overrides
+    if (difficulty < 2.0 && difficulty !== undefined && tier !== 3) {
+      modelGroup = this.defaults.QUICK_MODEL;
+      reasoningParts.push(`Low difficulty (${difficulty}) -> Quick model.`);
+    } else if (difficulty > 4.5 && tier !== 3) {
+      modelGroup = this.defaults.SECURITY_MODEL;
+      reasoningParts.push(`High difficulty (${difficulty}) -> Complexity upgrade.`);
+    }
+
+    // 4. v5 Multi-Cloud Arbitrage
+    const provider = this.cloudBroker.getBestProvider({ 
+      latencyConstraint: tier === 3 ? 500 : 1000 
+    });
+    const modelId = this.cloudBroker.mapToProviderModel(provider, modelGroup);
+    
+    reasoningParts.push(`Arbitrage: Routed to ${provider} (${modelId}) based on latency/cost.`);
+
+    return { 
+      modelId, 
+      provider,
+      modelGroup,
+      costTier: modelGroup === 'opus' ? 'high' : (modelGroup === 'haiku' ? 'low' : 'medium'), 
+      reasoning: reasoningParts.join(' ') 
+    };
+  }
+
+  /**
+   * Implements the Provider Fallback Protocol (v5 Pillar V).
+   * @param {string} failedProvider - The provider that failed.
+   * @param {string} modelGroup - The group being requested.
+   * @returns {Object} - New model and provider details.
+   */
+  handleProviderFailure(failedProvider, modelGroup) {
+    const fallbackProvider = this.cloudBroker.getFallbackProvider(failedProvider);
+    const modelId = this.cloudBroker.mapToProviderModel(fallbackProvider, modelGroup);
+
+    console.warn(`[P5-FALLBACK] Provider ${failedProvider} failed. Migrating context to ${fallbackProvider} (${modelId}).`);
+
+    return {
+      modelId,
+      provider: fallbackProvider,
+      modelGroup,
+      reasoning: `Provider Fallback Protocol: Emergency migration from ${failedProvider} to ${fallbackProvider}.`
+    };
+  }
+
+  /**
+   * Tracks the "Agentic ROI" for a completed task.
+   * @param {Object} report - Task execution report (tokens, duration, status)
+   */
+  trackROI(report) {
+    const roiPath = path.join(this.projectRoot, '.planning', 'ROI.jsonl');
+    const entry = {
+      timestamp: new Date().toISOString(),
+      planId: report.planId,
+      task: report.taskName,
+      model: report.modelId,
+      costTier: report.costTier,
+      inputTokens: report.inputTokens,
+      outputTokens: report.outputTokens,
+      durationMs: report.durationMs,
+      status: report.status,
+      goalAchieved: report.status === 'completed' ? 1 : 0,
+      estimatedCostUSD: this.estimateCost(report.modelId, report.inputTokens, report.outputTokens),
+    };
+
+    fs.appendFileSync(roiPath, JSON.stringify(entry) + '\n');
+  }
+
+  estimateCost(modelId, input, output) {
+    // Mock cost estimation logic per 1M tokens
+    const rates = {
+      'claude-3-opus': { in: 15, out: 75 },
+      'claude-3-5-sonnet': { in: 3, out: 15 },
+      'claude-3-haiku': { in: 0.25, out: 1.25 },
+    };
+
+    const rate = rates[modelId] || rates['claude-3-5-sonnet'];
+    return (input / 1_000_000) * rate.in + (output / 1_000_000) * rate.out;
+  }
+}
+
+module.exports = ModelBroker;

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/models/model-client.js

@@ -0,0 +1,98 @@
+/**
+ * MindForge v2 — Model Client
+ * Unified client with routing, fallbacks, and cost tracking.
+ */
+'use strict';
+
+const Router = require('./model-router');
+const CostTracker = require('./cost-tracker');
+const AnthropicProvider = require('./anthropic-provider');
+const OpenAIProvider = require('./openai-provider');
+const GeminiProvider = require('./gemini-provider');
+
+const FALLBACK_CHAINS = {
+  'claude-3-opus-20240229': ['gpt-4o', 'claude-3-5-sonnet-20240620'],
+  'gpt-4o': ['claude-3-5-sonnet-20240620'],
+  'gemini-1.5-pro': ['claude-3-5-sonnet-20240620'],
+};
+
+class ModelClient {
+  static async complete(params) {
+    const {
+      persona = 'developer',
+      tier = 1,
+      maxTokens,
+      temperature,
+      taskName = 'unknown',
+      sessionId = 'unknown',
+      phaseNum = 0
+    } = params;
+
+    // 1. Route to model
+    const routing = Router.route(persona, tier);
+    let modelId = routing.model;
+
+    // 2. Pre-flight cost check
+    try {
+      await CostTracker.preflight(0.05); // Conservative estimate
+    } catch (e) {
+      if (e.code === 'COST_LIMIT_REACHED') throw e;
+    }
+
+    // 3. Execute with fallbacks
+    let result = null;
+    let attempts = [modelId, ...(FALLBACK_CHAINS[modelId] || [])];
+
+    for (const currentModel of attempts) {
+      try {
+        const provider = this._getProvider(currentModel);
+        if (!provider) continue;
+
+        result = await provider.complete({
+          model: currentModel,
+          systemPrompt: params.systemPrompt,
+          userMessage: params.userMessage,
+          maxTokens,
+          temperature
+        });
+
+        // Add metadata
+        result.task_name = taskName;
+        result.session_id = sessionId;
+        result.phase = phaseNum;
+
+        if (currentModel !== modelId) {
+          result.content = `[FALLBACK NOTICE: ${modelId} unavailable — used ${currentModel} instead.]\n\n${result.content}`;
+        }
+
+        // 4. Record cost
+        await CostTracker.record(result);
+        return result;
+
+      } catch (err) {
+        process.stderr.write(`[model-client] ${currentModel} failed: ${err.message}\n`);
+        if (attempts.indexOf(currentModel) === attempts.length - 1) {
+          throw err;
+        }
+      }
+    }
+  }
+
+  static _getProvider(modelId) {
+    if (modelId.includes('claude')) {
+      if (!process.env.ANTHROPIC_API_KEY) return null;
+      return new AnthropicProvider(process.env.ANTHROPIC_API_KEY);
+    }
+    if (modelId.includes('gpt')) {
+      if (!process.env.OPENAI_API_KEY) return null;
+      return new OpenAIProvider(process.env.OPENAI_API_KEY);
+    }
+    if (modelId.includes('gemini')) {
+      if (!process.env.GOOGLE_API_KEY) return null;
+      return new GeminiProvider(process.env.GOOGLE_API_KEY);
+    }
+    return null;
+  }
+}
+
+module.exports = ModelClient;