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

package/dist/index.js

@@ -1,5 +1,7 @@
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync, appendFileSync } from "fs";
 import { join } 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 = [
     { providerID: "anthropic", modelID: "claude-sonnet-4-20250514" },
     { providerID: "google", modelID: "gemini-2.5-pro" },
@@ -71,7 +73,44 @@ 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");
+    // Write to file for debugging
+    const logToFile = (message) => {
+        try {
+            appendFileSync(logFilePath, `[${new Date().toISOString()}] ${message}\n`);
+        }
+        catch { }
+    };
+    logToFile(`Plugin loaded, config: ${JSON.stringify(config)}`);
+    console.log("[rate-limit-fallback] Plugin loaded, config:", config);
+    // Use client.app.log for better logging in both run and TUI modes
+    try {
+        await client.app.log({
+            body: {
+                service: "rate-limit-fallback",
+                level: "info",
+                message: `Plugin loaded, config: ${JSON.stringify(config)}`,
+            },
+        });
+    }
+    catch (e) {
+        logToFile(`client.app.log failed: ${e}`);
+        console.log("[rate-limit-fallback] Plugin loaded, config:", config);
+    }
     if (!config.enabled) {
+        logToFile("Plugin disabled, returning empty object");
+        try {
+            await client.app.log({
+                body: {
+                    service: "rate-limit-fallback",
+                    level: "info",
+                    message: "Plugin disabled, returning empty object",
+                },
+            });
+        }
+        catch {
+            console.log("[rate-limit-fallback] Plugin disabled, returning empty object");
+        }
         return {};
     }
     const rateLimitedModels = new Map();
@@ -283,29 +322,135 @@ export const RateLimitFallback = async ({ client, directory }) => {
     }
     return {
         event: async ({ event }) => {
+            // Log events to debug plugin execution
+            logToFile(`Event received: ${event.type}`);
+            try {
+                await client.app.log({
+                    body: {
+                        service: "rate-limit-fallback",
+                        level: "debug",
+                        message: `Event received: ${event.type}`,
+                    },
+                });
+            }
+            catch (e) {
+                logToFile(`client.app.log failed for event: ${e}`);
+                console.log("[rate-limit-fallback] Event received:", event.type);
+            }
             if (event.type === "session.error") {
                 const { sessionID, error } = event.properties;
+                logToFile(`session.error: sessionID=${sessionID}, error=${JSON.stringify(error)}`);
+                try {
+                    await client.app.log({
+                        body: {
+                            service: "rate-limit-fallback",
+                            level: "debug",
+                            message: `session.error: sessionID=${sessionID}, error=${JSON.stringify(error)}`,
+                        },
+                    });
+                }
+                catch {
+                    console.log("[rate-limit-fallback] session.error:", sessionID, error);
+                }
                 if (sessionID && error && isRateLimitError(error)) {
+                    logToFile("Rate limit error detected, attempting fallback");
+                    try {
+                        await client.app.log({
+                            body: {
+                                service: "rate-limit-fallback",
+                                level: "info",
+                                message: "Rate limit error detected, attempting fallback",
+                            },
+                        });
+                    }
+                    catch {
+                        console.log("[rate-limit-fallback] Rate limit error detected, attempting fallback");
+                    }
                     await handleRateLimitFallback(sessionID, "", "");
                 }
             }
             if (event.type === "message.updated") {
                 const info = event.properties?.info;
+                logToFile(`message.updated: ${JSON.stringify(info)}`);
+                try {
+                    await client.app.log({
+                        body: {
+                            service: "rate-limit-fallback",
+                            level: "debug",
+                            message: `message.updated: ${JSON.stringify(info)}`,
+                        },
+                    });
+                }
+                catch {
+                    console.log("[rate-limit-fallback] message.updated:", info);
+                }
                 if (info?.error && isRateLimitError(info.error)) {
+                    logToFile("Rate limit error in message, attempting fallback");
+                    try {
+                        await client.app.log({
+                            body: {
+                                service: "rate-limit-fallback",
+                                level: "info",
+                                message: "Rate limit error in message, attempting fallback",
+                            },
+                        });
+                    }
+                    catch {
+                        console.log("[rate-limit-fallback] Rate limit error in message, attempting fallback");
+                    }
                     await handleRateLimitFallback(info.sessionID, info.providerID || "", info.modelID || "");
                 }
             }
             if (event.type === "session.status") {
                 const props = event.properties;
                 const status = props?.status;
+                logToFile(`session.status: ${JSON.stringify(status)}`);
+                try {
+                    await client.app.log({
+                        body: {
+                            service: "rate-limit-fallback",
+                            level: "debug",
+                            message: `session.status: ${JSON.stringify(status)}`,
+                        },
+                    });
+                }
+                catch {
+                    console.log("[rate-limit-fallback] session.status:", 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");
+                    logToFile(`Is rate limit retry: ${isRateLimitRetry}, message: ${message}`);
+                    try {
+                        await client.app.log({
+                            body: {
+                                service: "rate-limit-fallback",
+                                level: "debug",
+                                message: `Is rate limit retry: ${isRateLimitRetry}, message: ${message}`,
+                            },
+                        });
+                    }
+                    catch {
+                        console.log("[rate-limit-fallback] Is rate limit retry:", isRateLimitRetry, "message:", message);
+                    }
                     if (isRateLimitRetry) {
                         // Try fallback on any attempt, handleRateLimitFallback will manage state
+                        logToFile("Attempting fallback for rate limit retry");
+                        try {
+                            await client.app.log({
+                                body: {
+                                    service: "rate-limit-fallback",
+                                    level: "info",
+                                    message: "Attempting fallback for rate limit retry",
+                                },
+                            });
+                        }
+                        catch {
+                            console.log("[rate-limit-fallback] Attempting fallback for rate limit retry");
+                        }
                         await handleRateLimitFallback(props.sessionID, "", "");
                     }
                 }

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@azumag/opencode-rate-limit-fallback",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "OpenCode plugin that automatically switches to fallback models when rate limited",
   "type": "module",
+  "main": "./dist/index.js",
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build"