@azumag/opencode-rate-limit-fallback 1.0.2 → 1.0.4

package/README.md

@@ -6,9 +6,11 @@ OpenCode plugin that automatically switches to fallback models when rate limited
 
 ## Features
 
-- Detects rate limit errors (429, "usage limit", "quota exceeded", etc.)
+- Detects rate limit errors (429, "usage limit", "quota exceeded", "high concurrency", etc.)
 - Automatically aborts the current request and retries with a fallback model
 - Configurable fallback model list with priority order
+- Three fallback modes: `cycle`, `stop`, and `retry-last`
+- Session model tracking for sequential fallback across multiple rate limits
 - Cooldown period to prevent immediate retry on rate-limited models
 - Toast notifications for user feedback
 
@@ -51,6 +53,7 @@ Create a configuration file at one of these locations:
 {
   "enabled": true,
   "cooldownMs": 60000,
+  "fallbackMode": "cycle",
   "fallbackModels": [
     { "providerID": "anthropic", "modelID": "claude-sonnet-4-20250514" },
     { "providerID": "google", "modelID": "gemini-2.5-pro" },
@@ -65,8 +68,17 @@ Create a configuration file at one of these locations:
 |--------|------|---------|-------------|
 | `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 |
 
+### Fallback Modes
+
+| Mode | Description |
+|------|-------------|
+| `"cycle"` | Reset and retry from the first model when all models are exhausted (default) |
+| `"stop"` | Stop and show error when all models are exhausted |
+| `"retry-last"` | Try the last model once more, then reset to first on next prompt |
+
 ### Default Fallback Models
 
 If no configuration is provided, the following models are used:

package/index.ts

@@ -7,10 +7,19 @@ interface FallbackModel {
   modelID: string;
 }
 
+/**
+ * Fallback mode when all models are exhausted:
+ * - "cycle": Reset and retry from the first model (default)
+ * - "stop": Stop and show error message
+ * - "retry-last": Try the last model once, then reset to first on next prompt
+ */
+type FallbackMode = "cycle" | "stop" | "retry-last";
+
 interface PluginConfig {
   fallbackModels: FallbackModel[];
   cooldownMs: number;
   enabled: boolean;
+  fallbackMode: FallbackMode;
 }
 
 const DEFAULT_FALLBACK_MODELS: FallbackModel[] = [
@@ -23,6 +32,7 @@ const DEFAULT_CONFIG: PluginConfig = {
   fallbackModels: DEFAULT_FALLBACK_MODELS,
   cooldownMs: 60 * 1000,
   enabled: true,
+  fallbackMode: "cycle",
 };
 
 function loadConfig(directory: string): PluginConfig {
@@ -39,10 +49,13 @@ function loadConfig(directory: string): PluginConfig {
       try {
         const content = readFileSync(configPath, "utf-8");
         const userConfig = JSON.parse(content);
+        const mode = userConfig.fallbackMode;
+        const validModes: FallbackMode[] = ["cycle", "stop", "retry-last"];
         return {
           ...DEFAULT_CONFIG,
           ...userConfig,
           fallbackModels: userConfig.fallbackModels || DEFAULT_CONFIG.fallbackModels,
+          fallbackMode: validModes.includes(mode) ? mode : DEFAULT_CONFIG.fallbackMode,
         };
       } catch (error) {
         // Config load failed, continue to next path
@@ -76,7 +89,9 @@ function isRateLimitError(error: any): boolean {
     "quota exceeded",
     "resource exhausted",
     "usage limit",
-    "High concurrency usage of this API",
+    "high concurrency usage of this api",
+    "high concurrency",
+    "reduce concurrency",
     "429",
   ];
 
@@ -97,6 +112,8 @@ export const RateLimitFallback: Plugin = async ({ client, directory }) => {
 
   const rateLimitedModels = new Map<string, number>();
   const retryState = new Map<string, { attemptedModels: Set<string>; lastAttemptTime: number }>();
+  const currentSessionModel = new Map<string, { providerID: string; modelID: string }>();
+  const fallbackInProgress = new Map<string, number>(); // sessionID -> timestamp
 
   function isModelRateLimited(providerID: string, modelID: string): boolean {
     const key = getModelKey(providerID, modelID);
@@ -140,12 +157,28 @@ export const RateLimitFallback: Plugin = async ({ client, directory }) => {
 
   async function handleRateLimitFallback(sessionID: string, currentProviderID: string, currentModelID: string) {
     try {
+      // Prevent duplicate fallback processing within 5 seconds
+      const lastFallback = fallbackInProgress.get(sessionID);
+      if (lastFallback && Date.now() - lastFallback < 5000) {
+        return;
+      }
+      fallbackInProgress.set(sessionID, Date.now());
+
+      // If no model info provided, try to get from tracked session model
+      if (!currentProviderID || !currentModelID) {
+        const tracked = currentSessionModel.get(sessionID);
+        if (tracked) {
+          currentProviderID = tracked.providerID;
+          currentModelID = tracked.modelID;
+        }
+      }
+
       await client.session.abort({ path: { id: sessionID } });
 
       await client.tui.showToast({
         body: {
           title: "Rate Limit Detected",
-          message: "Switching to fallback model...",
+          message: `Switching from ${currentModelID || 'current model'}...`,
           variant: "warning",
           duration: 3000,
         },
@@ -171,18 +204,61 @@ export const RateLimitFallback: Plugin = async ({ client, directory }) => {
         state.attemptedModels.add(getModelKey(currentProviderID, currentModelID));
       }
 
-      const nextModel = findNextAvailableModel(currentProviderID || "", currentModelID || "", state.attemptedModels);
+      let nextModel = findNextAvailableModel(currentProviderID || "", currentModelID || "", state.attemptedModels);
+
+      // Handle when no model is found based on fallbackMode
+      if (!nextModel && state.attemptedModels.size > 0) {
+        if (config.fallbackMode === "cycle") {
+          // Reset and retry from the first model
+          state.attemptedModels.clear();
+          if (currentProviderID && currentModelID) {
+            state.attemptedModels.add(getModelKey(currentProviderID, currentModelID));
+          }
+          nextModel = findNextAvailableModel("", "", state.attemptedModels);
+        } else if (config.fallbackMode === "retry-last") {
+          // Try the last model in the list once, then reset on next prompt
+          const lastModel = config.fallbackModels[config.fallbackModels.length - 1];
+          if (lastModel) {
+            const lastKey = getModelKey(lastModel.providerID, lastModel.modelID);
+            const isLastModelCurrent = currentProviderID === lastModel.providerID && currentModelID === lastModel.modelID;
+
+            if (!isLastModelCurrent && !isModelRateLimited(lastModel.providerID, lastModel.modelID)) {
+              // Use the last model for one more try
+              nextModel = lastModel;
+              await client.tui.showToast({
+                body: {
+                  title: "Last Resort",
+                  message: `Trying ${lastModel.modelID} one more time...`,
+                  variant: "warning",
+                  duration: 3000,
+                },
+              });
+            } else {
+              // Last model also failed, reset for next prompt
+              state.attemptedModels.clear();
+              if (currentProviderID && currentModelID) {
+                state.attemptedModels.add(getModelKey(currentProviderID, currentModelID));
+              }
+              nextModel = findNextAvailableModel("", "", state.attemptedModels);
+            }
+          }
+        }
+        // "stop" mode: nextModel remains null, will show error below
+      }
 
       if (!nextModel) {
         await client.tui.showToast({
           body: {
             title: "No Fallback Available",
-            message: "All models are rate limited",
+            message: config.fallbackMode === "stop"
+              ? "All fallback models exhausted"
+              : "All models are rate limited",
             variant: "error",
             duration: 5000,
           },
         });
         retryState.delete(stateKey);
+        fallbackInProgress.delete(sessionID);
         return;
       }
 
@@ -209,6 +285,9 @@ export const RateLimitFallback: Plugin = async ({ client, directory }) => {
         },
       });
 
+      // Track the new model for this session
+      currentSessionModel.set(sessionID, { providerID: nextModel.providerID, modelID: nextModel.modelID });
+
       await client.session.prompt({
         path: { id: sessionID },
         body: {
@@ -227,8 +306,11 @@ export const RateLimitFallback: Plugin = async ({ client, directory }) => {
       });
 
       retryState.delete(stateKey);
+      // Clear fallback flag to allow next fallback if needed
+      fallbackInProgress.delete(sessionID);
     } catch (err) {
-      // Fallback failed silently
+      // Fallback failed, clear the flag
+      fallbackInProgress.delete(sessionID);
     }
   }
 
@@ -254,10 +336,15 @@ export const RateLimitFallback: Plugin = async ({ client, directory }) => {
 
         if (status?.type === "retry" && status?.message) {
           const message = status.message.toLowerCase();
-          if (message.includes("usage limit") || message.includes("rate limit")) {
-            if (status.attempt === 1) {
-              await handleRateLimitFallback(props.sessionID, "", "");
-            }
+          const isRateLimitRetry =
+            message.includes("usage limit") ||
+            message.includes("rate limit") ||
+            message.includes("high concurrency") ||
+            message.includes("reduce concurrency");
+
+          if (isRateLimitRetry) {
+            // Try fallback on any attempt, handleRateLimitFallback will manage state
+            await handleRateLimitFallback(props.sessionID, "", "");
           }
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azumag/opencode-rate-limit-fallback",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "OpenCode plugin that automatically switches to fallback models when rate limited",
   "main": "index.ts",
   "type": "module",

package/rate-limit-fallback.example.json

@@ -1,6 +1,7 @@
 {
   "enabled": true,
   "cooldownMs": 60000,
+  "fallbackMode": "cycle",
   "fallbackModels": [
     { "providerID": "anthropic", "modelID": "claude-sonnet-4-20250514" },
     { "providerID": "google", "modelID": "gemini-2.5-pro" },