@azumag/opencode-rate-limit-fallback 1.37.0 → 1.40.0

package/dist/src/circuitbreaker/CircuitBreaker.d.ts

@@ -37,6 +37,11 @@ export declare class CircuitBreaker {
      * @returns The current circuit state
      */
     getState(modelKey: string): CircuitBreakerState;
+    /**
+     * Show toast notification for circuit state transition
+     * @private
+     */
+    private showStateTransitionToast;
     /**
      * Clean up stale entries from the circuits map
      */

package/dist/src/circuitbreaker/CircuitBreaker.js

@@ -44,17 +44,8 @@ export class CircuitBreaker {
                 oldState: oldStateType,
                 newState: newStateType,
             });
-            // Show toast notification for HALF_OPEN transition (recovery attempt)
-            if (newStateType === 'HALF_OPEN' && this.client) {
-                safeShowToast(this.client, {
-                    body: {
-                        title: "Circuit Recovery Attempt",
-                        message: `Attempting recovery for ${modelKey} after ${this.config.recoveryTimeoutMs}ms`,
-                        variant: "info",
-                        duration: 3000,
-                    },
-                });
-            }
+            // Show toast notification for state transition
+            this.showStateTransitionToast(modelKey, oldStateType, newStateType);
             // Record metrics
             if (this.metricsManager) {
                 this.metricsManager.recordCircuitBreakerStateTransition(modelKey, oldStateType, newStateType);
@@ -74,23 +65,14 @@ export class CircuitBreaker {
         const oldState = circuit.getState().state;
         circuit.onSuccess();
         const newState = circuit.getState().state;
-        // Log state transition
+        // Log state transition and show toast
         if (oldState !== newState) {
             this.logger.info(`Circuit breaker state changed for ${modelKey}`, {
                 oldState,
                 newState,
             });
-            // Show toast notification for circuit close
-            if (newState === 'CLOSED' && oldState !== 'CLOSED' && this.client) {
-                safeShowToast(this.client, {
-                    body: {
-                        title: "Circuit Closed",
-                        message: `Circuit breaker closed for ${modelKey} - service recovered`,
-                        variant: "success",
-                        duration: 3000,
-                    },
-                });
-            }
+            // Show toast notification for state transition
+            this.showStateTransitionToast(modelKey, oldState, newState);
             // Record metrics
             if (this.metricsManager) {
                 this.metricsManager.recordCircuitBreakerStateTransition(modelKey, oldState, newState);
@@ -115,35 +97,15 @@ export class CircuitBreaker {
         const oldState = circuit.getState().state;
         circuit.onFailure();
         const newState = circuit.getState().state;
-        // Log state transition
+        // Log state transition and show toast
         if (oldState !== newState) {
             this.logger.warn(`Circuit breaker state changed for ${modelKey}`, {
                 oldState,
                 newState,
                 failureCount: circuit.getState().failureCount,
             });
-            // Show toast notification for circuit open
-            if (newState === 'OPEN' && this.client) {
-                safeShowToast(this.client, {
-                    body: {
-                        title: "Circuit Opened",
-                        message: `Circuit breaker opened for ${modelKey} after failure threshold`,
-                        variant: "warning",
-                        duration: 5000,
-                    },
-                });
-            }
-            // Show toast notification for circuit close
-            if (newState === 'CLOSED' && oldState !== 'CLOSED' && this.client) {
-                safeShowToast(this.client, {
-                    body: {
-                        title: "Circuit Closed",
-                        message: `Circuit breaker closed for ${modelKey} - service recovered`,
-                        variant: "success",
-                        duration: 3000,
-                    },
-                });
-            }
+            // Show toast notification for state transition
+            this.showStateTransitionToast(modelKey, oldState, newState);
             // Record metrics
             if (this.metricsManager) {
                 this.metricsManager.recordCircuitBreakerStateTransition(modelKey, oldState, newState);
@@ -169,6 +131,50 @@ export class CircuitBreaker {
         }
         return circuit.getState();
     }
+    /**
+     * Show toast notification for circuit state transition
+     * @private
+     */
+    showStateTransitionToast(modelKey, oldState, newState) {
+        if (!this.client) {
+            return;
+        }
+        switch (newState) {
+            case 'OPEN':
+                safeShowToast(this.client, {
+                    body: {
+                        title: "Circuit Opened",
+                        message: `Circuit breaker opened for ${modelKey} after failure threshold`,
+                        variant: "warning",
+                        duration: 5000,
+                    },
+                });
+                break;
+            case 'HALF_OPEN':
+                safeShowToast(this.client, {
+                    body: {
+                        title: "Circuit Recovery Attempt",
+                        message: `Attempting recovery for ${modelKey} after ${this.config.recoveryTimeoutMs}ms`,
+                        variant: "info",
+                        duration: 3000,
+                    },
+                });
+                break;
+            case 'CLOSED':
+                // Only show toast for circuit close when transitioning from non-CLOSED state
+                if (oldState !== 'CLOSED') {
+                    safeShowToast(this.client, {
+                        body: {
+                            title: "Circuit Closed",
+                            message: `Circuit breaker closed for ${modelKey} - service recovered`,
+                            variant: "success",
+                            duration: 3000,
+                        },
+                    });
+                }
+                break;
+        }
+    }
     /**
      * Clean up stale entries from the circuits map
      */

package/dist/src/config/defaults.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Default configuration constants
+ */
+/**
+ * Default health persistence path
+ */
+export declare const DEFAULT_HEALTH_PERSISTENCE_PATH: string;
+/**
+ * Default health tracker configuration
+ */
+export declare const DEFAULT_HEALTH_TRACKER_CONFIG: {
+    readonly enabled: true;
+    readonly path: string;
+    readonly responseTimeThreshold: 2000;
+    readonly responseTimePenaltyDivisor: 200;
+    readonly failurePenaltyMultiplier: 15;
+    readonly minRequestsForReliableScore: 3;
+};
+/**
+ * Default retry policy configuration
+ */
+export declare const DEFAULT_RETRY_POLICY_CONFIG: {
+    readonly maxRetries: 3;
+    readonly strategy: "immediate";
+    readonly baseDelayMs: 1000;
+    readonly maxDelayMs: 30000;
+    readonly jitterEnabled: false;
+    readonly jitterFactor: 0.1;
+};
+/**
+ * Default polynomial retry parameters
+ */
+export declare const DEFAULT_POLYNOMIAL_BASE = 1.5;
+export declare const DEFAULT_POLYNOMIAL_EXPONENT = 2;
+/**
+ * Default circuit breaker configuration
+ */
+export declare const DEFAULT_CIRCUIT_BREAKER_CONFIG: {
+    readonly enabled: false;
+    readonly failureThreshold: 5;
+    readonly recoveryTimeoutMs: 60000;
+    readonly halfOpenMaxCalls: 1;
+    readonly successThreshold: 2;
+};
+/**
+ * Default cooldown period (ms)
+ */
+export declare const DEFAULT_COOLDOWN_MS: number;
+/**
+ * Default fallback mode
+ */
+export declare const DEFAULT_FALLBACK_MODE: "cycle";
+/**
+ * Default log configuration
+ */
+export declare const DEFAULT_LOG_CONFIG: {
+    readonly level: "warn";
+    readonly format: "simple";
+    readonly enableTimestamp: true;
+};
+/**
+ * Default metrics configuration
+ */
+export declare const DEFAULT_METRICS_CONFIG: {
+    readonly enabled: false;
+    readonly output: {
+        readonly console: true;
+        readonly format: "pretty";
+    };
+    readonly resetInterval: "daily";
+};

package/dist/src/config/defaults.js

@@ -0,0 +1,91 @@
+/**
+ * Default configuration constants
+ */
+import { join } from "path";
+import { homedir } from "os";
+// ============================================================================
+// Health Tracker Defaults
+// ============================================================================
+/**
+ * Default health persistence path
+ */
+export const DEFAULT_HEALTH_PERSISTENCE_PATH = join(homedir(), '.opencode', 'rate-limit-fallback-health.json');
+/**
+ * Default health tracker configuration
+ */
+export const DEFAULT_HEALTH_TRACKER_CONFIG = {
+    enabled: true,
+    path: DEFAULT_HEALTH_PERSISTENCE_PATH,
+    responseTimeThreshold: 2000, // ms - threshold for response time penalty
+    responseTimePenaltyDivisor: 200, // divisor for response time penalty calculation
+    failurePenaltyMultiplier: 15, // penalty per consecutive failure
+    minRequestsForReliableScore: 3, // min requests before score is reliable
+};
+// ============================================================================
+// Retry Defaults
+// ============================================================================
+/**
+ * Default retry policy configuration
+ */
+export const DEFAULT_RETRY_POLICY_CONFIG = {
+    maxRetries: 3,
+    strategy: "immediate",
+    baseDelayMs: 1000,
+    maxDelayMs: 30000,
+    jitterEnabled: false,
+    jitterFactor: 0.1,
+};
+/**
+ * Default polynomial retry parameters
+ */
+export const DEFAULT_POLYNOMIAL_BASE = 1.5;
+export const DEFAULT_POLYNOMIAL_EXPONENT = 2;
+// ============================================================================
+// Circuit Breaker Defaults
+// ============================================================================
+/**
+ * Default circuit breaker configuration
+ */
+export const DEFAULT_CIRCUIT_BREAKER_CONFIG = {
+    enabled: false,
+    failureThreshold: 5,
+    recoveryTimeoutMs: 60000,
+    halfOpenMaxCalls: 1,
+    successThreshold: 2,
+};
+// ============================================================================
+// Plugin Defaults
+// ============================================================================
+/**
+ * Default cooldown period (ms)
+ */
+export const DEFAULT_COOLDOWN_MS = 60 * 1000;
+/**
+ * Default fallback mode
+ */
+export const DEFAULT_FALLBACK_MODE = "cycle";
+// ============================================================================
+// Logging Defaults
+// ============================================================================
+/**
+ * Default log configuration
+ */
+export const DEFAULT_LOG_CONFIG = {
+    level: "warn",
+    format: "simple",
+    enableTimestamp: true,
+};
+// ============================================================================
+// Metrics Defaults
+// ============================================================================
+/**
+ * Default metrics configuration
+ */
+export const DEFAULT_METRICS_CONFIG = {
+    enabled: false,
+    output: {
+        console: true,
+        format: "pretty",
+    },
+    resetInterval: "daily",
+};

package/dist/src/fallback/FallbackHandler.d.ts

@@ -19,6 +19,7 @@ export declare class FallbackHandler {
     private retryState;
     private fallbackInProgress;
     private fallbackMessages;
+    private sessionLock;
     private metricsManager;
     private subagentTracker;
     private retryManager;

package/dist/src/fallback/FallbackHandler.js

@@ -19,6 +19,7 @@ export class FallbackHandler {
     retryState;
     fallbackInProgress;
     fallbackMessages;
+    sessionLock;
     // Metrics manager reference
     metricsManager;
     // Subagent tracker reference
@@ -46,6 +47,7 @@ export class FallbackHandler {
         this.retryState = new Map();
         this.fallbackInProgress = new Map();
         this.fallbackMessages = new Map();
+        this.sessionLock = new Set();
         // Initialize retry manager
         this.retryManager = new RetryManager(config.retryPolicy || {}, logger);
     }
@@ -147,10 +149,16 @@ export class FallbackHandler {
      * Handle the rate limit fallback process
      */
     async handleRateLimitFallback(sessionID, currentProviderID, currentModelID) {
+        // Resolve target session before acquiring lock
+        const rootSessionID = this.subagentTracker.getRootSession(sessionID);
+        const targetSessionID = rootSessionID || sessionID;
+        // Session-level lock: prevent concurrent fallback processing
+        if (this.sessionLock.has(targetSessionID)) {
+            this.logger.debug(`Fallback already in progress for session ${targetSessionID}, skipping`);
+            return;
+        }
+        this.sessionLock.add(targetSessionID);
         try {
-            // Get root session and hierarchy using subagent tracker
-            const rootSessionID = this.subagentTracker.getRootSession(sessionID);
-            const targetSessionID = rootSessionID || sessionID;
             const hierarchy = this.subagentTracker.getHierarchy(sessionID);
             // If no model info provided, try to get from tracked session model
             if (!currentProviderID || !currentModelID) {
@@ -309,10 +317,11 @@ export class FallbackHandler {
                 name: errorName,
             });
             // Record retry failure on error
-            const rootSessionID = this.subagentTracker.getRootSession(sessionID);
-            const targetSessionID = rootSessionID || sessionID;
             this.retryManager.recordFailure(targetSessionID);
         }
+        finally {
+            this.sessionLock.delete(targetSessionID);
+        }
     }
     /**
      * Handle message updated events for metrics recording
@@ -419,6 +428,7 @@ export class FallbackHandler {
         this.retryState.clear();
         this.fallbackInProgress.clear();
         this.fallbackMessages.clear();
+        this.sessionLock.clear();
         this.retryManager.destroy();
         // Destroy circuit breaker
         if (this.circuitBreaker) {

package/dist/src/health/HealthTracker.d.ts

@@ -18,6 +18,7 @@ export declare class HealthTracker {
     private responseTimeThreshold;
     private responseTimePenaltyDivisor;
     private failurePenaltyMultiplier;
+    private minRequestsForReliableScore;
     private persistenceDebounceMs;
     constructor(config: PluginConfig, logger: Logger);
     /**

package/dist/src/health/HealthTracker.js

@@ -4,23 +4,12 @@
  */
 import { getModelKey } from '../utils/helpers.js';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { homedir } from 'os';
+import { dirname } from 'path';
+import { DEFAULT_HEALTH_TRACKER_CONFIG } from '../config/defaults.js';
 /**
- * Default health persistence path
+ * Default health tracker configuration
  */
-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,
-};
+const DEFAULT_HEALTH_CONFIG = DEFAULT_HEALTH_TRACKER_CONFIG;
 /**
  * Model Health Tracker class
  */
@@ -36,22 +25,26 @@ export class HealthTracker {
     responseTimeThreshold;
     responseTimePenaltyDivisor;
     failurePenaltyMultiplier;
+    minRequestsForReliableScore;
     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;
+        const healthConfig = config.healthPersistence
+            ? { ...DEFAULT_HEALTH_CONFIG, ...config.healthPersistence }
+            : DEFAULT_HEALTH_CONFIG;
+        this.persistenceEnabled = healthConfig.enabled !== false;
+        this.persistencePath = healthConfig.path || DEFAULT_HEALTH_CONFIG.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
+        // Initialize configurable thresholds from config
+        this.responseTimeThreshold = healthConfig.responseTimeThreshold ?? DEFAULT_HEALTH_CONFIG.responseTimeThreshold;
+        this.responseTimePenaltyDivisor = healthConfig.responseTimePenaltyDivisor ?? DEFAULT_HEALTH_CONFIG.responseTimePenaltyDivisor;
+        this.failurePenaltyMultiplier = healthConfig.failurePenaltyMultiplier ?? DEFAULT_HEALTH_CONFIG.failurePenaltyMultiplier;
+        this.minRequestsForReliableScore = healthConfig.minRequestsForReliableScore ?? DEFAULT_HEALTH_CONFIG.minRequestsForReliableScore;
         this.persistenceDebounceMs = 30000; // 30 seconds debounce for persistence
         // Load existing state
         if (this.persistenceEnabled) {
@@ -189,7 +182,7 @@ export class HealthTracker {
     calculateHealthScore(health) {
         let score = 100;
         // Penalize based on success rate
-        if (health.totalRequests >= MIN_REQUESTS_FOR_RELIABLE_SCORE) {
+        if (health.totalRequests >= this.minRequestsForReliableScore) {
             const successRate = health.successfulRequests / health.totalRequests;
             score = Math.round(score * successRate);
         }
@@ -310,7 +303,7 @@ export class HealthTracker {
         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;
+        const modelsWithReliableData = models.filter(h => h.totalRequests >= this.minRequestsForReliableScore).length;
         return {
             totalTracked: models.length,
             totalRequests,

package/dist/src/retry/RetryManager.d.ts

@@ -36,6 +36,14 @@ export declare class RetryManager {
      * Calculate linear backoff delay
      */
     private calculateLinearDelay;
+    /**
+     * Calculate polynomial backoff delay
+     */
+    private calculatePolynomialDelay;
+    /**
+     * Calculate custom backoff delay
+     */
+    private calculateCustomDelay;
     /**
      * Apply jitter to delay
      */

package/dist/src/retry/RetryManager.js

@@ -26,6 +26,10 @@ export class RetryManager {
             this.logger.warn('Invalid strategy, using default', { strategy: this.config.strategy });
             this.config.strategy = DEFAULT_RETRY_POLICY.strategy;
         }
+        if (this.config.strategy === 'custom' && typeof this.config.customStrategy !== 'function') {
+            this.logger.warn('Custom strategy selected but customStrategy is not a function, using immediate');
+            this.config.strategy = 'immediate';
+        }
         if (this.config.maxRetries < 0) {
             this.logger.warn('Invalid maxRetries, using default', { maxRetries: this.config.maxRetries });
             this.config.maxRetries = DEFAULT_RETRY_POLICY.maxRetries;
@@ -46,6 +50,14 @@ export class RetryManager {
             this.logger.warn('Invalid jitterFactor, using default', { jitterFactor: this.config.jitterFactor });
             this.config.jitterFactor = DEFAULT_RETRY_POLICY.jitterFactor;
         }
+        if (this.config.polynomialBase !== undefined && this.config.polynomialBase <= 0) {
+            this.logger.warn('Invalid polynomialBase, using default', { polynomialBase: this.config.polynomialBase });
+            this.config.polynomialBase = DEFAULT_RETRY_POLICY.polynomialBase;
+        }
+        if (this.config.polynomialExponent !== undefined && this.config.polynomialExponent <= 0) {
+            this.logger.warn('Invalid polynomialExponent, using default', { polynomialExponent: this.config.polynomialExponent });
+            this.config.polynomialExponent = DEFAULT_RETRY_POLICY.polynomialExponent;
+        }
         if (this.config.timeoutMs !== undefined && this.config.timeoutMs < 0) {
             this.logger.warn('Invalid timeoutMs, ignoring', { timeoutMs: this.config.timeoutMs });
             this.config.timeoutMs = undefined;
@@ -96,6 +108,12 @@ export class RetryManager {
             case "linear":
                 delay = this.calculateLinearDelay(attempt.attemptCount);
                 break;
+            case "polynomial":
+                delay = this.calculatePolynomialDelay(attempt.attemptCount);
+                break;
+            case "custom":
+                delay = this.calculateCustomDelay(attempt.attemptCount);
+                break;
             case "immediate":
             default:
                 delay = 0;
@@ -121,6 +139,50 @@ export class RetryManager {
         const linearDelay = this.config.baseDelayMs * (attemptCount + 1);
         return Math.min(linearDelay, this.config.maxDelayMs);
     }
+    /**
+     * Calculate polynomial backoff delay
+     */
+    calculatePolynomialDelay(attemptCount) {
+        const base = this.config.polynomialBase || 1.5;
+        const exponent = this.config.polynomialExponent || 2;
+        const polynomialDelay = this.config.baseDelayMs * Math.pow(base, attemptCount * exponent);
+        return Math.min(polynomialDelay, this.config.maxDelayMs);
+    }
+    /**
+     * Calculate custom backoff delay
+     */
+    calculateCustomDelay(attemptCount) {
+        if (this.config.customStrategy) {
+            try {
+                const rawDelay = this.config.customStrategy(attemptCount);
+                // Validate and clamp the delay to valid range
+                const clampedDelay = Math.max(0, Math.min(rawDelay, this.config.maxDelayMs));
+                // Log warnings if value was clamped
+                if (rawDelay < 0) {
+                    this.logger.warn('Custom strategy returned negative delay, clamping to 0', {
+                        rawDelay,
+                        attemptCount,
+                    });
+                }
+                else if (rawDelay > this.config.maxDelayMs) {
+                    this.logger.warn('Custom strategy returned delay exceeding maxDelayMs, clamping', {
+                        rawDelay,
+                        maxDelayMs: this.config.maxDelayMs,
+                        attemptCount,
+                    });
+                }
+                return clampedDelay;
+            }
+            catch (error) {
+                this.logger.error('Custom strategy function threw error, using immediate', { error, attemptCount });
+                return 0;
+            }
+        }
+        else {
+            this.logger.warn('Custom strategy selected but no customStrategy function provided, using immediate');
+            return 0;
+        }
+    }
     /**
      * Apply jitter to delay
      */

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

@@ -19,8 +19,21 @@ export interface FallbackModel {
 export type FallbackMode = "cycle" | "stop" | "retry-last";
 /**
  * Retry strategy type
+ * - "immediate": Retry immediately without delay
+ * - "exponential": Exponential backoff (baseDelayMs * 2^attempt)
+ * - "linear": Linear backoff (baseDelayMs * (attempt + 1))
+ * - "polynomial": Polynomial backoff (polynomialBase ^ polynomialExponent * attempt * baseDelayMs)
+ * - "custom": Use custom function (TypeScript/JS configuration only, not JSON)
  */
-export type RetryStrategy = "immediate" | "exponential" | "linear" | "custom";
+export type RetryStrategy = "immediate" | "exponential" | "linear" | "polynomial" | "custom";
+/**
+ * Custom retry strategy function (for TypeScript/JavaScript configuration only)
+ * Note: This only works when configured programmatically in TypeScript/JS, not in JSON files.
+ * For JSON configuration, use named strategies like "polynomial".
+ * @param attemptCount - The current attempt count (0-indexed)
+ * @returns The delay in milliseconds before the next retry
+ */
+export type CustomRetryStrategyFn = (attemptCount: number) => number;
 /**
  * Retry policy configuration
  */
@@ -32,6 +45,9 @@ export interface RetryPolicy {
     jitterEnabled: boolean;
     jitterFactor: number;
     timeoutMs?: number;
+    polynomialBase?: number;
+    polynomialExponent?: number;
+    customStrategy?: CustomRetryStrategyFn;
 }
 /**
  * Circuit breaker state
@@ -82,12 +98,21 @@ export interface ConfigValidationOptions {
     logWarnings?: boolean;
 }
 /**
- * Health persistence configuration
+ * Health tracker configuration
  */
-export interface HealthPersistenceConfig {
+export interface HealthTrackerConfig {
     enabled: boolean;
     path?: string;
+    responseTimeThreshold?: number;
+    responseTimePenaltyDivisor?: number;
+    failurePenaltyMultiplier?: number;
+    minRequestsForReliableScore?: number;
 }
+/**
+ * Health persistence configuration (alias for HealthTrackerConfig)
+ * Use this for backward compatibility.
+ */
+export type HealthPersistenceConfig = HealthTrackerConfig;
 /**
  * Health metrics for a model
  */

package/dist/src/types/index.js

@@ -22,6 +22,8 @@ export const DEFAULT_RETRY_POLICY = {
     maxDelayMs: 30000,
     jitterEnabled: false,
     jitterFactor: 0.1,
+    polynomialBase: 1.5,
+    polynomialExponent: 2,
 };
 /**
  * Default circuit breaker configuration
@@ -40,7 +42,7 @@ export const VALID_FALLBACK_MODES = ["cycle", "stop", "retry-last"];
 /**
  * Valid retry strategies
  */
-export const VALID_RETRY_STRATEGIES = ["immediate", "exponential", "linear", "custom"];
+export const VALID_RETRY_STRATEGIES = ["immediate", "exponential", "linear", "polynomial", "custom"];
 /**
  * Valid reset intervals
  */

package/dist/src/utils/config.js

@@ -4,29 +4,20 @@
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 import { DEFAULT_FALLBACK_MODELS, VALID_FALLBACK_MODES, VALID_RESET_INTERVALS, DEFAULT_RETRY_POLICY, VALID_RETRY_STRATEGIES, DEFAULT_CIRCUIT_BREAKER_CONFIG, } from '../types/index.js';
+import { DEFAULT_HEALTH_TRACKER_CONFIG, DEFAULT_COOLDOWN_MS, DEFAULT_FALLBACK_MODE, DEFAULT_LOG_CONFIG, DEFAULT_METRICS_CONFIG, } from '../config/defaults.js';
 /**
  * Default plugin configuration
  */
 export const DEFAULT_CONFIG = {
     fallbackModels: DEFAULT_FALLBACK_MODELS,
-    cooldownMs: 60 * 1000,
+    cooldownMs: DEFAULT_COOLDOWN_MS,
     enabled: true,
-    fallbackMode: "cycle",
+    fallbackMode: DEFAULT_FALLBACK_MODE,
     retryPolicy: DEFAULT_RETRY_POLICY,
     circuitBreaker: DEFAULT_CIRCUIT_BREAKER_CONFIG,
-    log: {
-        level: "warn",
-        format: "simple",
-        enableTimestamp: true,
-    },
-    metrics: {
-        enabled: false,
-        output: {
-            console: true,
-            format: "pretty",
-        },
-        resetInterval: "daily",
-    },
+    healthPersistence: DEFAULT_HEALTH_TRACKER_CONFIG,
+    log: DEFAULT_LOG_CONFIG,
+    metrics: DEFAULT_METRICS_CONFIG,
 };
 /**
  * Validate configuration values
@@ -49,6 +40,10 @@ export function validateConfig(config) {
             ...DEFAULT_CONFIG.circuitBreaker,
             ...config.circuitBreaker,
         } : DEFAULT_CONFIG.circuitBreaker,
+        healthPersistence: config.healthPersistence ? {
+            ...DEFAULT_CONFIG.healthPersistence,
+            ...config.healthPersistence,
+        } : DEFAULT_CONFIG.healthPersistence,
         log: config.log ? { ...DEFAULT_CONFIG.log, ...config.log } : DEFAULT_CONFIG.log,
         metrics: config.metrics ? {
             ...DEFAULT_CONFIG.metrics,
@@ -89,10 +84,8 @@ export function loadConfig(directory, worktree) {
                 const userConfig = JSON.parse(content);
                 return { config: validateConfig(userConfig), source: configPath };
             }
-            catch (error) {
-                // Log config errors to console immediately before logger is initialized
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                console.error(`[RateLimitFallback] Failed to load config from ${configPath}:`, errorMessage);
+            catch {
+                // Skip invalid config files silently - caller will log via structured logger
             }
         }
     }

package/package.json

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