@azumag/opencode-rate-limit-fallback 1.0.6 → 1.0.8

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const RateLimitFallback: Plugin;
+export default RateLimitFallback;

package/dist/index.js

@@ -0,0 +1,316 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+const DEFAULT_FALLBACK_MODELS = [
+    { providerID: "anthropic", modelID: "claude-sonnet-4-20250514" },
+    { providerID: "google", modelID: "gemini-2.5-pro" },
+    { providerID: "google", modelID: "gemini-2.5-flash" },
+];
+const DEFAULT_CONFIG = {
+    fallbackModels: DEFAULT_FALLBACK_MODELS,
+    cooldownMs: 60 * 1000,
+    enabled: true,
+    fallbackMode: "cycle",
+};
+function loadConfig(directory) {
+    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"),
+    ];
+    for (const configPath of configPaths) {
+        if (existsSync(configPath)) {
+            try {
+                const content = readFileSync(configPath, "utf-8");
+                const userConfig = JSON.parse(content);
+                const mode = userConfig.fallbackMode;
+                const validModes = ["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
+            }
+        }
+    }
+    return DEFAULT_CONFIG;
+}
+function getModelKey(providerID, modelID) {
+    return `${providerID}/${modelID}`;
+}
+function isRateLimitError(error) {
+    if (!error)
+        return false;
+    if (error.name === "APIError" && error.data?.statusCode === 429) {
+        return true;
+    }
+    const responseBody = (error.data?.responseBody || "").toLowerCase();
+    const message = (error.data?.message || error.message || "").toLowerCase();
+    const errorName = (error.name || "").toLowerCase();
+    const rateLimitIndicators = [
+        "rate limit",
+        "rate_limit",
+        "ratelimit",
+        "too many requests",
+        "quota exceeded",
+        "resource exhausted",
+        "usage limit",
+        "high concurrency usage of this api",
+        "high concurrency",
+        "reduce concurrency",
+        "429",
+    ];
+    return rateLimitIndicators.some((indicator) => responseBody.includes(indicator) ||
+        message.includes(indicator) ||
+        errorName.includes(indicator));
+}
+export const RateLimitFallback = async ({ client, directory }) => {
+    const config = loadConfig(directory);
+    if (!config.enabled) {
+        return {};
+    }
+    const rateLimitedModels = new Map();
+    const retryState = new Map();
+    const currentSessionModel = new Map();
+    const fallbackInProgress = new Map(); // sessionID -> timestamp
+    async function logOrToast(message, variant = "info") {
+        try {
+            await client.tui.showToast({
+                body: { message, variant },
+            });
+        }
+        catch {
+            const variantMap = {
+                info: "info",
+                success: "info",
+                warning: "warn",
+                error: "error",
+            };
+            await client.app.log({
+                body: {
+                    service: "rate-limit-fallback",
+                    level: variantMap[variant],
+                    message,
+                },
+            });
+        }
+    }
+    async function toast(title, message, variant = "info") {
+        try {
+            await client.tui.showToast({
+                body: { title, message, variant },
+            });
+        }
+        catch {
+            const variantMap = {
+                info: "info",
+                success: "info",
+                warning: "warn",
+                error: "error",
+            };
+            await client.app.log({
+                body: {
+                    service: "rate-limit-fallback",
+                    level: variantMap[variant],
+                    message: `${title}: ${message}`,
+                },
+            });
+        }
+    }
+    function isModelRateLimited(providerID, modelID) {
+        const key = getModelKey(providerID, modelID);
+        const limitedAt = rateLimitedModels.get(key);
+        if (!limitedAt)
+            return false;
+        if (Date.now() - limitedAt > config.cooldownMs) {
+            rateLimitedModels.delete(key);
+            return false;
+        }
+        return true;
+    }
+    function markModelRateLimited(providerID, modelID) {
+        const key = getModelKey(providerID, modelID);
+        rateLimitedModels.set(key, Date.now());
+    }
+    function findNextAvailableModel(currentProviderID, currentModelID, attemptedModels) {
+        const currentKey = getModelKey(currentProviderID, currentModelID);
+        let startIndex = config.fallbackModels.findIndex(m => getModelKey(m.providerID, m.modelID) === currentKey);
+        // If current model is not in the fallback list, search from the beginning
+        if (startIndex === -1) {
+            // Only search through all models once (first loop handles this)
+            for (let i = 0; i < config.fallbackModels.length; i++) {
+                const model = config.fallbackModels[i];
+                const key = getModelKey(model.providerID, model.modelID);
+                if (!attemptedModels.has(key) && !isModelRateLimited(model.providerID, model.modelID)) {
+                    return model;
+                }
+            }
+            return null;
+        }
+        // Search for the next model after current position
+        for (let i = startIndex + 1; i < config.fallbackModels.length; i++) {
+            const model = config.fallbackModels[i];
+            const key = getModelKey(model.providerID, model.modelID);
+            if (!attemptedModels.has(key) && !isModelRateLimited(model.providerID, model.modelID)) {
+                return model;
+            }
+        }
+        // Search from the beginning to current position (wrap around)
+        for (let i = 0; i <= startIndex && i < config.fallbackModels.length; i++) {
+            const model = config.fallbackModels[i];
+            const key = getModelKey(model.providerID, model.modelID);
+            if (!attemptedModels.has(key) && !isModelRateLimited(model.providerID, model.modelID)) {
+                return model;
+            }
+        }
+        return null;
+    }
+    async function handleRateLimitFallback(sessionID, currentProviderID, currentModelID) {
+        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 toast("Rate Limit Detected", `Switching from ${currentModelID || 'current model'}...`, "warning");
+            const messagesResult = await client.session.messages({ path: { id: sessionID } });
+            if (!messagesResult.data)
+                return;
+            const messages = messagesResult.data;
+            const lastUserMessage = [...messages].reverse().find(m => m.info.role === "user");
+            if (!lastUserMessage)
+                return;
+            const stateKey = `${sessionID}:${lastUserMessage.info.id}`;
+            let state = retryState.get(stateKey);
+            if (!state || Date.now() - state.lastAttemptTime > 30000) {
+                state = { attemptedModels: new Set(), lastAttemptTime: Date.now() };
+                retryState.set(stateKey, state);
+            }
+            if (currentProviderID && currentModelID) {
+                markModelRateLimited(currentProviderID, currentModelID);
+                state.attemptedModels.add(getModelKey(currentProviderID, currentModelID));
+            }
+            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 toast("Last Resort", `Trying ${lastModel.modelID} one more time...`, "warning");
+                        }
+                        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 toast("No Fallback Available", config.fallbackMode === "stop"
+                    ? "All fallback models exhausted"
+                    : "All models are rate limited", "error");
+                retryState.delete(stateKey);
+                fallbackInProgress.delete(sessionID);
+                return;
+            }
+            state.attemptedModels.add(getModelKey(nextModel.providerID, nextModel.modelID));
+            state.lastAttemptTime = Date.now();
+            const parts = lastUserMessage.parts
+                .filter((p) => p.type === "text" || p.type === "file")
+                .map((p) => {
+                if (p.type === "text")
+                    return { type: "text", text: p.text };
+                if (p.type === "file")
+                    return { type: "file", path: p.path, mediaType: p.mediaType };
+                return null;
+            })
+                .filter(Boolean);
+            if (parts.length === 0)
+                return;
+            await toast("Retrying", `Using ${nextModel.providerID}/${nextModel.modelID}`, "info");
+            // Track the new model for this session
+            currentSessionModel.set(sessionID, { providerID: nextModel.providerID, modelID: nextModel.modelID });
+            await client.session.prompt({
+                path: { id: sessionID },
+                body: {
+                    parts: parts,
+                    model: { providerID: nextModel.providerID, modelID: nextModel.modelID },
+                },
+            });
+            await toast("Fallback Successful", `Now using ${nextModel.modelID}`, "success");
+            retryState.delete(stateKey);
+            // Clear fallback flag to allow next fallback if needed
+            fallbackInProgress.delete(sessionID);
+        }
+        catch (err) {
+            // Fallback failed, clear the flag
+            fallbackInProgress.delete(sessionID);
+        }
+    }
+    return {
+        event: async ({ event }) => {
+            if (event.type === "session.error") {
+                const { sessionID, error } = event.properties;
+                if (sessionID && error && isRateLimitError(error)) {
+                    await handleRateLimitFallback(sessionID, "", "");
+                }
+            }
+            if (event.type === "message.updated") {
+                const info = event.properties?.info;
+                if (info?.error && isRateLimitError(info.error)) {
+                    await handleRateLimitFallback(info.sessionID, info.providerID || "", info.modelID || "");
+                }
+            }
+            if (event.type === "session.status") {
+                const props = event.properties;
+                const status = props?.status;
+                if (status?.type === "retry" && status?.message) {
+                    const message = status.message.toLowerCase();
+                    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, "", "");
+                    }
+                }
+            }
+        },
+    };
+};
+export default RateLimitFallback;

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@azumag/opencode-rate-limit-fallback",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "OpenCode plugin that automatically switches to fallback models when rate limited",
-  "main": "index.ts",
   "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
   "keywords": [
     "opencode",
     "plugin",
@@ -21,7 +24,21 @@
     "url": "https://github.com/azumag/opencode-rate-limit-fallback/issues"
   },
   "homepage": "https://github.com/azumag/opencode-rate-limit-fallback#readme",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
   "dependencies": {
     "@opencode-ai/plugin": "latest"
+  },
+  "devDependencies": {
+    "@tsconfig/node22": "^22.0.5",
+    "@types/node": "^25.2.2",
+    "typescript": "^5.9.3"
   }
 }

package/.github/workflows/npm-publish.yml

@@ -1,21 +0,0 @@
-name: npm publish
-
-on:
-  push:
-    branches:
-      - main
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-          registry-url: 'https://registry.npmjs.org'
-
-      - run: npm install
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/index.ts

@@ -1,370 +0,0 @@
-import type { Plugin } from "@opencode-ai/plugin";
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-
-interface FallbackModel {
-  providerID: string;
-  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[] = [
-  { providerID: "anthropic", modelID: "claude-sonnet-4-20250514" },
-  { providerID: "google", modelID: "gemini-2.5-pro" },
-  { providerID: "google", modelID: "gemini-2.5-flash" },
-];
-
-const DEFAULT_CONFIG: PluginConfig = {
-  fallbackModels: DEFAULT_FALLBACK_MODELS,
-  cooldownMs: 60 * 1000,
-  enabled: true,
-  fallbackMode: "cycle",
-};
-
-function loadConfig(directory: string): PluginConfig {
-  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"),
-  ];
-
-  for (const configPath of configPaths) {
-    if (existsSync(configPath)) {
-      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
-      }
-    }
-  }
-
-  return DEFAULT_CONFIG;
-}
-
-function getModelKey(providerID: string, modelID: string): string {
-  return `${providerID}/${modelID}`;
-}
-
-function isRateLimitError(error: any): boolean {
-  if (!error) return false;
-
-  if (error.name === "APIError" && error.data?.statusCode === 429) {
-    return true;
-  }
-
-  const responseBody = (error.data?.responseBody || "").toLowerCase();
-  const message = (error.data?.message || error.message || "").toLowerCase();
-  const errorName = (error.name || "").toLowerCase();
-
-  const rateLimitIndicators = [
-    "rate limit",
-    "rate_limit",
-    "ratelimit",
-    "too many requests",
-    "quota exceeded",
-    "resource exhausted",
-    "usage limit",
-    "high concurrency usage of this api",
-    "high concurrency",
-    "reduce concurrency",
-    "429",
-  ];
-
-  return rateLimitIndicators.some(
-    (indicator) =>
-      responseBody.includes(indicator) ||
-      message.includes(indicator) ||
-      errorName.includes(indicator)
-  );
-}
-
-export const RateLimitFallback: Plugin = async ({ client, directory }) => {
-  const config = loadConfig(directory);
-
-  if (!config.enabled) {
-    return {};
-  }
-
-  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
-
-  async function logOrToast(message: string, variant: "info" | "success" | "warning" | "error" = "info") {
-    try {
-      await client.tui.showToast({
-        body: { message, variant },
-      });
-    } catch {
-      await client.app.log({
-        body: {
-          service: "rate-limit-fallback",
-          level: variant,
-          message,
-        },
-      });
-    }
-  }
-
-  async function toast(title: string, message: string, variant: "info" | "success" | "warning" | "error" = "info") {
-    try {
-      await client.tui.showToast({
-        body: { title, message, variant },
-      });
-    } catch {
-      await client.app.log({
-        body: {
-          service: "rate-limit-fallback",
-          level: variant,
-          message: `${title}: ${message}`,
-        },
-      });
-    }
-  }
-
-  function isModelRateLimited(providerID: string, modelID: string): boolean {
-    const key = getModelKey(providerID, modelID);
-    const limitedAt = rateLimitedModels.get(key);
-    if (!limitedAt) return false;
-    if (Date.now() - limitedAt > config.cooldownMs) {
-      rateLimitedModels.delete(key);
-      return false;
-    }
-    return true;
-  }
-
-  function markModelRateLimited(providerID: string, modelID: string): void {
-    const key = getModelKey(providerID, modelID);
-    rateLimitedModels.set(key, Date.now());
-  }
-
-  function findNextAvailableModel(currentProviderID: string, currentModelID: string, attemptedModels: Set<string>): FallbackModel | null {
-    const currentKey = getModelKey(currentProviderID, currentModelID);
-    let startIndex = config.fallbackModels.findIndex(m => getModelKey(m.providerID, m.modelID) === currentKey);
-
-    // If current model is not in the fallback list, search from the beginning
-    if (startIndex === -1) {
-      // Only search through all models once (first loop handles this)
-      for (let i = 0; i < config.fallbackModels.length; i++) {
-        const model = config.fallbackModels[i];
-        const key = getModelKey(model.providerID, model.modelID);
-        if (!attemptedModels.has(key) && !isModelRateLimited(model.providerID, model.modelID)) {
-          return model;
-        }
-      }
-      return null;
-    }
-
-    // Search for the next model after current position
-    for (let i = startIndex + 1; i < config.fallbackModels.length; i++) {
-      const model = config.fallbackModels[i];
-      const key = getModelKey(model.providerID, model.modelID);
-      if (!attemptedModels.has(key) && !isModelRateLimited(model.providerID, model.modelID)) {
-        return model;
-      }
-    }
-
-    // Search from the beginning to current position (wrap around)
-    for (let i = 0; i <= startIndex && i < config.fallbackModels.length; i++) {
-      const model = config.fallbackModels[i];
-      const key = getModelKey(model.providerID, model.modelID);
-      if (!attemptedModels.has(key) && !isModelRateLimited(model.providerID, model.modelID)) {
-        return model;
-      }
-    }
-
-    return null;
-  }
-
-  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 toast("Rate Limit Detected", `Switching from ${currentModelID || 'current model'}...`, "warning");
-
-      const messagesResult = await client.session.messages({ path: { id: sessionID } });
-      if (!messagesResult.data) return;
-
-      const messages = messagesResult.data;
-      const lastUserMessage = [...messages].reverse().find(m => m.info.role === "user");
-      if (!lastUserMessage) return;
-
-      const stateKey = `${sessionID}:${lastUserMessage.info.id}`;
-      let state = retryState.get(stateKey);
-
-      if (!state || Date.now() - state.lastAttemptTime > 30000) {
-        state = { attemptedModels: new Set<string>(), lastAttemptTime: Date.now() };
-        retryState.set(stateKey, state);
-      }
-
-      if (currentProviderID && currentModelID) {
-        markModelRateLimited(currentProviderID, currentModelID);
-        state.attemptedModels.add(getModelKey(currentProviderID, currentModelID));
-      }
-
-      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 toast("Last Resort", `Trying ${lastModel.modelID} one more time...`, "warning");
-              } 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 toast(
-          "No Fallback Available",
-          config.fallbackMode === "stop"
-            ? "All fallback models exhausted"
-            : "All models are rate limited",
-          "error"
-        );
-        retryState.delete(stateKey);
-        fallbackInProgress.delete(sessionID);
-        return;
-      }
-
-      state.attemptedModels.add(getModelKey(nextModel.providerID, nextModel.modelID));
-      state.lastAttemptTime = Date.now();
-
-      const parts = lastUserMessage.parts
-        .filter((p: any) => p.type === "text" || p.type === "file")
-        .map((p: any) => {
-          if (p.type === "text") return { type: "text" as const, text: p.text };
-          if (p.type === "file") return { type: "file" as const, path: p.path, mediaType: p.mediaType };
-          return null;
-        })
-        .filter(Boolean);
-
-      if (parts.length === 0) return;
-
-      await toast("Retrying", `Using ${nextModel.providerID}/${nextModel.modelID}`, "info");
-
-      // Track the new model for this session
-      currentSessionModel.set(sessionID, { providerID: nextModel.providerID, modelID: nextModel.modelID });
-
-      await client.session.prompt({
-        path: { id: sessionID },
-        body: {
-          parts: parts as any,
-          model: { providerID: nextModel.providerID, modelID: nextModel.modelID },
-        },
-      });
-
-      await toast("Fallback Successful", `Now using ${nextModel.modelID}`, "success");
-
-      retryState.delete(stateKey);
-      // Clear fallback flag to allow next fallback if needed
-      fallbackInProgress.delete(sessionID);
-    } catch (err) {
-      // Fallback failed, clear the flag
-      fallbackInProgress.delete(sessionID);
-    }
-  }
-
-  return {
-    event: async ({ event }) => {
-      if (event.type === "session.error") {
-        const { sessionID, error } = event.properties as any;
-        if (sessionID && error && isRateLimitError(error)) {
-          await handleRateLimitFallback(sessionID, "", "");
-        }
-      }
-
-      if (event.type === "message.updated") {
-        const info = (event.properties as any)?.info;
-        if (info?.error && isRateLimitError(info.error)) {
-          await handleRateLimitFallback(info.sessionID, info.providerID || "", info.modelID || "");
-        }
-      }
-
-      if (event.type === "session.status") {
-        const props = event.properties as any;
-        const status = props?.status;
-
-        if (status?.type === "retry" && status?.message) {
-          const message = status.message.toLowerCase();
-          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, "", "");
-          }
-        }
-      }
-    },
-  };
-};
-
-export default RateLimitFallback;

package/rate-limit-fallback.example.json

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