@defai.digital/automatosx 5.12.2 → 5.12.3

package/README.md

@@ -7,13 +7,13 @@ AutomatosX is a local-first CLI that transforms stateless AI assistants into a p
 [![npm version](https://img.shields.io/npm/v/@defai.digital/automatosx.svg)](https://www.npmjs.com/package/@defai.digital/automatosx)
 [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
 [![TypeScript](https://img.shields.io/badge/TypeScript-100%25-blue.svg)](https://www.typescriptlang.org/)
-[![Tests](https://img.shields.io/badge/tests-2,405%20passing-brightgreen.svg)](#)
+[![Tests](https://img.shields.io/badge/tests-2,458%20passing-brightgreen.svg)](#)
 [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/defai-digital/automatosx/ci.yml?branch=main&label=CI)](https://github.com/defai-digital/automatosx/actions)
 [![macOS](https://img.shields.io/badge/macOS-26.0-blue.svg)](https://www.apple.com/macos)
 [![Windows](https://img.shields.io/badge/Windows-10+-blue.svg)](https://www.microsoft.com/windows)
 [![Ubuntu](https://img.shields.io/badge/Ubuntu-24.04-orange.svg)](https://ubuntu.com)
 
-**Status**: ✅ Production Ready · **v5.12.2** · October 2025 · 23 Specialized Agents · 100% Resource Leak Free · Spec-Driven Development
+**Status**: ✅ Production Ready · **v5.12.3** · October 2025 · 23 Specialized Agents · 100% Resource Leak Free · Spec-Driven Development
 
 ---
 

package/dist/index.js

@@ -9000,6 +9000,646 @@ var PerformanceTimer = class {
   }
 };
 
+// src/core/routing-strategy.ts
+init_esm_shims();
+
+// src/types/routing.ts
+init_esm_shims();
+var ROUTING_STRATEGIES = {
+  /**
+   * Fast Strategy - Minimize latency
+   * Best for: Real-time applications, user-facing features
+   */
+  fast: {
+    name: "fast",
+    weights: {
+      latency: 0.7,
+      quality: 0.2,
+      cost: 0.1,
+      availability: 0
+    }
+  },
+  /**
+   * Cheap Strategy - Minimize cost
+   * Best for: Batch processing, non-critical tasks
+   */
+  cheap: {
+    name: "cheap",
+    weights: {
+      cost: 0.7,
+      quality: 0.2,
+      latency: 0.1,
+      availability: 0
+    }
+  },
+  /**
+   * Balanced Strategy - Balance all factors equally
+   * Best for: General-purpose use
+   */
+  balanced: {
+    name: "balanced",
+    weights: {
+      cost: 0.33,
+      latency: 0.33,
+      quality: 0.33,
+      availability: 0.01
+    }
+  },
+  /**
+   * Quality Strategy - Maximize quality and reliability
+   * Best for: Production systems, critical tasks
+   */
+  quality: {
+    name: "quality",
+    weights: {
+      quality: 0.6,
+      latency: 0.3,
+      cost: 0.1,
+      availability: 0
+    }
+  },
+  /**
+   * Custom Strategy - User-defined weights
+   * Weights must be provided in config
+   */
+  custom: {
+    name: "custom",
+    weights: {
+      cost: 0.25,
+      latency: 0.25,
+      quality: 0.25,
+      availability: 0.25
+    }
+  }
+};
+
+// src/core/provider-metrics-tracker.ts
+init_esm_shims();
+init_logger();
+var ProviderMetricsTracker = class extends EventEmitter {
+  metrics = /* @__PURE__ */ new Map();
+  windowSize;
+  minRequests;
+  constructor(options = {}) {
+    super();
+    this.windowSize = options.windowSize || 100;
+    this.minRequests = options.minRequests || 10;
+    logger.debug("ProviderMetricsTracker initialized", {
+      windowSize: this.windowSize,
+      minRequests: this.minRequests
+    });
+  }
+  /**
+   * Record a request for metrics tracking
+   */
+  async recordRequest(provider, latencyMs, success, finishReason, tokenUsage, costUsd, model) {
+    if (!this.metrics.has(provider)) {
+      this.metrics.set(provider, []);
+    }
+    const records = this.metrics.get(provider);
+    records.push({
+      timestamp: Date.now(),
+      latencyMs,
+      success,
+      finishReason,
+      promptTokens: tokenUsage.prompt,
+      completionTokens: tokenUsage.completion,
+      totalTokens: tokenUsage.total,
+      costUsd,
+      model
+    });
+    if (records.length > this.windowSize) {
+      records.splice(0, records.length - this.windowSize);
+    }
+    logger.debug("Request recorded", {
+      provider,
+      latencyMs,
+      success,
+      totalRequests: records.length
+    });
+    this.emit("metrics-updated", provider);
+  }
+  /**
+   * Get current metrics for a provider
+   */
+  async getMetrics(provider) {
+    const records = this.metrics.get(provider);
+    if (!records || records.length === 0) {
+      return null;
+    }
+    const now = Date.now();
+    const firstTimestamp = records[0].timestamp;
+    const lastTimestamp = records[records.length - 1].timestamp;
+    const latencies = records.map((r) => r.latencyMs).sort((a, b) => a - b);
+    const avgLatency = latencies.reduce((sum, l) => sum + l, 0) / latencies.length;
+    const p50Index = Math.floor(latencies.length * 0.5);
+    const p95Index = Math.floor(latencies.length * 0.95);
+    const p99Index = Math.floor(latencies.length * 0.99);
+    const successful = records.filter((r) => r.success);
+    const failed = records.filter((r) => !r.success);
+    const stopFinishes = successful.filter((r) => r.finishReason === "stop");
+    const lengthFinishes = successful.filter((r) => r.finishReason === "length");
+    const errorFinishes = records.filter((r) => r.finishReason === "error");
+    const successRate = successful.length / records.length;
+    const properStopRate = successful.length > 0 ? stopFinishes.length / successful.length : 0;
+    const totalCost = records.reduce((sum, r) => sum + r.costUsd, 0);
+    const avgCostPerRequest = totalCost / records.length;
+    const totalTokens = records.reduce((sum, r) => sum + r.totalTokens, 0);
+    const avgCostPer1M = totalTokens > 0 ? totalCost / totalTokens * 1e6 : 0;
+    const lastSuccess = successful.length > 0 ? successful[successful.length - 1].timestamp : 0;
+    const lastFailure = failed.length > 0 ? failed[failed.length - 1].timestamp : 0;
+    let consecutiveFailures = 0;
+    for (let i = records.length - 1; i >= 0; i--) {
+      if (!records[i].success) {
+        consecutiveFailures++;
+      } else {
+        break;
+      }
+    }
+    const uptime = successRate;
+    return {
+      provider,
+      window: records.length,
+      latency: {
+        avg: avgLatency,
+        p50: latencies[p50Index] ?? avgLatency,
+        p95: latencies[p95Index] ?? latencies[latencies.length - 1],
+        p99: latencies[p99Index] ?? latencies[latencies.length - 1],
+        min: latencies[0],
+        max: latencies[latencies.length - 1]
+      },
+      quality: {
+        totalRequests: records.length,
+        successfulRequests: successful.length,
+        failedRequests: failed.length,
+        successRate,
+        stopFinishes: stopFinishes.length,
+        lengthFinishes: lengthFinishes.length,
+        errorFinishes: errorFinishes.length,
+        properStopRate
+      },
+      cost: {
+        totalCostUsd: totalCost,
+        avgCostPerRequest,
+        avgCostPer1MTokens: avgCostPer1M
+      },
+      availability: {
+        uptime,
+        lastSuccess,
+        lastFailure,
+        consecutiveFailures
+      },
+      firstRequest: firstTimestamp,
+      lastRequest: lastTimestamp,
+      lastUpdated: now
+    };
+  }
+  /**
+   * Calculate latency score (0-1, 1 = best)
+   * Based on P95 latency compared to threshold
+   */
+  async getLatencyScore(provider) {
+    const metrics = await this.getMetrics(provider);
+    if (!metrics || metrics.window < this.minRequests) {
+      return 0.5;
+    }
+    const p95 = metrics.latency.p95;
+    if (p95 < 1e3) return 1;
+    if (p95 < 2e3) return 1 - (p95 - 1e3) / 1e3 * 0.1;
+    if (p95 < 3e3) return 0.9 - (p95 - 2e3) / 1e3 * 0.2;
+    if (p95 < 4e3) return 0.7 - (p95 - 3e3) / 1e3 * 0.2;
+    if (p95 < 5e3) return 0.5 - (p95 - 4e3) / 1e3 * 0.2;
+    return Math.max(0.1, 0.3 - (p95 - 5e3) / 5e3 * 0.2);
+  }
+  /**
+   * Calculate quality score (0-1, 1 = best)
+   * Based on success rate and proper stop rate
+   */
+  async getQualityScore(provider) {
+    const metrics = await this.getMetrics(provider);
+    if (!metrics || metrics.window < this.minRequests) {
+      return 0.5;
+    }
+    const successScore = metrics.quality.successRate;
+    const stopScore = metrics.quality.properStopRate;
+    if (successScore < 0.5) {
+      return successScore * 0.9 + stopScore * 0.1;
+    } else {
+      return successScore * 0.7 + stopScore * 0.3;
+    }
+  }
+  /**
+   * Calculate cost score (0-1, 1 = cheapest)
+   * Relative to other providers
+   */
+  async getCostScore(provider, allProviders) {
+    const metrics = await this.getMetrics(provider);
+    if (!metrics || metrics.window < this.minRequests) {
+      return 0.5;
+    }
+    const costs = [];
+    for (const p of allProviders) {
+      const m = await this.getMetrics(p);
+      if (m && m.window >= this.minRequests) {
+        costs.push(m.cost.avgCostPer1MTokens);
+      }
+    }
+    if (costs.length === 0) {
+      return 0.5;
+    }
+    const minCost = Math.min(...costs);
+    const maxCost = Math.max(...costs);
+    const providerCost = metrics.cost.avgCostPer1MTokens;
+    if (maxCost === minCost) {
+      return 1;
+    }
+    return 1 - (providerCost - minCost) / (maxCost - minCost);
+  }
+  /**
+   * Calculate availability score (0-1, 1 = most available)
+   */
+  async getAvailabilityScore(provider) {
+    const metrics = await this.getMetrics(provider);
+    if (!metrics || metrics.window < this.minRequests) {
+      return 0.5;
+    }
+    const uptimeScore = metrics.availability.uptime;
+    const failurePenalty = Math.min(metrics.availability.consecutiveFailures * 0.1, 0.5);
+    return Math.max(0, uptimeScore - failurePenalty);
+  }
+  /**
+   * Calculate overall provider score based on weights
+   */
+  async calculateScore(provider, weights, allProviders, healthMultiplier = 1) {
+    const costScore = await this.getCostScore(provider, allProviders);
+    const latencyScore = await this.getLatencyScore(provider);
+    const qualityScore = await this.getQualityScore(provider);
+    const availabilityScore = await this.getAvailabilityScore(provider);
+    const totalScore = (weights.cost * costScore + weights.latency * latencyScore + weights.quality * qualityScore + weights.availability * availabilityScore) * healthMultiplier;
+    const metrics = await this.getMetrics(provider);
+    return {
+      provider,
+      totalScore,
+      breakdown: {
+        costScore,
+        latencyScore,
+        qualityScore,
+        availabilityScore
+      },
+      healthMultiplier,
+      metadata: metrics ? {
+        avgLatencyMs: metrics.latency.avg,
+        avgCostPer1M: metrics.cost.avgCostPer1MTokens,
+        successRate: metrics.quality.successRate,
+        lastUsed: metrics.lastRequest
+      } : void 0
+    };
+  }
+  /**
+   * Get all provider scores sorted by total score (descending)
+   */
+  async getAllScores(providers, weights, healthMultipliers) {
+    const scores = [];
+    for (const provider of providers) {
+      const health = healthMultipliers.get(provider) || 1;
+      const score = await this.calculateScore(provider, weights, providers, health);
+      scores.push(score);
+    }
+    scores.sort((a, b) => b.totalScore - a.totalScore);
+    return scores;
+  }
+  /**
+   * Get number of requests tracked for a provider
+   */
+  getRequestCount(provider) {
+    const records = this.metrics.get(provider);
+    return records ? records.length : 0;
+  }
+  /**
+   * Check if provider has sufficient data for scoring
+   */
+  hasSufficientData(provider) {
+    return this.getRequestCount(provider) >= this.minRequests;
+  }
+  /**
+   * Clear metrics for a provider
+   */
+  clearMetrics(provider) {
+    this.metrics.delete(provider);
+    logger.debug("Metrics cleared", { provider });
+  }
+  /**
+   * Clear all metrics
+   */
+  clearAllMetrics() {
+    this.metrics.clear();
+    logger.debug("All metrics cleared");
+  }
+  /**
+   * Get summary of all tracked providers
+   */
+  getSummary() {
+    const summary = {};
+    for (const [provider, records] of this.metrics.entries()) {
+      summary[provider] = {
+        requests: records.length,
+        hasSufficientData: records.length >= this.minRequests
+      };
+    }
+    return summary;
+  }
+  /**
+   * Export metrics for debugging/analysis
+   */
+  async exportMetrics(provider) {
+    const records = this.metrics.get(provider);
+    return records ? [...records] : null;
+  }
+};
+var globalMetricsTracker = null;
+function getProviderMetricsTracker() {
+  if (!globalMetricsTracker) {
+    globalMetricsTracker = new ProviderMetricsTracker();
+  }
+  return globalMetricsTracker;
+}
+
+// src/core/routing-strategy.ts
+init_logger();
+var RoutingStrategyManager = class extends EventEmitter {
+  strategy;
+  metricsTracker;
+  minRequestsForScoring;
+  enableLogging;
+  decisionHistory = [];
+  maxHistorySize = 100;
+  constructor(config = {}) {
+    super();
+    this.metricsTracker = getProviderMetricsTracker();
+    const strategyName = config.strategy || "balanced";
+    this.strategy = this.loadStrategy(strategyName, config.customWeights);
+    this.minRequestsForScoring = config.minRequestsForScoring || 10;
+    this.enableLogging = config.enableLogging || false;
+    if (config.metricsWindow) {
+      this.metricsTracker = new ProviderMetricsTracker({
+        windowSize: config.metricsWindow,
+        minRequests: this.minRequestsForScoring
+      });
+      logger.info("RoutingStrategyManager using isolated metrics tracker", {
+        windowSize: config.metricsWindow,
+        minRequests: this.minRequestsForScoring
+      });
+    }
+    logger.info("RoutingStrategyManager initialized", {
+      strategy: this.strategy.name,
+      weights: this.strategy.weights,
+      minRequestsForScoring: this.minRequestsForScoring
+    });
+  }
+  /**
+   * Load strategy configuration by name
+   */
+  loadStrategy(name, customWeights) {
+    if (name === "custom" && customWeights) {
+      const total = Object.values(customWeights).reduce((sum, w) => sum + w, 0);
+      if (Math.abs(total - 1) > 0.01) {
+        logger.warn("Custom routing weights do not sum to 1.0", {
+          weights: customWeights,
+          total
+        });
+      }
+      return {
+        name: "custom",
+        weights: customWeights
+      };
+    }
+    const strategy = ROUTING_STRATEGIES[name];
+    if (!strategy) {
+      logger.warn("Unknown routing strategy, falling back to balanced", { name });
+      return ROUTING_STRATEGIES.balanced;
+    }
+    return strategy;
+  }
+  /**
+   * Select best provider based on current strategy
+   *
+   * @param providers - Available providers
+   * @param healthMultipliers - Health scores from circuit breaker (0-1)
+   * @param fallbackToPriority - Use priority-based selection if insufficient metrics
+   * @returns Selected provider name or null if none available
+   */
+  async selectProvider(providers, healthMultipliers, fallbackToPriority = true) {
+    if (providers.length === 0) {
+      return null;
+    }
+    const sufficientData = providers.some((p) => this.metricsTracker.getRequestCount(p) >= this.minRequestsForScoring);
+    if (!sufficientData) {
+      if (fallbackToPriority) {
+        const healthyProviders = providers.filter((p) => {
+          const health = healthMultipliers.get(p) ?? 1;
+          return health >= 0.1;
+        });
+        if (healthyProviders.length === 0) {
+          return null;
+        }
+        const selected = healthyProviders[0];
+        if (!selected) {
+          return null;
+        }
+        const decision2 = {
+          selectedProvider: selected,
+          strategy: this.strategy.name,
+          scores: [],
+          reason: "Insufficient metrics data, using priority-based selection with health check",
+          timestamp: Date.now()
+        };
+        this.recordDecision(decision2);
+        return decision2;
+      } else {
+        return null;
+      }
+    }
+    const scores = await this.metricsTracker.getAllScores(
+      providers,
+      this.strategy.weights,
+      healthMultipliers
+    );
+    if (scores.length === 0) {
+      return null;
+    }
+    const best = scores[0];
+    const reason = this.generateReason(best, scores);
+    const decision = {
+      selectedProvider: best.provider,
+      strategy: this.strategy.name,
+      scores,
+      reason,
+      timestamp: Date.now()
+    };
+    this.recordDecision(decision);
+    if (this.enableLogging) {
+      logger.info("Routing decision made", {
+        selected: best.provider,
+        strategy: this.strategy.name,
+        totalScore: best.totalScore.toFixed(3),
+        breakdown: {
+          cost: best.breakdown.costScore.toFixed(3),
+          latency: best.breakdown.latencyScore.toFixed(3),
+          quality: best.breakdown.qualityScore.toFixed(3),
+          availability: best.breakdown.availabilityScore.toFixed(3)
+        },
+        reason
+      });
+    }
+    this.emit("decision", decision);
+    return decision;
+  }
+  /**
+   * Generate human-readable reason for provider selection
+   */
+  generateReason(best, allScores) {
+    const reasons = [];
+    const breakdown = best.breakdown;
+    const weights = this.strategy.weights;
+    const weightedScores = {
+      cost: breakdown.costScore * weights.cost,
+      latency: breakdown.latencyScore * weights.latency,
+      quality: breakdown.qualityScore * weights.quality,
+      availability: breakdown.availabilityScore * weights.availability
+    };
+    const topFactor = Object.entries(weightedScores).sort(([, a], [, b]) => b - a)[0];
+    if (!topFactor) {
+      return `Selected ${best.provider}`;
+    }
+    const [factor, score] = topFactor;
+    switch (this.strategy.name) {
+      case "fast":
+        reasons.push(`Lowest latency (${best.metadata?.avgLatencyMs?.toFixed(0)}ms avg)`);
+        break;
+      case "cheap":
+        reasons.push(`Lowest cost ($${best.metadata?.avgCostPer1M?.toFixed(2)}/1M tokens)`);
+        break;
+      case "quality":
+        reasons.push(`Highest quality (${(best.breakdown.qualityScore * 100).toFixed(1)}% score)`);
+        break;
+      case "balanced":
+        reasons.push(`Best overall balance (score: ${best.totalScore.toFixed(3)})`);
+        break;
+      default:
+        reasons.push(`Custom strategy (${factor} weighted ${(score * 100).toFixed(1)}%)`);
+    }
+    if (best.healthMultiplier < 1) {
+      reasons.push(`adjusted for health (${(best.healthMultiplier * 100).toFixed(0)}%)`);
+    }
+    return reasons.join(", ");
+  }
+  /**
+   * Record routing decision in history
+   */
+  recordDecision(decision) {
+    this.decisionHistory.push(decision);
+    if (this.decisionHistory.length > this.maxHistorySize) {
+      this.decisionHistory.shift();
+    }
+  }
+  /**
+   * Get recent routing decisions
+   */
+  getDecisionHistory(limit = 10) {
+    return this.decisionHistory.slice(-limit);
+  }
+  /**
+   * Get routing statistics
+   */
+  getStats() {
+    const stats = {
+      strategy: this.strategy.name,
+      totalDecisions: this.decisionHistory.length,
+      providerUsage: {},
+      avgScores: {}
+    };
+    for (const decision of this.decisionHistory) {
+      const provider = decision.selectedProvider;
+      stats.providerUsage[provider] = (stats.providerUsage[provider] || 0) + 1;
+    }
+    const scoresByProvider = {};
+    for (const decision of this.decisionHistory) {
+      for (const score of decision.scores) {
+        if (!scoresByProvider[score.provider]) {
+          scoresByProvider[score.provider] = [];
+        }
+        scoresByProvider[score.provider].push(score.totalScore);
+      }
+    }
+    for (const [provider, scores] of Object.entries(scoresByProvider)) {
+      const avg = scores.reduce((sum, s) => sum + s, 0) / scores.length;
+      stats.avgScores[provider] = avg;
+    }
+    return stats;
+  }
+  /**
+   * Get routing statistics (alias for getStats)
+   */
+  getRoutingStats() {
+    return this.getStats();
+  }
+  /**
+   * Update strategy
+   */
+  setStrategy(name, customWeights) {
+    this.strategy = this.loadStrategy(name, customWeights);
+    logger.info("Routing strategy updated", {
+      strategy: this.strategy.name,
+      weights: this.strategy.weights
+    });
+    this.emit("strategy-changed", this.strategy);
+  }
+  /**
+   * Get current strategy
+   */
+  getStrategy() {
+    return { ...this.strategy };
+  }
+  /**
+   * Get current weights
+   */
+  getWeights() {
+    return { ...this.strategy.weights };
+  }
+  /**
+   * Enable/disable logging
+   */
+  setLogging(enabled) {
+    this.enableLogging = enabled;
+  }
+  /**
+   * Get metrics tracker (for advanced use)
+   */
+  getMetricsTracker() {
+    return this.metricsTracker;
+  }
+  /**
+   * Clear decision history
+   */
+  clearHistory() {
+    this.decisionHistory = [];
+    logger.debug("Routing decision history cleared");
+  }
+  /**
+   * Export decision history for analysis
+   */
+  exportHistory() {
+    return [...this.decisionHistory];
+  }
+};
+var globalRoutingStrategy = null;
+function getRoutingStrategyManager(config) {
+  if (!globalRoutingStrategy) {
+    globalRoutingStrategy = new RoutingStrategyManager(config);
+  }
+  return globalRoutingStrategy;
+}
+
 // src/core/router.ts
 var Router = class {
   providers;
@@ -9017,6 +9657,8 @@ var Router = class {
     totalDuration: 0,
     failures: 0
   };
+  // Phase 3: Multi-factor routing
+  useMultiFactorRouting = false;
   constructor(config) {
     this.providers = [...config.providers].sort((a, b) => {
       return a.priority - b.priority;
@@ -9029,6 +9671,14 @@ var Router = class {
     void limitManager.initialize().catch((err) => {
       logger.warn("Failed to initialize ProviderLimitManager", { error: err.message });
     });
+    if (config.strategy) {
+      this.useMultiFactorRouting = true;
+      const strategyManager = getRoutingStrategyManager(config.strategy);
+      logger.info("Multi-factor routing enabled", {
+        strategy: strategyManager.getStrategy().name,
+        weights: strategyManager.getWeights()
+      });
+    }
     this.healthCheckIntervalMs = config.healthCheckInterval;
     if (config.healthCheckInterval) {
       this.startHealthChecks(config.healthCheckInterval);
@@ -9104,9 +9754,37 @@ var Router = class {
       }
       throw ProviderError.noAvailableProviders();
     }
+    let providersToTry = availableProviders;
+    if (this.useMultiFactorRouting) {
+      const strategyManager = getRoutingStrategyManager();
+      const providerNames = availableProviders.map((p) => p.name);
+      const healthMultipliers = /* @__PURE__ */ new Map();
+      for (const provider of availableProviders) {
+        const isPenalized = this.penalizedProviders.has(provider.name);
+        healthMultipliers.set(provider.name, isPenalized ? 0.5 : 1);
+      }
+      const scores = await getProviderMetricsTracker().getAllScores(
+        providerNames,
+        strategyManager.getWeights(),
+        healthMultipliers
+      );
+      if (scores.length > 0) {
+        const scoreMap = new Map(scores.map((s) => [s.provider, s.totalScore]));
+        providersToTry = [...availableProviders].sort((a, b) => {
+          const scoreA = scoreMap.get(a.name) ?? 0;
+          const scoreB = scoreMap.get(b.name) ?? 0;
+          return scoreB - scoreA;
+        });
+        logger.debug("Provider order after multi-factor routing", {
+          original: availableProviders.map((p) => p.name),
+          reordered: providersToTry.map((p) => p.name),
+          scores: Object.fromEntries(scoreMap)
+        });
+      }
+    }
     let lastError;
     let attemptNumber = 0;
-    for (const provider of availableProviders) {
+    for (const provider of providersToTry) {
       attemptNumber++;
       try {
         logger.info(`Selecting provider: ${provider.name} (attempt ${attemptNumber}/${availableProviders.length})`);
@@ -9166,6 +9844,24 @@ var Router = class {
           );
         }
         this.penalizedProviders.delete(provider.name);
+        if (this.useMultiFactorRouting) {
+          const metricsTracker = getProviderMetricsTracker();
+          const estimatedCost = this.estimateCost(provider.name, response.tokensUsed);
+          await metricsTracker.recordRequest(
+            provider.name,
+            response.latencyMs,
+            true,
+            // success
+            response.finishReason || "stop",
+            {
+              prompt: response.tokensUsed.prompt,
+              completion: response.tokensUsed.completion,
+              total: response.tokensUsed.total
+            },
+            estimatedCost,
+            response.model
+          );
+        }
         return response;
       } catch (error) {
         lastError = error;
@@ -9203,6 +9899,22 @@ var Router = class {
           this.penalizedProviders.set(provider.name, penaltyExpiry);
           logger.debug(`Provider ${provider.name} penalized until ${new Date(penaltyExpiry).toISOString()}`);
         }
+        if (this.useMultiFactorRouting) {
+          const metricsTracker = getProviderMetricsTracker();
+          await metricsTracker.recordRequest(
+            provider.name,
+            0,
+            // latency unknown for failed requests
+            false,
+            // failure
+            "error",
+            { prompt: 0, completion: 0, total: 0 },
+            0,
+            // no cost for failed requests
+            void 0
+            // model unknown
+          );
+        }
         if (!this.fallbackEnabled) {
           throw lastError;
         }
@@ -9440,6 +10152,17 @@ var Router = class {
       })
     };
   }
+  /**
+   * Estimate cost of a request based on tokens used
+   * Phase 3: Helper for metrics tracking
+   */
+  estimateCost(providerName, tokensUsed) {
+    const inputCostPer1M = 2.5;
+    const outputCostPer1M = 10;
+    const inputCost = tokensUsed.prompt / 1e6 * inputCostPer1M;
+    const outputCost = tokensUsed.completion / 1e6 * outputCostPer1M;
+    return inputCost + outputCost;
+  }
 };
 
 // src/core/lazy-memory-manager.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defai.digital/automatosx",
-  "version": "5.12.2",
+  "version": "5.12.3",
   "description": "AI Agent Orchestration Platform",
   "type": "module",
   "publishConfig": {