@azumag/opencode-rate-limit-fallback 1.0.19 → 1.0.20

package/dist/index.js

@@ -214,7 +214,7 @@ export const RateLimitFallback = async ({ client, directory }) => {
         }
         return null;
     }
-    async function handleRateLimitFallback(sessionID, currentProviderID, currentModelID) {
+    async function handleRateLimitFallback(sessionID, currentProviderID, currentModelID, skipAbort = false) {
         try {
             // Prevent duplicate fallback processing within 5 seconds
             const lastFallback = fallbackInProgress.get(sessionID);
@@ -316,28 +316,29 @@ export const RateLimitFallback = async ({ client, directory }) => {
                 parts: parts,
                 model: { providerID: nextModel.providerID, modelID: nextModel.modelID },
             };
-            // abort → promptAsync: works in TUI, fails in headless (server disposes)
-            // promptAsync → abort: fails in TUI (abort kills the new prompt too)
+            // promptAsync → abort: send fallback prompt first, then abort the old request
+            // This prevents the abort from killing the new fallback prompt.
             //
-            // Use abort → promptAsync as the primary path (TUI confirmed working).
-            // Headless mode (opencode run) is a known limitation — the server
-            // dispose sequence interrupts the new prompt before it can complete.
+            // For session.error events, the request is already in error state, so we
+            // only send promptAsync (skipAbort = true). For retry status, we send both.
             //
             // promptAsync: HTTP POST /session/{id}/prompt_async → 204 (SDK sdk.gen.js).
             const t0 = Date.now();
-            try {
-                await client.session.abort({ path: { id: sessionID } });
-                logToFile(`abort succeeded for session ${sessionID} (${Date.now() - t0}ms)`);
-            }
-            catch (abortErr) {
-                logToFile(`abort failed (${Date.now() - t0}ms): ${abortErr}`);
-            }
-            const t1 = Date.now();
             await client.session.promptAsync({
                 path: { id: sessionID },
                 body: promptBody,
             });
-            logToFile(`promptAsync completed for session ${sessionID} (${Date.now() - t1}ms, total ${Date.now() - t0}ms) with model ${nextModel.providerID}/${nextModel.modelID}`);
+            const t1 = Date.now();
+            if (!skipAbort) {
+                try {
+                    await client.session.abort({ path: { id: sessionID } });
+                    logToFile(`abort succeeded for session ${sessionID} (${Date.now() - t1}ms, total ${Date.now() - t0}ms)`);
+                }
+                catch (abortErr) {
+                    logToFile(`abort failed (${Date.now() - t1}ms): ${abortErr}`);
+                }
+            }
+            logToFile(`promptAsync completed for session ${sessionID} (${Date.now() - t0}ms) with model ${nextModel.providerID}/${nextModel.modelID}`);
             // Toast is best-effort notification. The toast() function (line ~185) has
             // built-in fallback: showToast failure → app.log. After promptAsync the
             // server may already be disposing, so both showToast and app.log could fail.
@@ -399,7 +400,7 @@ export const RateLimitFallback = async ({ client, directory }) => {
                     catch {
                         console.log("[rate-limit-fallback] Rate limit error detected, attempting fallback");
                     }
-                    await handleRateLimitFallback(sessionID, "", "");
+                    await handleRateLimitFallback(sessionID, "", "", true); // skipAbort = true (already in error state)
                 }
             }
             if (event.type === "message.updated") {
@@ -438,7 +439,7 @@ export const RateLimitFallback = async ({ client, directory }) => {
                     catch {
                         console.log("[rate-limit-fallback] Rate limit error in message, attempting fallback");
                     }
-                    await handleRateLimitFallback(info.sessionID, info.providerID || "", info.modelID || "");
+                    await handleRateLimitFallback(info.sessionID, info.providerID || "", info.modelID || "", true); // skipAbort = true (already in error state)
                 }
             }
             if (event.type === "session.status") {
@@ -457,6 +458,23 @@ export const RateLimitFallback = async ({ client, directory }) => {
                 catch {
                     console.log("[rate-limit-fallback] session.status:", status);
                 }
+                if (status?.type === "interrupted") {
+                    // Handle interrupted session - resend prompt with fallback model (skip abort)
+                    logToFile("Session interrupted, attempting to resend prompt");
+                    try {
+                        await client.app.log({
+                            body: {
+                                service: "rate-limit-fallback",
+                                level: "info",
+                                message: "Session interrupted, attempting to resend prompt",
+                            },
+                        });
+                    }
+                    catch {
+                        console.log("[rate-limit-fallback] Session interrupted, attempting to resend prompt");
+                    }
+                    await handleRateLimitFallback(props.sessionID, "", "", true); // skipAbort = true
+                }
                 if (status?.type === "retry" && status?.message) {
                     const message = status.message.toLowerCase();
                     const isRateLimitRetry = message.includes("usage limit") ||

package/package.json

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