mindforge-cc 8.2.0 → 9.0.0

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

@@ -1,161 +0,0 @@
-/**
- * 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

@@ -1,118 +0,0 @@
-/**
- * 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

@@ -1,79 +0,0 @@
-/**
- * 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

@@ -1,79 +0,0 @@
-/**
- * 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

@@ -1,129 +0,0 @@
-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

@@ -1,98 +0,0 @@
-/**
- * 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;