@azumag/opencode-rate-limit-fallback 1.64.0 → 1.67.0

package/dist/index.js

@@ -240,6 +240,10 @@ export const RateLimitFallback = async ({ client, directory, worktree }) => {
             // Handle message.updated events
             if (isMessageUpdatedEvent(event)) {
                 const info = event.properties.info;
+                // Track model info for all assistant messages (needed to identify current model on session.error)
+                if (info?.providerID && info?.modelID && info?.sessionID) {
+                    fallbackHandler.setSessionModel(info.sessionID, info.providerID, info.modelID);
+                }
                 if (info?.error && errorPatternRegistry.isRateLimitError(info.error)) {
                     // Learn from this error if pattern learning is enabled
                     const patternLearner = errorPatternRegistry.getPatternLearner();

package/dist/src/config/Validator.js

@@ -143,7 +143,7 @@ export class ConfigValidator {
                     }
                 }
                 if (config.retryPolicy.strategy !== undefined) {
-                    const validStrategies = ['immediate', 'exponential', 'linear', 'custom'];
+                    const validStrategies = ['immediate', 'exponential', 'linear', 'polynomial', 'custom'];
                     if (!validStrategies.includes(config.retryPolicy.strategy)) {
                         errors.push({
                             path: 'retryPolicy.strategy',

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

@@ -43,13 +43,9 @@ export declare class FallbackHandler {
         modelID: string;
     } | null;
     /**
-     * Abort current session with error handling
-     */
-    private abortSession;
-    /**
-     * Queue prompt asynchronously (non-blocking), then abort retry loop.
-     * promptAsync FIRST queues pending work so that server doesn't dispose on idle.
-     * abort SECOND cancels the retry loop; the server sees the queued prompt and processes it.
+     * Queue prompt asynchronously (non-blocking) to schedule fallback.
+     * The server's retry loop finishes naturally; it then picks up the queued prompt.
+     * We do NOT call abort — its AbortController signal persists and kills the new stream.
      */
     retryWithModel(targetSessionID: string, model: FallbackModel, parts: MessagePart[], hierarchy: SessionHierarchy | null): Promise<void>;
     /**

package/dist/src/fallback/FallbackHandler.js

@@ -92,21 +92,9 @@ export class FallbackHandler {
         return tracked ? { providerID: tracked.providerID, modelID: tracked.modelID } : null;
     }
     /**
-     * Abort current session with error handling
-     */
-    async abortSession(sessionID) {
-        try {
-            await this.client.session.abort({ path: { id: sessionID } });
-        }
-        catch (abortError) {
-            // Silently ignore abort errors and continue with fallback
-            this.logger.debug(`Failed to abort session ${sessionID}`, { error: abortError });
-        }
-    }
-    /**
-     * Queue prompt asynchronously (non-blocking), then abort retry loop.
-     * promptAsync FIRST queues pending work so that server doesn't dispose on idle.
-     * abort SECOND cancels the retry loop; the server sees the queued prompt and processes it.
+     * Queue prompt asynchronously (non-blocking) to schedule fallback.
+     * The server's retry loop finishes naturally; it then picks up the queued prompt.
+     * We do NOT call abort — its AbortController signal persists and kills the new stream.
      */
     async retryWithModel(targetSessionID, model, parts, hierarchy) {
         // Record model usage for dynamic prioritization
@@ -152,11 +140,13 @@ export class FallbackHandler {
                 model: { providerID: model.providerID, modelID: model.modelID },
             },
         });
-        // 2. abort: cancel the retry loop; server sees queued prompt and processes it
-        await this.abortSession(targetSessionID);
+        // Do NOT call abort after promptAsync.
+        // The AbortController signal persists and kills the newly queued stream too,
+        // causing "interrupted" in TUI mode and server disposal in headless mode.
+        // Let the server's retry loop finish naturally; it will pick up the queued prompt.
         await safeShowToast(this.client, {
             body: {
-                title: "Fallback Successful",
+                title: "Fallback Queued",
                 message: `Now using ${model.modelID}`,
                 variant: "success",
                 duration: 3000,

package/package.json

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