@azumag/opencode-rate-limit-fallback 1.35.0 → 1.36.0

package/dist/src/health/HealthTracker.js

@@ -0,0 +1,353 @@
+/**
+ * Model Health Tracker
+ * Tracks model success rates and response times for health-based selection
+ */
+import { getModelKey } from '../utils/helpers.js';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+/**
+ * Default health persistence path
+ */
+const DEFAULT_HEALTH_PERSISTENCE_PATH = join(homedir(), '.opencode', 'rate-limit-fallback-health.json');
+/**
+ * Minimum requests before health score is considered reliable
+ */
+const MIN_REQUESTS_FOR_RELIABLE_SCORE = 3;
+/**
+ * Default health configuration
+ */
+const DEFAULT_HEALTH_CONFIG = {
+    enabled: true,
+    path: DEFAULT_HEALTH_PERSISTENCE_PATH,
+};
+/**
+ * Model Health Tracker class
+ */
+export class HealthTracker {
+    healthData;
+    persistenceEnabled;
+    persistencePath;
+    healthBasedSelectionEnabled;
+    logger;
+    savePending;
+    saveTimeout;
+    // Configurable thresholds
+    responseTimeThreshold;
+    responseTimePenaltyDivisor;
+    failurePenaltyMultiplier;
+    persistenceDebounceMs;
+    constructor(config, logger) {
+        this.healthData = new Map();
+        // Parse health persistence config
+        const healthPersistence = config.healthPersistence || DEFAULT_HEALTH_CONFIG;
+        this.persistenceEnabled = healthPersistence.enabled !== false;
+        this.persistencePath = healthPersistence.path || DEFAULT_HEALTH_PERSISTENCE_PATH;
+        this.healthBasedSelectionEnabled = config.enableHealthBasedSelection || false;
+        // Initialize logger
+        this.logger = logger;
+        // Initialize save state
+        this.savePending = false;
+        // Initialize configurable thresholds (can be customized via config if needed)
+        this.responseTimeThreshold = 2000; // ms - threshold for response time penalty
+        this.responseTimePenaltyDivisor = 200; // divisor for response time penalty calculation
+        this.failurePenaltyMultiplier = 15; // penalty per consecutive failure
+        this.persistenceDebounceMs = 30000; // 30 seconds debounce for persistence
+        // Load existing state
+        if (this.persistenceEnabled) {
+            this.loadState();
+        }
+    }
+    /**
+     * Record a successful request for a model
+     */
+    recordSuccess(providerID, modelID, responseTime) {
+        const key = getModelKey(providerID, modelID);
+        const now = Date.now();
+        let health = this.healthData.get(key);
+        if (!health) {
+            // Initialize new health entry
+            health = {
+                modelKey: key,
+                providerID,
+                modelID,
+                totalRequests: 0,
+                successfulRequests: 0,
+                failedRequests: 0,
+                consecutiveFailures: 0,
+                avgResponseTime: 0,
+                lastUsed: now,
+                lastSuccess: now,
+                lastFailure: 0,
+                healthScore: 100, // Start with perfect score
+            };
+        }
+        // Update metrics
+        health.totalRequests++;
+        health.successfulRequests++;
+        health.consecutiveFailures = 0;
+        health.lastUsed = now;
+        health.lastSuccess = now;
+        // Update average response time (weighted moving average)
+        if (health.avgResponseTime === 0) {
+            health.avgResponseTime = responseTime;
+        }
+        else {
+            // Weight new response at 30%
+            health.avgResponseTime = Math.round(health.avgResponseTime * 0.7 + responseTime * 0.3);
+        }
+        // Recalculate health score
+        health.healthScore = this.calculateHealthScore(health);
+        this.healthData.set(key, health);
+        // Persist if enabled
+        if (this.persistenceEnabled) {
+            this.saveState();
+        }
+    }
+    /**
+     * Record a failed request for a model
+     */
+    recordFailure(providerID, modelID) {
+        const key = getModelKey(providerID, modelID);
+        const now = Date.now();
+        let health = this.healthData.get(key);
+        if (!health) {
+            // Initialize new health entry
+            health = {
+                modelKey: key,
+                providerID,
+                modelID,
+                totalRequests: 0,
+                successfulRequests: 0,
+                failedRequests: 0,
+                consecutiveFailures: 0,
+                avgResponseTime: 0,
+                lastUsed: now,
+                lastSuccess: 0,
+                lastFailure: now,
+                healthScore: 100,
+            };
+        }
+        // Update metrics
+        health.totalRequests++;
+        health.failedRequests++;
+        health.consecutiveFailures++;
+        health.lastUsed = now;
+        health.lastFailure = now;
+        // Recalculate health score
+        health.healthScore = this.calculateHealthScore(health);
+        this.healthData.set(key, health);
+        // Persist if enabled
+        if (this.persistenceEnabled) {
+            this.saveState();
+        }
+    }
+    /**
+     * Get the health score for a model (0-100)
+     */
+    getHealthScore(providerID, modelID) {
+        const key = getModelKey(providerID, modelID);
+        const health = this.healthData.get(key);
+        if (!health) {
+            return 100; // No data yet - assume healthy
+        }
+        return health.healthScore;
+    }
+    /**
+     * Get full health data for a model
+     */
+    getModelHealth(providerID, modelID) {
+        const key = getModelKey(providerID, modelID);
+        return this.healthData.get(key) || null;
+    }
+    /**
+     * Get all health data
+     */
+    getAllHealthData() {
+        return Array.from(this.healthData.values());
+    }
+    /**
+     * Get healthiest models from a list of candidates
+     * Returns models sorted by health score (highest first)
+     */
+    getHealthiestModels(candidates, limit) {
+        // Map candidates with health scores
+        const scored = candidates.map(model => ({
+            model,
+            score: this.getHealthScore(model.providerID, model.modelID),
+        }));
+        // Sort by health score (descending)
+        scored.sort((a, b) => b.score - a.score);
+        // Return limited results or all
+        const result = scored.map(item => item.model);
+        return limit ? result.slice(0, limit) : result;
+    }
+    /**
+     * Calculate health score based on metrics
+     * Score is 0-100, higher is healthier
+     */
+    calculateHealthScore(health) {
+        let score = 100;
+        // Penalize based on success rate
+        if (health.totalRequests >= MIN_REQUESTS_FOR_RELIABLE_SCORE) {
+            const successRate = health.successfulRequests / health.totalRequests;
+            score = Math.round(score * successRate);
+        }
+        // Penalize consecutive failures heavily
+        const failurePenalty = Math.min(health.consecutiveFailures * this.failurePenaltyMultiplier, 80);
+        score -= failurePenalty;
+        // Penalize slow response times (if we have data)
+        if (health.avgResponseTime > 0) {
+            const responseTimePenalty = Math.min(Math.round((health.avgResponseTime - this.responseTimeThreshold) / this.responseTimePenaltyDivisor), 30);
+            if (responseTimePenalty > 0) {
+                score -= responseTimePenalty;
+            }
+        }
+        // Ensure score is within valid range
+        return Math.max(0, Math.min(100, score));
+    }
+    /**
+     * Save health state to file (with debouncing)
+     */
+    saveState() {
+        if (!this.persistenceEnabled) {
+            return;
+        }
+        // If a save is already pending, don't schedule another one
+        if (this.savePending) {
+            return;
+        }
+        this.savePending = true;
+        // Clear any existing timeout
+        if (this.saveTimeout) {
+            clearTimeout(this.saveTimeout);
+        }
+        // Schedule debounced save
+        this.saveTimeout = setTimeout(() => {
+            this.performSave();
+            this.savePending = false;
+        }, this.persistenceDebounceMs);
+    }
+    /**
+     * Perform the actual save operation
+     */
+    performSave() {
+        try {
+            // Ensure directory exists
+            const dir = dirname(this.persistencePath);
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+            const state = {
+                models: Object.fromEntries(this.healthData.entries()),
+                lastUpdated: Date.now(),
+            };
+            writeFileSync(this.persistencePath, JSON.stringify(state, null, 2), 'utf-8');
+        }
+        catch (error) {
+            // Use logger instead of console
+            this.logger.warn('[HealthTracker] Failed to save state', { error });
+        }
+    }
+    /**
+     * Load health state from file
+     */
+    loadState() {
+        if (!this.persistenceEnabled || !existsSync(this.persistencePath)) {
+            return;
+        }
+        try {
+            const content = readFileSync(this.persistencePath, 'utf-8');
+            const state = JSON.parse(content);
+            // Validate state structure
+            if (state.models && typeof state.models === 'object') {
+                for (const [key, health] of Object.entries(state.models)) {
+                    // Validate health object structure
+                    if (health && typeof health === 'object' && health.modelKey === key) {
+                        this.healthData.set(key, health);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Use logger instead of console
+            this.logger.warn('[HealthTracker] Failed to load state, starting fresh', { error });
+        }
+    }
+    /**
+     * Reset health data for a specific model
+     */
+    resetModelHealth(providerID, modelID) {
+        const key = getModelKey(providerID, modelID);
+        this.healthData.delete(key);
+        if (this.persistenceEnabled) {
+            this.saveState();
+        }
+    }
+    /**
+     * Reset all health data
+     */
+    resetAllHealth() {
+        this.healthData.clear();
+        if (this.persistenceEnabled) {
+            this.saveState();
+        }
+    }
+    /**
+     * Check if health-based selection is enabled
+     */
+    isEnabled() {
+        return this.healthBasedSelectionEnabled;
+    }
+    /**
+     * Get statistics about tracked models
+     */
+    getStats() {
+        const models = Array.from(this.healthData.values());
+        const totalRequests = models.reduce((sum, h) => sum + h.totalRequests, 0);
+        const totalSuccesses = models.reduce((sum, h) => sum + h.successfulRequests, 0);
+        const totalFailures = models.reduce((sum, h) => sum + h.failedRequests, 0);
+        const avgHealthScore = models.length > 0
+            ? Math.round(models.reduce((sum, h) => sum + h.healthScore, 0) / models.length)
+            : 100;
+        const modelsWithReliableData = models.filter(h => h.totalRequests >= MIN_REQUESTS_FOR_RELIABLE_SCORE).length;
+        return {
+            totalTracked: models.length,
+            totalRequests,
+            totalSuccesses,
+            totalFailures,
+            avgHealthScore,
+            modelsWithReliableData,
+        };
+    }
+    /**
+     * Clean up old health data (models not used recently)
+     */
+    cleanupOldEntries(maxAgeMs = 30 * 24 * 60 * 60 * 1000) {
+        // Default: 30 days
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [key, health] of this.healthData.entries()) {
+            if (now - health.lastUsed > maxAgeMs) {
+                this.healthData.delete(key);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0 && this.persistenceEnabled) {
+            this.saveState();
+        }
+        return cleaned;
+    }
+    /**
+     * Destroy the health tracker
+     */
+    destroy() {
+        // Cancel any pending save
+        if (this.saveTimeout) {
+            clearTimeout(this.saveTimeout);
+        }
+        // Save state immediately before cleanup
+        this.performSave();
+        this.healthData.clear();
+    }
+}

package/dist/src/types/index.d.ts

@@ -74,6 +74,53 @@ export interface MetricsConfig {
     output: MetricsOutputConfig;
     resetInterval: "hourly" | "daily" | "weekly";
 }
+/**
+ * Configuration validation options
+ */
+export interface ConfigValidationOptions {
+    strict?: boolean;
+    logWarnings?: boolean;
+}
+/**
+ * Health persistence configuration
+ */
+export interface HealthPersistenceConfig {
+    enabled: boolean;
+    path?: string;
+}
+/**
+ * Health metrics for a model
+ */
+export interface ModelHealth {
+    modelKey: string;
+    providerID: string;
+    modelID: string;
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    consecutiveFailures: number;
+    avgResponseTime: number;
+    lastUsed: number;
+    lastSuccess: number;
+    lastFailure: number;
+    healthScore: number;
+}
+/**
+ * Error pattern definition
+ */
+export interface ErrorPattern {
+    name: string;
+    provider?: string;
+    patterns: (string | RegExp)[];
+    priority: number;
+}
+/**
+ * Error pattern configuration
+ */
+export interface ErrorPatternsConfig {
+    custom?: ErrorPattern[];
+    enableLearning?: boolean;
+}
 /**
  * Plugin configuration
  */
@@ -88,6 +135,11 @@ export interface PluginConfig {
     circuitBreaker?: CircuitBreakerConfig;
     log?: LogConfig;
     metrics?: MetricsConfig;
+    configValidation?: ConfigValidationOptions;
+    enableHealthBasedSelection?: boolean;
+    healthPersistence?: HealthPersistenceConfig;
+    verbose?: boolean;
+    errorPatterns?: ErrorPatternsConfig;
 }
 /**
  * Fallback state for tracking progress

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azumag/opencode-rate-limit-fallback",
-  "version": "1.35.0",
+  "version": "1.36.0",
   "description": "OpenCode plugin that automatically switches to fallback models when rate limited",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/src/utils/errorDetection.d.ts

@@ -1,7 +0,0 @@
-/**
- * Rate limit error detection
- */
-/**
- * Check if error is rate limit related
- */
-export declare function isRateLimitError(error: unknown): boolean;

package/dist/src/utils/errorDetection.js

@@ -1,34 +0,0 @@
-/**
- * Rate limit error detection
- */
-/**
- * Check if error is rate limit related
- */
-export function isRateLimitError(error) {
-    if (!error || typeof error !== "object")
-        return false;
-    // More type-safe error object structure
-    const err = error;
-    // Check for 429 status code in APIError (strict check)
-    if (err.name === "APIError" && err.data?.statusCode === 429) {
-        return true;
-    }
-    // Type-safe access to error fields
-    const responseBody = String(err.data?.responseBody || "").toLowerCase();
-    const message = String(err.data?.message || err.message || "").toLowerCase();
-    // Strict rate limit indicators only - avoid false positives
-    const strictRateLimitIndicators = [
-        "rate limit",
-        "rate_limit",
-        "ratelimit",
-        "too many requests",
-        "quota exceeded",
-    ];
-    // Check for 429 in text (explicit HTTP status code, word-boundary to avoid false positives like "4291")
-    if (/\b429\b/.test(responseBody) || /\b429\b/.test(message)) {
-        return true;
-    }
-    // Check for strict rate limit keywords
-    return strictRateLimitIndicators.some((indicator) => responseBody.includes(indicator) ||
-        message.includes(indicator));
-}