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

package/README.md

@@ -17,10 +17,11 @@ OpenCode plugin that automatically switches to fallback models when rate limited
   - Jitter to prevent thundering herd problem
   - Configurable retry limits and timeouts
   - Retry statistics tracking
-- Toast notifications for user feedback
-- Subagent session support with automatic fallback propagation to parent sessions
-- Configurable maximum subagent nesting depth
-- **Metrics collection** to track rate limits, fallbacks, and model performance
+ - Toast notifications for user feedback
+ - Subagent session support with automatic fallback propagation to parent sessions
+ - Configurable maximum subagent nesting depth
+ - **Circuit breaker pattern** to prevent cascading failures from consistently failing models
+ - **Metrics collection** to track rate limits, fallbacks, and model performance
 
 ## Installation
 
@@ -85,21 +86,29 @@ Create a configuration file at one of these locations:
       "format": "pretty"
     },
     "resetInterval": "daily"
+  },
+  "circuitBreaker": {
+    "enabled": true,
+    "failureThreshold": 5,
+    "recoveryTimeoutMs": 60000,
+    "halfOpenMaxCalls": 1,
+    "successThreshold": 2
   }
 }
 ```
 
 ### Configuration Options
 
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `enabled` | boolean | `true` | Enable/disable the plugin |
-| `cooldownMs` | number | `60000` | Cooldown period (ms) before retrying a rate-limited model |
-| `fallbackMode` | string | `"cycle"` | Behavior when all models are exhausted (see below) |
-| `fallbackModels` | array | See below | List of fallback models in priority order |
-| `maxSubagentDepth` | number | `10` | Maximum nesting depth for subagent hierarchies |
-| `enableSubagentFallback` | boolean | `true` | Enable/disable fallback for subagent sessions |
-| `retryPolicy` | object | See below | Retry policy configuration (see below) |
+ | Option | Type | Default | Description |
+ |--------|------|---------|-------------|
+ | `enabled` | boolean | `true` | Enable/disable the plugin |
+ | `cooldownMs` | number | `60000` | Cooldown period (ms) before retrying a rate-limited model |
+ | `fallbackMode` | string | `"cycle"` | Behavior when all models are exhausted (see below) |
+ | `fallbackModels` | array | See below | List of fallback models in priority order |
+ | `maxSubagentDepth` | number | `10` | Maximum nesting depth for subagent hierarchies |
+ | `enableSubagentFallback` | boolean | `true` | Enable/disable fallback for subagent sessions |
+ | `retryPolicy` | object | See below | Retry policy configuration (see below) |
+ | `circuitBreaker` | object | See below | Circuit breaker configuration (see below) |
 
 ### Fallback Modes
 
@@ -163,11 +172,56 @@ Example with `baseDelayMs: 1000` and `maxDelayMs: 5000`:
 
 Jitter adds random variation to delay times to prevent the "thundering herd" problem, where multiple clients retry simultaneously and overwhelm the API.
 
-- Recommended for production environments with multiple concurrent users
-- `jitterFactor: 0.1` adds ±10% variance to delay times
-- Example: With base delay of 1000ms and jitterFactor 0.1, actual delay will be 900-1100ms
+ - Recommended for production environments with multiple concurrent users
+ - `jitterFactor: 0.1` adds ±10% variance to delay times
+ - Example: With base delay of 1000ms and jitterFactor 0.1, actual delay will be 900-1100ms
+
+### Circuit Breaker
+
+The circuit breaker pattern prevents cascading failures by temporarily disabling models that are consistently failing (not due to rate limits).
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `circuitBreaker.enabled` | boolean | `false` | Enable/disable circuit breaker |
+| `circuitBreaker.failureThreshold` | number | `5` | Consecutive failures before opening circuit |
+| `circuitBreaker.recoveryTimeoutMs` | number | `60000` | Wait time before attempting recovery (ms) |
+| `circuitBreaker.halfOpenMaxCalls` | number | `1` | Max calls allowed in HALF_OPEN state |
+| `circuitBreaker.successThreshold` | number | `2` | Successes needed to close circuit |
+
+#### How It Works
+
+The circuit breaker maintains three states for each model:
+
+1. **CLOSED State**: Normal operation, requests pass through
+   - Failures are counted until the threshold is reached
+   - On threshold breach, transitions to OPEN state
 
-### Default Fallback Models
+2. **OPEN State**: Model is failing, requests fail fast
+   - The circuit is "open" to prevent unnecessary API calls
+   - No requests are allowed through
+   - After the recovery timeout, transitions to HALF_OPEN state
+
+3. **HALF_OPEN State**: Testing if model recovered after timeout
+   - A limited number of test requests are allowed
+   - On success, transitions back to CLOSED state
+   - On failure, returns to OPEN state
+
+#### Important Notes
+
+- **Rate limit errors are NOT counted as failures**: The circuit breaker only tracks actual failures, not rate limit errors
+- **Disabled by default**: Set `circuitBreaker.enabled: true` to activate this feature
+- **Per-model tracking**: Each model has its own circuit state
+- **Toast notifications**: Users are notified when circuits open/close for awareness
+
+#### Configuration Recommendations
+
+| Environment | failureThreshold | recoveryTimeoutMs | halfOpenMaxCalls |
+|-------------|------------------|-------------------|------------------|
+| Development | 3 | 30000 | 1 |
+| Production | 5 | 60000 | 1 |
+| High Availability | 10 | 30000 | 2 |
+
+ ### Default Fallback Models
 
 If no configuration is provided, the following models are used:
 
@@ -206,11 +260,12 @@ When OpenCode uses subagents (e.g., for complex tasks requiring specialized agen
 
 ## Metrics
 
-The plugin includes a metrics collection feature that tracks:
-- Rate limit events per provider/model
-- Fallback statistics (total, successful, failed, average duration)
-- **Retry statistics** (total attempts, successes, failures, average delay)
-- Model performance (requests, successes, failures, response time)
+ The plugin includes a metrics collection feature that tracks:
+ - Rate limit events per provider/model
+ - Fallback statistics (total, successful, failed, average duration)
+ - **Retry statistics** (total attempts, successes, failures, average delay)
+ - Model performance (requests, successes, failures, response time)
+ - **Circuit breaker statistics** (state transitions, open/closed counts)
 
 ### Metrics Configuration
 
@@ -284,15 +339,28 @@ Retries:
 
 Model Performance:
 ----------------------------------------
-  google/gemini-2.5-pro:
-    Requests: 10
-    Successes: 9
-    Failures: 1
-    Avg Response: 0.85s
-    Success Rate: 90.0%
-```
-
-**JSON** (machine-readable):
+   google/gemini-2.5-pro:
+     Requests: 10
+     Successes: 9
+     Failures: 1
+     Avg Response: 0.85s
+     Success Rate: 90.0%
+
+ Circuit Breaker:
+ ----------------------------------------
+   anthropic/claude-3-5-sonnet-20250514:
+     State: OPEN
+     Failures: 5
+     Successes: 0
+     State Transitions: 2
+   google/gemini-2.5-pro:
+     State: CLOSED
+     Failures: 2
+     Successes: 8
+     State Transitions: 3
+ ```
+
+ **JSON** (machine-readable):
 ```json
 {
   "rateLimits": {
@@ -332,18 +400,32 @@ Model Performance:
       }
     }
   },
-  "modelPerformance": {
-    "google/gemini-2.5-pro": {
-      "requests": 10,
-      "successes": 9,
-      "failures": 1,
-      "averageResponseTime": 850
-    }
-  },
-  "startedAt": 1739148000000,
-  "generatedAt": 1739149800000
-}
-```
+   "modelPerformance": {
+     "google/gemini-2.5-pro": {
+       "requests": 10,
+       "successes": 9,
+       "failures": 1,
+       "averageResponseTime": 850
+     }
+   },
+   "circuitBreaker": {
+     "anthropic/claude-3-5-sonnet-20250514": {
+       "currentState": "OPEN",
+       "failures": 5,
+       "successes": 0,
+       "stateTransitions": 2
+     },
+     "google/gemini-2.5-pro": {
+       "currentState": "CLOSED",
+       "failures": 2,
+       "successes": 8,
+       "stateTransitions": 3
+     }
+   },
+   "startedAt": 1739148000000,
+   "generatedAt": 1739149800000
+ }
+ ```
 
 **CSV** (spreadsheet-friendly):
 ```
@@ -364,10 +446,15 @@ model,attempts,successes,success_rate
 anthropic/claude-3-5-sonnet-20250514,5,3,60.0
 google/gemini-2.5-pro,7,5,71.4
 
-=== MODEL_PERFORMANCE ===
-model,requests,successes,failures,avg_response_time_ms,success_rate
-google/gemini-2.5-pro,10,9,1,850,90.0
-```
+ === MODEL_PERFORMANCE ===
+ model,requests,successes,failures,avg_response_time_ms,success_rate
+ google/gemini-2.5-pro,10,9,1,850,90.0
+
+ === CIRCUIT_BREAKER ===
+ model,current_state,failures,successes,state_transitions
+ anthropic/claude-3-5-sonnet-20250514,OPEN,5,0,2
+ google/gemini-2.5-pro,CLOSED,2,8,3
+ ```
 
 ## License
 

package/dist/index.d.ts

@@ -6,5 +6,5 @@
 import type { Plugin } from "@opencode-ai/plugin";
 export declare const RateLimitFallback: Plugin;
 export default RateLimitFallback;
-export type { PluginConfig, MetricsConfig, FallbackModel, FallbackMode } from "./src/types/index.js";
+export type { PluginConfig, MetricsConfig, FallbackModel, FallbackMode, CircuitBreakerConfig, CircuitBreakerState, CircuitBreakerStateType } from "./src/types/index.js";
 export type { LogConfig, Logger } from "./logger.js";

package/dist/index.js

@@ -53,8 +53,8 @@ function isSubagentSessionCreatedEvent(event) {
 // ============================================================================
 // Main Plugin Export
 // ============================================================================
-export const RateLimitFallback = async ({ client, directory }) => {
-    const config = loadConfig(directory);
+export const RateLimitFallback = async ({ client, directory, worktree }) => {
+    const { config, source: configSource } = loadConfig(directory, worktree);
     // Detect headless mode (no TUI)
     const isHeadless = !client.tui;
     // Auto-adjust log level for headless mode to ensure visibility
@@ -64,6 +64,12 @@ export const RateLimitFallback = async ({ client, directory }) => {
     };
     // Create logger instance
     const logger = createLogger(logConfig, "RateLimitFallback");
+    if (configSource) {
+        logger.info(`Config loaded from ${configSource}`);
+    }
+    else {
+        logger.info("No config file found, using defaults");
+    }
     if (!config.enabled) {
         return {};
     }

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

@@ -0,0 +1,53 @@
+/**
+ * Circuit Breaker - Manages circuit breakers for multiple models
+ */
+import type { Logger } from '../../logger.js';
+import type { CircuitBreakerConfig, CircuitBreakerState, OpenCodeClient } from '../types/index.js';
+import type { MetricsManager } from '../metrics/MetricsManager.js';
+/**
+ * CircuitBreaker class - Manages circuit breaker logic for models
+ */
+export declare class CircuitBreaker {
+    private circuits;
+    private config;
+    private logger;
+    private metricsManager?;
+    private client?;
+    constructor(config: CircuitBreakerConfig, logger: Logger, metricsManager?: MetricsManager, client?: OpenCodeClient);
+    /**
+     * Check if a request should be allowed for a model
+     * @param modelKey - The model key (providerID/modelID)
+     * @returns true if request is allowed, false otherwise
+     */
+    canExecute(modelKey: string): boolean;
+    /**
+     * Record a successful request for a model
+     * @param modelKey - The model key (providerID/modelID)
+     */
+    recordSuccess(modelKey: string): void;
+    /**
+     * Record a failed request for a model
+     * @param modelKey - The model key (providerID/modelID)
+     * @param isRateLimit - true if the failure was due to rate limiting
+     */
+    recordFailure(modelKey: string, isRateLimit: boolean): void;
+    /**
+     * Get the current state of a circuit
+     * @param modelKey - The model key (providerID/modelID)
+     * @returns The current circuit state
+     */
+    getState(modelKey: string): CircuitBreakerState;
+    /**
+     * Clean up stale entries from the circuits map
+     */
+    cleanupStaleEntries(): void;
+    /**
+     * Get or create a circuit for a model
+     * @private
+     */
+    private getOrCreateCircuit;
+    /**
+     * Destroy the circuit breaker and clean up resources
+     */
+    destroy(): void;
+}

package/dist/src/circuitbreaker/CircuitBreaker.js

@@ -0,0 +1,208 @@
+/**
+ * Circuit Breaker - Manages circuit breakers for multiple models
+ */
+import { CircuitState } from './CircuitState.js';
+import { safeShowToast } from '../utils/helpers.js';
+/**
+ * CircuitBreaker class - Manages circuit breaker logic for models
+ */
+export class CircuitBreaker {
+    circuits;
+    config;
+    logger;
+    metricsManager;
+    client;
+    constructor(config, logger, metricsManager, client) {
+        this.config = config;
+        this.logger = logger;
+        this.metricsManager = metricsManager;
+        this.client = client;
+        this.circuits = new Map();
+    }
+    /**
+     * Check if a request should be allowed for a model
+     * @param modelKey - The model key (providerID/modelID)
+     * @returns true if request is allowed, false otherwise
+     */
+    canExecute(modelKey) {
+        if (!this.config.enabled) {
+            return true;
+        }
+        const circuit = this.getOrCreateCircuit(modelKey);
+        const { allowed, transition } = circuit.canExecute();
+        const state = circuit.getState();
+        this.logger.debug(`Circuit breaker check for ${modelKey}`, {
+            state: state.state,
+            allowed,
+            failureCount: state.failureCount,
+        });
+        // Log and record transition if occurred
+        if (transition) {
+            const oldStateType = transition.from;
+            const newStateType = transition.to;
+            this.logger.info(`Circuit breaker state changed for ${modelKey}`, {
+                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,
+                    },
+                });
+            }
+            // Record metrics
+            if (this.metricsManager) {
+                this.metricsManager.recordCircuitBreakerStateTransition(modelKey, oldStateType, newStateType);
+            }
+        }
+        return allowed;
+    }
+    /**
+     * Record a successful request for a model
+     * @param modelKey - The model key (providerID/modelID)
+     */
+    recordSuccess(modelKey) {
+        if (!this.config.enabled) {
+            return;
+        }
+        const circuit = this.getOrCreateCircuit(modelKey);
+        const oldState = circuit.getState().state;
+        circuit.onSuccess();
+        const newState = circuit.getState().state;
+        // Log state transition
+        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,
+                    },
+                });
+            }
+            // Record metrics
+            if (this.metricsManager) {
+                this.metricsManager.recordCircuitBreakerStateTransition(modelKey, oldState, newState);
+            }
+        }
+    }
+    /**
+     * Record a failed request for a model
+     * @param modelKey - The model key (providerID/modelID)
+     * @param isRateLimit - true if the failure was due to rate limiting
+     */
+    recordFailure(modelKey, isRateLimit) {
+        if (!this.config.enabled) {
+            return;
+        }
+        // Rate limit errors don't count as circuit failures
+        if (isRateLimit) {
+            this.logger.debug(`Rate limit error for ${modelKey}, not counting as circuit failure`);
+            return;
+        }
+        const circuit = this.getOrCreateCircuit(modelKey);
+        const oldState = circuit.getState().state;
+        circuit.onFailure();
+        const newState = circuit.getState().state;
+        // Log state transition
+        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,
+                    },
+                });
+            }
+            // Record metrics
+            if (this.metricsManager) {
+                this.metricsManager.recordCircuitBreakerStateTransition(modelKey, oldState, newState);
+            }
+        }
+    }
+    /**
+     * Get the current state of a circuit
+     * @param modelKey - The model key (providerID/modelID)
+     * @returns The current circuit state
+     */
+    getState(modelKey) {
+        const circuit = this.circuits.get(modelKey);
+        if (!circuit) {
+            return {
+                state: 'CLOSED',
+                failureCount: 0,
+                successCount: 0,
+                lastFailureTime: 0,
+                lastSuccessTime: 0,
+                nextAttemptTime: 0,
+            };
+        }
+        return circuit.getState();
+    }
+    /**
+     * Clean up stale entries from the circuits map
+     */
+    cleanupStaleEntries() {
+        const now = Date.now();
+        const cutoffTime = now - (24 * 60 * 60 * 1000); // 24 hours
+        for (const [key, circuit] of this.circuits.entries()) {
+            const state = circuit.getState();
+            const lastActivity = Math.max(state.lastFailureTime, state.lastSuccessTime);
+            // Remove circuits that haven't been active for 24 hours
+            if (lastActivity < cutoffTime) {
+                this.circuits.delete(key);
+                this.logger.debug(`Cleaned up stale circuit for ${key}`);
+            }
+        }
+    }
+    /**
+     * Get or create a circuit for a model
+     * @private
+     */
+    getOrCreateCircuit(modelKey) {
+        let circuit = this.circuits.get(modelKey);
+        if (!circuit) {
+            circuit = new CircuitState(this.config);
+            this.circuits.set(modelKey, circuit);
+            this.logger.debug(`Created new circuit for ${modelKey}`);
+        }
+        return circuit;
+    }
+    /**
+     * Destroy the circuit breaker and clean up resources
+     */
+    destroy() {
+        this.circuits.clear();
+        this.logger.debug('Circuit breaker destroyed');
+    }
+}

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

@@ -0,0 +1,44 @@
+/**
+ * Circuit State - State machine for individual circuit breaker state
+ */
+import type { CircuitBreakerConfig, CircuitBreakerState, CircuitBreakerStateType } from '../types/index.js';
+/**
+ * Return type for canExecute method
+ */
+export interface CanExecuteResult {
+    allowed: boolean;
+    transition?: {
+        from: CircuitBreakerStateType;
+        to: CircuitBreakerStateType;
+    };
+}
+/**
+ * CircuitState class - Manages state transitions for a single circuit
+ */
+export declare class CircuitState {
+    state: CircuitBreakerState;
+    private halfOpenCalls;
+    private config;
+    constructor(config: CircuitBreakerConfig);
+    /**
+     * Handle a successful request
+     */
+    onSuccess(): void;
+    /**
+     * Handle a failed request
+     */
+    onFailure(): void;
+    /**
+     * Check if a request can be executed through this circuit
+     * @returns Object with allowed flag and optional transition info
+     */
+    canExecute(): CanExecuteResult;
+    /**
+     * Get the current state
+     */
+    getState(): CircuitBreakerState;
+    /**
+     * Reset the circuit to CLOSED state
+     */
+    reset(): void;
+}

package/dist/src/circuitbreaker/CircuitState.js

@@ -0,0 +1,128 @@
+/**
+ * Circuit State - State machine for individual circuit breaker state
+ */
+/**
+ * CircuitState class - Manages state transitions for a single circuit
+ */
+export class CircuitState {
+    state;
+    halfOpenCalls = 0;
+    config;
+    constructor(config) {
+        this.config = config;
+        this.state = {
+            state: 'CLOSED',
+            failureCount: 0,
+            successCount: 0,
+            lastFailureTime: 0,
+            lastSuccessTime: 0,
+            nextAttemptTime: 0,
+        };
+    }
+    /**
+     * Handle a successful request
+     */
+    onSuccess() {
+        const now = Date.now();
+        this.state.lastSuccessTime = now;
+        switch (this.state.state) {
+            case 'CLOSED':
+                // Reset failure count on success
+                this.state.failureCount = 0;
+                break;
+            case 'HALF_OPEN':
+                this.state.successCount++;
+                this.state.failureCount = 0;
+                // Close circuit if success threshold reached
+                if (this.state.successCount >= this.config.successThreshold) {
+                    this.state.state = 'CLOSED';
+                    this.state.successCount = 0;
+                    this.halfOpenCalls = 0;
+                }
+                break;
+            case 'OPEN':
+                // Should not receive success in OPEN state
+                break;
+        }
+    }
+    /**
+     * Handle a failed request
+     */
+    onFailure() {
+        const now = Date.now();
+        this.state.lastFailureTime = now;
+        switch (this.state.state) {
+            case 'CLOSED':
+                this.state.failureCount++;
+                // Open circuit if failure threshold reached
+                if (this.state.failureCount >= this.config.failureThreshold) {
+                    this.state.state = 'OPEN';
+                    this.state.nextAttemptTime = now + this.config.recoveryTimeoutMs;
+                    this.state.successCount = 0;
+                }
+                break;
+            case 'HALF_OPEN':
+                // Re-open circuit on failure
+                this.state.state = 'OPEN';
+                this.state.nextAttemptTime = now + this.config.recoveryTimeoutMs;
+                this.state.failureCount++;
+                this.state.successCount = 0;
+                this.halfOpenCalls = 0;
+                break;
+            case 'OPEN':
+                // Already open, just update count
+                this.state.failureCount++;
+                break;
+        }
+    }
+    /**
+     * Check if a request can be executed through this circuit
+     * @returns Object with allowed flag and optional transition info
+     */
+    canExecute() {
+        const now = Date.now();
+        switch (this.state.state) {
+            case 'CLOSED':
+                return { allowed: true };
+            case 'OPEN':
+                // Check if recovery timeout has elapsed
+                if (now >= this.state.nextAttemptTime) {
+                    // Transition to HALF_OPEN for test request
+                    const transition = { from: 'OPEN', to: 'HALF_OPEN' };
+                    this.state.state = 'HALF_OPEN';
+                    this.halfOpenCalls = 0;
+                    return { allowed: true, transition };
+                }
+                return { allowed: false };
+            case 'HALF_OPEN':
+                // Limit calls in HALF_OPEN state
+                if (this.halfOpenCalls < this.config.halfOpenMaxCalls) {
+                    this.halfOpenCalls++;
+                    return { allowed: true };
+                }
+                return { allowed: false };
+            default:
+                return { allowed: false };
+        }
+    }
+    /**
+     * Get the current state
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Reset the circuit to CLOSED state
+     */
+    reset() {
+        this.state = {
+            state: 'CLOSED',
+            failureCount: 0,
+            successCount: 0,
+            lastFailureTime: 0,
+            lastSuccessTime: 0,
+            nextAttemptTime: 0,
+        };
+        this.halfOpenCalls = 0;
+    }
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Circuit Breaker Module
+ *
+ * Provides circuit breaker pattern implementation to prevent cascading failures
+ * by automatically disabling models that are consistently failing.
+ */
+export { CircuitBreaker } from './CircuitBreaker.js';
+export { CircuitState, type CanExecuteResult } from './CircuitState.js';

package/dist/src/circuitbreaker/index.js

@@ -0,0 +1,8 @@
+/**
+ * Circuit Breaker Module
+ *
+ * Provides circuit breaker pattern implementation to prevent cascading failures
+ * by automatically disabling models that are consistently failing.
+ */
+export { CircuitBreaker } from './CircuitBreaker.js';
+export { CircuitState } from './CircuitState.js';

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

@@ -21,6 +21,7 @@ export declare class FallbackHandler {
     private metricsManager;
     private subagentTracker;
     private retryManager;
+    private circuitBreaker?;
     constructor(config: PluginConfig, client: OpenCodeClient, logger: Logger, metricsManager: MetricsManager, subagentTracker: SubagentTracker);
     /**
      * Check and mark fallback in progress for deduplication

package/dist/src/fallback/FallbackHandler.js

@@ -3,6 +3,7 @@
  */
 import { SESSION_ENTRY_TTL_MS } from '../types/index.js';
 import { ModelSelector } from './ModelSelector.js';
+import { CircuitBreaker } from '../circuitbreaker/CircuitBreaker.js';
 import { extractMessageParts, convertPartsToSDKFormat, safeShowToast, getStateKey, getModelKey, DEDUP_WINDOW_MS, STATE_TIMEOUT_MS } from '../utils/helpers.js';
 import { RetryManager } from '../retry/RetryManager.js';
 /**
@@ -24,13 +25,19 @@ export class FallbackHandler {
     subagentTracker;
     // Retry manager reference
     retryManager;
+    // Circuit breaker reference
+    circuitBreaker;
     constructor(config, client, logger, metricsManager, subagentTracker) {
         this.config = config;
         this.client = client;
         this.logger = logger;
-        this.modelSelector = new ModelSelector(config, client);
         this.metricsManager = metricsManager;
         this.subagentTracker = subagentTracker;
+        // Initialize circuit breaker if enabled
+        if (config.circuitBreaker?.enabled) {
+            this.circuitBreaker = new CircuitBreaker(config.circuitBreaker, logger, metricsManager, client);
+        }
+        this.modelSelector = new ModelSelector(config, client, this.circuitBreaker);
         this.currentSessionModel = new Map();
         this.modelRequestStartTimes = new Map();
         this.retryState = new Map();
@@ -301,6 +308,11 @@ export class FallbackHandler {
             // Non-rate-limit error - record model failure metric
             const tracked = this.currentSessionModel.get(sessionID);
             if (tracked) {
+                // Record failure to circuit breaker (isRateLimit = false)
+                if (this.circuitBreaker) {
+                    const modelKey = getModelKey(tracked.providerID, tracked.modelID);
+                    this.circuitBreaker.recordFailure(modelKey, false);
+                }
                 if (this.metricsManager) {
                     this.metricsManager.recordModelFailure(tracked.providerID, tracked.modelID);
                     // Check if this was a fallback attempt and record failure
@@ -326,6 +338,11 @@ export class FallbackHandler {
                 // Record fallback success metric
                 const tracked = this.currentSessionModel.get(sessionID);
                 if (tracked) {
+                    // Record success to circuit breaker
+                    if (this.circuitBreaker) {
+                        const modelKey = getModelKey(tracked.providerID, tracked.modelID);
+                        this.circuitBreaker.recordSuccess(modelKey);
+                    }
                     if (this.metricsManager) {
                         this.metricsManager.recordFallbackSuccess(tracked.providerID, tracked.modelID, fallbackInfo.timestamp);
                         // Record model performance metric
@@ -374,6 +391,10 @@ export class FallbackHandler {
         }
         this.modelSelector.cleanupStaleEntries();
         this.retryManager.cleanupStaleEntries(SESSION_ENTRY_TTL_MS);
+        // Clean up circuit breaker stale entries
+        if (this.circuitBreaker) {
+            this.circuitBreaker.cleanupStaleEntries();
+        }
     }
     /**
      * Clean up all resources
@@ -385,5 +406,9 @@ export class FallbackHandler {
         this.fallbackInProgress.clear();
         this.fallbackMessages.clear();
         this.retryManager.destroy();
+        // Destroy circuit breaker
+        if (this.circuitBreaker) {
+            this.circuitBreaker.destroy();
+        }
     }
 }

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

@@ -2,6 +2,7 @@
  * Model selection logic based on fallback mode
  */
 import type { FallbackModel, PluginConfig, OpenCodeClient } from '../types/index.js';
+import type { CircuitBreaker } from '../circuitbreaker/index.js';
 /**
  * Model Selector class for handling model selection strategies
  */
@@ -9,7 +10,8 @@ export declare class ModelSelector {
     private rateLimitedModels;
     private config;
     private client;
-    constructor(config: PluginConfig, client: OpenCodeClient);
+    private circuitBreaker?;
+    constructor(config: PluginConfig, client: OpenCodeClient, circuitBreaker?: CircuitBreaker);
     /**
      * Check if a model is currently rate limited
      */
@@ -22,6 +24,10 @@ export declare class ModelSelector {
      * Find the next available model that is not rate limited
      */
     private findNextAvailableModel;
+    /**
+     * Check if a model is available (not rate limited and not blocked by circuit breaker)
+     */
+    private isModelAvailable;
     /**
      * Apply the fallback mode logic
      */

package/dist/src/fallback/ModelSelector.js

@@ -10,9 +10,11 @@ export class ModelSelector {
     rateLimitedModels;
     config;
     client;
-    constructor(config, client) {
+    circuitBreaker;
+    constructor(config, client, circuitBreaker) {
         this.config = config;
         this.client = client;
+        this.circuitBreaker = circuitBreaker;
         this.rateLimitedModels = new Map();
     }
     /**
@@ -48,7 +50,7 @@ export class ModelSelector {
         for (let i = searchStartIndex + 1; i < this.config.fallbackModels.length; i++) {
             const model = this.config.fallbackModels[i];
             const key = getModelKey(model.providerID, model.modelID);
-            if (!attemptedModels.has(key) && !this.isModelRateLimited(model.providerID, model.modelID)) {
+            if (!attemptedModels.has(key) && !this.isModelRateLimited(model.providerID, model.modelID) && this.isModelAvailable(model.providerID, model.modelID)) {
                 return model;
             }
         }
@@ -56,12 +58,23 @@ export class ModelSelector {
         for (let i = 0; i <= searchStartIndex && i < this.config.fallbackModels.length; i++) {
             const model = this.config.fallbackModels[i];
             const key = getModelKey(model.providerID, model.modelID);
-            if (!attemptedModels.has(key) && !this.isModelRateLimited(model.providerID, model.modelID)) {
+            if (!attemptedModels.has(key) && !this.isModelRateLimited(model.providerID, model.modelID) && this.isModelAvailable(model.providerID, model.modelID)) {
                 return model;
             }
         }
         return null;
     }
+    /**
+     * Check if a model is available (not rate limited and not blocked by circuit breaker)
+     */
+    isModelAvailable(providerID, modelID) {
+        // Check circuit breaker if enabled
+        if (this.circuitBreaker && this.config.circuitBreaker?.enabled) {
+            const modelKey = getModelKey(providerID, modelID);
+            return this.circuitBreaker.canExecute(modelKey);
+        }
+        return true;
+    }
     /**
      * Apply the fallback mode logic
      */
@@ -79,7 +92,7 @@ export class ModelSelector {
             const lastModel = this.config.fallbackModels[this.config.fallbackModels.length - 1];
             if (lastModel) {
                 const isLastModelCurrent = currentProviderID === lastModel.providerID && currentModelID === lastModel.modelID;
-                if (!isLastModelCurrent && !this.isModelRateLimited(lastModel.providerID, lastModel.modelID)) {
+                if (!isLastModelCurrent && !this.isModelRateLimited(lastModel.providerID, lastModel.modelID) && this.isModelAvailable(lastModel.providerID, lastModel.modelID)) {
                     // Use the last model for one more try
                     safeShowToast(this.client, {
                         body: {

package/dist/src/metrics/MetricsManager.d.ts

@@ -2,7 +2,7 @@
  * Metrics Manager - Handles metrics collection, aggregation, and reporting
  */
 import type { Logger } from '../../logger.js';
-import type { MetricsConfig, MetricsData, RateLimitMetrics, FallbackTargetMetrics, ModelPerformanceMetrics } from '../types/index.js';
+import type { MetricsConfig, MetricsData, RateLimitMetrics, FallbackTargetMetrics, ModelPerformanceMetrics, CircuitBreakerStateType } from '../types/index.js';
 /**
  * Metrics Manager class for collecting and reporting metrics
  */
@@ -61,6 +61,15 @@ export declare class MetricsManager {
      * Record a failed retry
      */
     recordRetryFailure(): void;
+    /**
+     * Record a circuit breaker state transition
+     */
+    recordCircuitBreakerStateTransition(modelKey: string, oldState: CircuitBreakerStateType, newState: CircuitBreakerStateType): void;
+    /**
+     * Helper method to update circuit breaker state counts
+     * @private
+     */
+    private updateCircuitBreakerStateCounts;
     /**
      * Get a copy of the current metrics
      */

package/dist/src/metrics/MetricsManager.js

@@ -31,6 +31,18 @@ export class MetricsManager {
                 byModel: new Map(),
             },
             modelPerformance: new Map(),
+            circuitBreaker: {
+                total: {
+                    stateTransitions: 0,
+                    opens: 0,
+                    closes: 0,
+                    halfOpens: 0,
+                    currentOpen: 0,
+                    currentHalfOpen: 0,
+                    currentClosed: 0,
+                },
+                byModel: new Map(),
+            },
             startedAt: Date.now(),
             generatedAt: Date.now(),
         };
@@ -71,6 +83,18 @@ export class MetricsManager {
                 byModel: new Map(),
             },
             modelPerformance: new Map(),
+            circuitBreaker: {
+                total: {
+                    stateTransitions: 0,
+                    opens: 0,
+                    closes: 0,
+                    halfOpens: 0,
+                    currentOpen: 0,
+                    currentHalfOpen: 0,
+                    currentClosed: 0,
+                },
+                byModel: new Map(),
+            },
             startedAt: Date.now(),
             generatedAt: Date.now(),
         };
@@ -229,6 +253,62 @@ export class MetricsManager {
             return;
         this.metrics.retries.failed++;
     }
+    /**
+     * Record a circuit breaker state transition
+     */
+    recordCircuitBreakerStateTransition(modelKey, oldState, newState) {
+        if (!this.config.enabled)
+            return;
+        // Update total metrics
+        this.metrics.circuitBreaker.total.stateTransitions++;
+        this.updateCircuitBreakerStateCounts(this.metrics.circuitBreaker.total, oldState, newState);
+        // Update model-specific metrics
+        let modelMetrics = this.metrics.circuitBreaker.byModel.get(modelKey);
+        if (!modelMetrics) {
+            modelMetrics = {
+                stateTransitions: 0,
+                opens: 0,
+                closes: 0,
+                halfOpens: 0,
+                currentOpen: 0,
+                currentHalfOpen: 0,
+                currentClosed: 1, // Start with CLOSED
+            };
+            this.metrics.circuitBreaker.byModel.set(modelKey, modelMetrics);
+        }
+        modelMetrics.stateTransitions++;
+        this.updateCircuitBreakerStateCounts(modelMetrics, oldState, newState);
+        this.metrics.circuitBreaker.byModel.set(modelKey, modelMetrics);
+    }
+    /**
+     * Helper method to update circuit breaker state counts
+     * @private
+     */
+    updateCircuitBreakerStateCounts(metrics, oldState, newState) {
+        // Update state counts based on old state
+        if (oldState === 'OPEN') {
+            metrics.currentOpen--;
+        }
+        else if (oldState === 'HALF_OPEN') {
+            metrics.currentHalfOpen--;
+        }
+        else if (oldState === 'CLOSED') {
+            metrics.currentClosed--;
+        }
+        // Update state counts based on new state
+        if (newState === 'OPEN') {
+            metrics.opens++;
+            metrics.currentOpen++;
+        }
+        else if (newState === 'HALF_OPEN') {
+            metrics.halfOpens++;
+            metrics.currentHalfOpen++;
+        }
+        else if (newState === 'CLOSED') {
+            metrics.closes++;
+            metrics.currentClosed++;
+        }
+    }
     /**
      * Get a copy of the current metrics
      */
@@ -266,6 +346,10 @@ export class MetricsManager {
                 byModel: Object.fromEntries(Array.from(metrics.retries.byModel.entries()).map(([k, v]) => [k, v])),
             },
             modelPerformance: Object.fromEntries(Array.from(metrics.modelPerformance.entries()).map(([k, v]) => [k, v])),
+            circuitBreaker: {
+                ...metrics.circuitBreaker,
+                byModel: Object.fromEntries(Array.from(metrics.circuitBreaker.byModel.entries()).map(([k, v]) => [k, v])),
+            },
             startedAt: metrics.startedAt,
             generatedAt: metrics.generatedAt,
         };
@@ -342,6 +426,31 @@ export class MetricsManager {
             }
         }
         lines.push("");
+        // Circuit Breaker
+        lines.push("Circuit Breaker:");
+        lines.push("-".repeat(40));
+        lines.push(`  State Transitions: ${this.metrics.circuitBreaker.total.stateTransitions}`);
+        lines.push(`  Opens: ${this.metrics.circuitBreaker.total.opens}`);
+        lines.push(`  Closes: ${this.metrics.circuitBreaker.total.closes}`);
+        lines.push(`  Half Opens: ${this.metrics.circuitBreaker.total.halfOpens}`);
+        lines.push("");
+        lines.push("  Current State Distribution:");
+        lines.push(`    CLOSED: ${this.metrics.circuitBreaker.total.currentClosed}`);
+        lines.push(`    HALF_OPEN: ${this.metrics.circuitBreaker.total.currentHalfOpen}`);
+        lines.push(`    OPEN: ${this.metrics.circuitBreaker.total.currentOpen}`);
+        if (this.metrics.circuitBreaker.byModel.size > 0) {
+            lines.push("");
+            lines.push("  By Model:");
+            for (const [model, data] of this.metrics.circuitBreaker.byModel.entries()) {
+                lines.push(`    ${model}:`);
+                lines.push(`      State Transitions: ${data.stateTransitions}`);
+                lines.push(`      Opens: ${data.opens}`);
+                lines.push(`      Closes: ${data.closes}`);
+                lines.push(`      Half Opens: ${data.halfOpens}`);
+                lines.push(`      Current State: ${data.currentOpen > 0 ? 'OPEN' : data.currentHalfOpen > 0 ? 'HALF_OPEN' : 'CLOSED'}`);
+            }
+        }
+        lines.push("");
         // Model Performance
         lines.push("Model Performance:");
         lines.push("-".repeat(40));
@@ -428,6 +537,34 @@ export class MetricsManager {
             ].join(","));
         }
         lines.push("");
+        // Circuit Breaker Summary CSV
+        lines.push("=== CIRCUIT_BREAKER_SUMMARY ===");
+        lines.push(`state_transitions,opens,closes,half_opens,current_open,current_half_open,current_closed`);
+        lines.push([
+            this.metrics.circuitBreaker.total.stateTransitions,
+            this.metrics.circuitBreaker.total.opens,
+            this.metrics.circuitBreaker.total.closes,
+            this.metrics.circuitBreaker.total.halfOpens,
+            this.metrics.circuitBreaker.total.currentOpen,
+            this.metrics.circuitBreaker.total.currentHalfOpen,
+            this.metrics.circuitBreaker.total.currentClosed,
+        ].join(","));
+        lines.push("");
+        // Circuit Breaker by Model CSV
+        lines.push("=== CIRCUIT_BREAKER_BY_MODEL ===");
+        lines.push("model,state_transitions,opens,closes,half_opens,current_state");
+        for (const [model, data] of this.metrics.circuitBreaker.byModel.entries()) {
+            const currentState = data.currentOpen > 0 ? 'OPEN' : data.currentHalfOpen > 0 ? 'HALF_OPEN' : 'CLOSED';
+            lines.push([
+                model,
+                data.stateTransitions,
+                data.opens,
+                data.closes,
+                data.halfOpens,
+                currentState,
+            ].join(","));
+        }
+        lines.push("");
         // Model Performance CSV
         lines.push("=== MODEL_PERFORMANCE ===");
         lines.push("model,requests,successes,failures,avg_response_time_ms,success_rate");

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

@@ -33,6 +33,31 @@ export interface RetryPolicy {
     jitterFactor: number;
     timeoutMs?: number;
 }
+/**
+ * Circuit breaker state
+ */
+export type CircuitBreakerStateType = 'CLOSED' | 'OPEN' | 'HALF_OPEN';
+/**
+ * Circuit breaker configuration
+ */
+export interface CircuitBreakerConfig {
+    enabled: boolean;
+    failureThreshold: number;
+    recoveryTimeoutMs: number;
+    halfOpenMaxCalls: number;
+    successThreshold: number;
+}
+/**
+ * Circuit breaker state data
+ */
+export interface CircuitBreakerState {
+    state: CircuitBreakerStateType;
+    failureCount: number;
+    successCount: number;
+    lastFailureTime: number;
+    lastSuccessTime: number;
+    nextAttemptTime: number;
+}
 /**
  * Metrics output configuration
  */
@@ -60,6 +85,7 @@ export interface PluginConfig {
     maxSubagentDepth?: number;
     enableSubagentFallback?: boolean;
     retryPolicy?: RetryPolicy;
+    circuitBreaker?: CircuitBreakerConfig;
     log?: LogConfig;
     metrics?: MetricsConfig;
 }
@@ -183,6 +209,18 @@ export interface ModelPerformanceMetrics {
     failures: number;
     averageResponseTime?: number;
 }
+/**
+ * Circuit breaker metrics
+ */
+export interface CircuitBreakerMetrics {
+    stateTransitions: number;
+    opens: number;
+    closes: number;
+    halfOpens: number;
+    currentOpen: number;
+    currentHalfOpen: number;
+    currentClosed: number;
+}
 /**
  * Retry metrics
  */
@@ -210,6 +248,10 @@ export interface MetricsData {
     };
     retries: RetryMetrics;
     modelPerformance: Map<string, ModelPerformanceMetrics>;
+    circuitBreaker: {
+        total: CircuitBreakerMetrics;
+        byModel: Map<string, CircuitBreakerMetrics>;
+    };
     startedAt: number;
     generatedAt: number;
 }
@@ -314,6 +356,10 @@ export declare const DEFAULT_FALLBACK_MODELS: FallbackModel[];
  * Default retry policy
  */
 export declare const DEFAULT_RETRY_POLICY: RetryPolicy;
+/**
+ * Default circuit breaker configuration
+ */
+export declare const DEFAULT_CIRCUIT_BREAKER_CONFIG: CircuitBreakerConfig;
 /**
  * Valid fallback modes
  */

package/dist/src/types/index.js

@@ -23,6 +23,16 @@ export const DEFAULT_RETRY_POLICY = {
     jitterEnabled: false,
     jitterFactor: 0.1,
 };
+/**
+ * Default circuit breaker configuration
+ */
+export const DEFAULT_CIRCUIT_BREAKER_CONFIG = {
+    enabled: false,
+    failureThreshold: 5,
+    recoveryTimeoutMs: 60000,
+    halfOpenMaxCalls: 1,
+    successThreshold: 2,
+};
 /**
  * Valid fallback modes
  */

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

@@ -6,6 +6,13 @@ import type { PluginConfig } from '../types/index.js';
  * Default plugin configuration
  */
 export declare const DEFAULT_CONFIG: PluginConfig;
+/**
+ * Result of config loading, includes which file was loaded
+ */
+export interface ConfigLoadResult {
+    config: PluginConfig;
+    source: string | null;
+}
 /**
  * Validate configuration values
  */
@@ -13,4 +20,4 @@ export declare function validateConfig(config: Partial<PluginConfig>): PluginCon
 /**
  * Load and validate config from file paths
  */
-export declare function loadConfig(directory: string): PluginConfig;
+export declare function loadConfig(directory: string, worktree?: string): ConfigLoadResult;

package/dist/src/utils/config.js

@@ -3,7 +3,7 @@
  */
 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, } from '../types/index.js';
+import { DEFAULT_FALLBACK_MODELS, VALID_FALLBACK_MODES, VALID_RESET_INTERVALS, DEFAULT_RETRY_POLICY, VALID_RETRY_STRATEGIES, DEFAULT_CIRCUIT_BREAKER_CONFIG, } from '../types/index.js';
 /**
  * Default plugin configuration
  */
@@ -13,6 +13,7 @@ export const DEFAULT_CONFIG = {
     enabled: true,
     fallbackMode: "cycle",
     retryPolicy: DEFAULT_RETRY_POLICY,
+    circuitBreaker: DEFAULT_CIRCUIT_BREAKER_CONFIG,
     log: {
         level: "warn",
         format: "simple",
@@ -37,13 +38,17 @@ export function validateConfig(config) {
     return {
         ...DEFAULT_CONFIG,
         ...config,
-        fallbackModels: config.fallbackModels || DEFAULT_CONFIG.fallbackModels,
+        fallbackModels: Array.isArray(config.fallbackModels) ? config.fallbackModels : DEFAULT_CONFIG.fallbackModels,
         fallbackMode: mode && VALID_FALLBACK_MODES.includes(mode) ? mode : DEFAULT_CONFIG.fallbackMode,
         retryPolicy: config.retryPolicy ? {
             ...DEFAULT_CONFIG.retryPolicy,
             ...config.retryPolicy,
             strategy: strategy && VALID_RETRY_STRATEGIES.includes(strategy) ? strategy : DEFAULT_CONFIG.retryPolicy.strategy,
         } : DEFAULT_CONFIG.retryPolicy,
+        circuitBreaker: config.circuitBreaker ? {
+            ...DEFAULT_CONFIG.circuitBreaker,
+            ...config.circuitBreaker,
+        } : DEFAULT_CONFIG.circuitBreaker,
         log: config.log ? { ...DEFAULT_CONFIG.log, ...config.log } : DEFAULT_CONFIG.log,
         metrics: config.metrics ? {
             ...DEFAULT_CONFIG.metrics,
@@ -59,20 +64,30 @@ export function validateConfig(config) {
 /**
  * Load and validate config from file paths
  */
-export function loadConfig(directory) {
+export function loadConfig(directory, worktree) {
     const homedir = process.env.HOME || "";
-    const configPaths = [
-        join(directory, ".opencode", "rate-limit-fallback.json"),
-        join(directory, "rate-limit-fallback.json"),
-        join(homedir, ".opencode", "rate-limit-fallback.json"),
-        join(homedir, ".config", "opencode", "rate-limit-fallback.json"),
-    ];
+    const xdgConfigHome = process.env.XDG_CONFIG_HOME || join(homedir, ".config");
+    // Build search paths: worktree first, then directory, then home locations
+    const searchDirs = [];
+    if (worktree) {
+        searchDirs.push(worktree);
+    }
+    if (!worktree || worktree !== directory) {
+        searchDirs.push(directory);
+    }
+    const configPaths = [];
+    for (const dir of searchDirs) {
+        configPaths.push(join(dir, ".opencode", "rate-limit-fallback.json"));
+        configPaths.push(join(dir, "rate-limit-fallback.json"));
+    }
+    configPaths.push(join(homedir, ".opencode", "rate-limit-fallback.json"));
+    configPaths.push(join(xdgConfigHome, "opencode", "rate-limit-fallback.json"));
     for (const configPath of configPaths) {
         if (existsSync(configPath)) {
             try {
                 const content = readFileSync(configPath, "utf-8");
                 const userConfig = JSON.parse(content);
-                return validateConfig(userConfig);
+                return { config: validateConfig(userConfig), source: configPath };
             }
             catch (error) {
                 // Log config errors to console immediately before logger is initialized
@@ -81,5 +96,5 @@ export function loadConfig(directory) {
             }
         }
     }
-    return DEFAULT_CONFIG;
+    return { config: DEFAULT_CONFIG, source: null };
 }

package/dist/src/utils/errorDetection.js

@@ -24,8 +24,8 @@ export function isRateLimitError(error) {
         "too many requests",
         "quota exceeded",
     ];
-    // Check for 429 in text (explicit HTTP status code)
-    if (responseBody.includes("429") || message.includes("429")) {
+    // 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

package/package.json

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