@azumag/opencode-rate-limit-fallback 1.0.12 → 1.0.13

package/dist/index.js

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync, appendFileSync } from "fs";
-import { join } from "path";
+import { existsSync, readFileSync, appendFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
 // Debug log at module level
 console.log("[rate-limit-fallback] Module loaded, version:", process.env.npm_package_version || "unknown");
 const DEFAULT_FALLBACK_MODELS = [
@@ -74,6 +74,11 @@ function isRateLimitError(error) {
 export const RateLimitFallback = async ({ client, directory }) => {
     const config = loadConfig(directory);
     const logFilePath = join(process.env.HOME || "", ".opencode", "rate-limit-fallback-debug.log");
+    // Ensure log directory exists
+    try {
+        mkdirSync(dirname(logFilePath), { recursive: true });
+    }
+    catch { }
     // Write to file for debugging
     const logToFile = (message) => {
         try {
@@ -227,12 +232,16 @@ export const RateLimitFallback = async ({ client, directory }) => {
             }
             // Fetch messages BEFORE abort — session must still be alive
             const messagesResult = await client.session.messages({ path: { id: sessionID } });
-            if (!messagesResult.data)
+            if (!messagesResult.data) {
+                fallbackInProgress.delete(sessionID);
                 return;
+            }
             const messages = messagesResult.data;
             const lastUserMessage = [...messages].reverse().find(m => m.info.role === "user");
-            if (!lastUserMessage)
+            if (!lastUserMessage) {
+                fallbackInProgress.delete(sessionID);
                 return;
+            }
             toast("Rate Limit Detected", `Switching from ${currentModelID || 'current model'}...`, "warning").catch(() => { });
             const stateKey = `${sessionID}:${lastUserMessage.info.id}`;
             let state = retryState.get(stateKey);
@@ -297,18 +306,17 @@ export const RateLimitFallback = async ({ client, directory }) => {
                 return null;
             })
                 .filter(Boolean);
-            if (parts.length === 0)
+            if (parts.length === 0) {
+                fallbackInProgress.delete(sessionID);
                 return;
-            toast("Retrying", `Using ${nextModel.providerID}/${nextModel.modelID}`, "info").catch(() => { });
+            }
             // Track the new model for this session
             currentSessionModel.set(sessionID, { providerID: nextModel.providerID, modelID: nextModel.modelID });
             const promptBody = {
                 parts: parts,
                 model: { providerID: nextModel.providerID, modelID: nextModel.modelID },
             };
-            // Abort first to cancel the retry loop, then promptAsync immediately
-            // The abort→promptAsync gap is minimal, so even in headless mode
-            // the server won't shut down before promptAsync fires
+            // Abort to cancel the retry loop
             try {
                 await client.session.abort({ path: { id: sessionID } });
                 logToFile(`abort succeeded for session ${sessionID}`);
@@ -316,11 +324,27 @@ export const RateLimitFallback = async ({ client, directory }) => {
             catch (abortErr) {
                 logToFile(`abort failed (non-critical): ${abortErr}`);
             }
-            await client.session.promptAsync({
-                path: { id: sessionID },
-                body: promptBody,
-            });
-            logToFile(`promptAsync sent successfully for session ${sessionID} with model ${nextModel.providerID}/${nextModel.modelID}`);
+            // await toast AFTER abort — provides natural delay (~50ms) for abort flag to clear
+            // before prompting. Without this delay, the new prompt gets immediately aborted.
+            await toast("Retrying", `Using ${nextModel.providerID}/${nextModel.modelID}`, "info");
+            // Try prompt (sync) first — reliably triggers generation in TUI mode.
+            // If it fails (e.g. run mode where server shuts down after abort),
+            // fall back to promptAsync which fires before server can exit.
+            try {
+                await client.session.prompt({
+                    path: { id: sessionID },
+                    body: promptBody,
+                });
+                logToFile(`prompt completed successfully for session ${sessionID} with model ${nextModel.providerID}/${nextModel.modelID}`);
+            }
+            catch (promptErr) {
+                logToFile(`prompt failed (${promptErr}), falling back to promptAsync`);
+                await client.session.promptAsync({
+                    path: { id: sessionID },
+                    body: promptBody,
+                });
+                logToFile(`promptAsync sent successfully for session ${sessionID} with model ${nextModel.providerID}/${nextModel.modelID}`);
+            }
             toast("Fallback Successful", `Now using ${nextModel.modelID}`, "success").catch(() => { });
             retryState.delete(stateKey);
             // Clear fallback flag to allow next fallback if needed

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@azumag/opencode-rate-limit-fallback",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "description": "OpenCode plugin that automatically switches to fallback models when rate limited",
   "type": "module",
   "main": "./dist/index.js",
   "scripts": {
     "build": "tsc",
+    "test": "vitest",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -40,6 +41,7 @@
   "devDependencies": {
     "@tsconfig/node22": "^22.0.5",
     "@types/node": "^25.2.2",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
   }
 }