@azumag/opencode-rate-limit-fallback 1.21.1 → 1.23.0

package/dist/index.d.ts

@@ -7,5 +7,4 @@ import type { Plugin } from "@opencode-ai/plugin";
 export declare const RateLimitFallback: Plugin;
 export default RateLimitFallback;
 export type { PluginConfig, MetricsConfig, FallbackModel, FallbackMode } from "./src/types/index.js";
-export { MetricsManager } from "./src/metrics/MetricsManager.js";
-export { createLogger, type LogConfig, type Logger } from "./logger.js";
+export type { LogConfig, Logger } from "./logger.js";

package/dist/index.js

@@ -3,14 +3,12 @@
  *
  * This plugin automatically switches to fallback models when rate limited
  */
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
 import { createLogger } from "./logger.js";
 import { MetricsManager } from "./src/metrics/MetricsManager.js";
 import { FallbackHandler } from "./src/fallback/FallbackHandler.js";
 import { loadConfig } from "./src/utils/config.js";
 import { isRateLimitError } from "./src/utils/errorDetection.js";
-import { initSubagentTracker, registerSubagent, getRootSession, getHierarchy, cleanupStaleEntries as clearHierarchyEntries, clearAll as clearAllHierarchies, } from "./src/session/SubagentTracker.js";
+import { SubagentTracker } from "./src/session/SubagentTracker.js";
 import { CLEANUP_INTERVAL_MS } from "./src/types/index.js";
 // ============================================================================
 // Event Type Guards
@@ -66,39 +64,16 @@ export const RateLimitFallback = async ({ client, directory }) => {
     };
     // Create logger instance
     const logger = createLogger(logConfig, "RateLimitFallback");
-    // Log config load errors (if any) after logger is initialized
-    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 {
-                readFileSync(configPath, "utf-8");
-            }
-            catch (error) {
-                logger.error(`Failed to load config from ${configPath}`, { error });
-            }
-        }
-    }
     if (!config.enabled) {
         return {};
     }
     // Initialize components
-    initSubagentTracker(config);
+    const subagentTracker = new SubagentTracker(config);
     const metricsManager = new MetricsManager(config.metrics ?? { enabled: false, output: { console: true, format: "pretty" }, resetInterval: "daily" }, logger);
-    // Create hierarchy resolver to avoid circular dependency
-    const hierarchyResolver = {
-        getRootSession: getRootSession,
-        getHierarchy: getHierarchy,
-    };
-    const fallbackHandler = new FallbackHandler(config, client, logger, metricsManager, hierarchyResolver);
+    const fallbackHandler = new FallbackHandler(config, client, logger, metricsManager, subagentTracker);
     // Cleanup stale entries periodically
     const cleanupInterval = setInterval(() => {
-        clearHierarchyEntries();
+        subagentTracker.cleanupStaleEntries();
         fallbackHandler.cleanupStaleEntries();
     }, CLEANUP_INTERVAL_MS);
     return {
@@ -146,19 +121,17 @@ export const RateLimitFallback = async ({ client, directory }) => {
             if (isSubagentSessionCreatedEvent(rawEvent)) {
                 const { sessionID, parentSessionID } = rawEvent.properties;
                 if (config.enableSubagentFallback !== false) {
-                    registerSubagent(sessionID, parentSessionID, config);
+                    subagentTracker.registerSubagent(sessionID, parentSessionID);
                 }
             }
         },
         // Cleanup function to prevent memory leaks
         cleanup: () => {
             clearInterval(cleanupInterval);
-            clearAllHierarchies();
+            subagentTracker.clearAll();
             metricsManager.destroy();
             fallbackHandler.destroy();
         },
     };
 };
 export default RateLimitFallback;
-export { MetricsManager } from "./src/metrics/MetricsManager.js";
-export { createLogger } from "./logger.js";

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

@@ -4,13 +4,7 @@
 import type { Logger } from '../../logger.js';
 import type { FallbackModel, PluginConfig, OpenCodeClient, MessagePart, SessionHierarchy } from '../types/index.js';
 import { MetricsManager } from '../metrics/MetricsManager.js';
-/**
- * Hierarchy resolver functions
- */
-export type HierarchyResolver = {
-    getRootSession: (sessionID: string) => string | null;
-    getHierarchy: (sessionID: string) => SessionHierarchy | null;
-};
+import type { SubagentTracker } from '../session/SubagentTracker.js';
 /**
  * Fallback Handler class for orchestrating the fallback retry flow
  */
@@ -25,8 +19,8 @@ export declare class FallbackHandler {
     private fallbackInProgress;
     private fallbackMessages;
     private metricsManager;
-    private hierarchyResolver;
-    constructor(config: PluginConfig, client: OpenCodeClient, logger: Logger, metricsManager: MetricsManager, hierarchyResolver: HierarchyResolver);
+    private subagentTracker;
+    constructor(config: PluginConfig, client: OpenCodeClient, logger: Logger, metricsManager: MetricsManager, subagentTracker: SubagentTracker);
     /**
      * Check and mark fallback in progress for deduplication
      */

package/dist/src/fallback/FallbackHandler.js

@@ -1,6 +1,7 @@
 /**
  * Fallback orchestration logic
  */
+import { SESSION_ENTRY_TTL_MS } from '../types/index.js';
 import { ModelSelector } from './ModelSelector.js';
 import { extractMessageParts, convertPartsToSDKFormat, safeShowToast, getStateKey, getModelKey, DEDUP_WINDOW_MS, STATE_TIMEOUT_MS } from '../utils/helpers.js';
 /**
@@ -18,15 +19,15 @@ export class FallbackHandler {
     fallbackMessages;
     // Metrics manager reference
     metricsManager;
-    // Hierarchy resolver
-    hierarchyResolver;
-    constructor(config, client, logger, metricsManager, hierarchyResolver) {
+    // Subagent tracker reference
+    subagentTracker;
+    constructor(config, client, logger, metricsManager, subagentTracker) {
         this.config = config;
         this.client = client;
         this.logger = logger;
         this.modelSelector = new ModelSelector(config, client);
         this.metricsManager = metricsManager;
-        this.hierarchyResolver = hierarchyResolver;
+        this.subagentTracker = subagentTracker;
         this.currentSessionModel = new Map();
         this.modelRequestStartTimes = new Map();
         this.retryState = new Map();
@@ -132,10 +133,10 @@ export class FallbackHandler {
      */
     async handleRateLimitFallback(sessionID, currentProviderID, currentModelID) {
         try {
-            // Get root session and hierarchy using resolver
-            const rootSessionID = this.hierarchyResolver.getRootSession(sessionID);
+            // Get root session and hierarchy using subagent tracker
+            const rootSessionID = this.subagentTracker.getRootSession(sessionID);
             const targetSessionID = rootSessionID || sessionID;
-            const hierarchy = this.hierarchyResolver.getHierarchy(sessionID);
+            const hierarchy = this.subagentTracker.getHierarchy(sessionID);
             // If no model info provided, try to get from tracked session model
             if (!currentProviderID || !currentModelID) {
                 const tracked = this.currentSessionModel.get(targetSessionID);
@@ -308,7 +309,6 @@ export class FallbackHandler {
      * Clean up stale entries
      */
     cleanupStaleEntries() {
-        const { STATE_TIMEOUT_MS, SESSION_ENTRY_TTL_MS } = require('../types/index.js');
         const now = Date.now();
         for (const [sessionID, entry] of this.currentSessionModel.entries()) {
             if (now - entry.lastUpdated > SESSION_ENTRY_TTL_MS) {

package/dist/src/session/SubagentTracker.d.ts

@@ -3,34 +3,35 @@
  */
 import type { SessionHierarchy, PluginConfig } from '../types/index.js';
 /**
- * Initialize subagent tracker with config
- */
-export declare function initSubagentTracker(config: PluginConfig): void;
-/**
- * Register a new subagent in the hierarchy
- */
-export declare function registerSubagent(sessionID: string, parentSessionID: string, config: PluginConfig): boolean;
-/**
- * Get root session ID for a session
- */
-export declare function getRootSession(sessionID: string): string | null;
-/**
- * Get hierarchy for a session
- */
-export declare function getHierarchy(sessionID: string): SessionHierarchy | null;
-/**
- * Get all session hierarchies (for cleanup)
- */
-export declare function getAllHierarchies(): Map<string, SessionHierarchy>;
-/**
- * Get session to root map (for cleanup)
- */
-export declare function getSessionToRootMap(): Map<string, string>;
-/**
- * Clean up stale hierarchies
- */
-export declare function cleanupStaleEntries(): void;
-/**
- * Clean up all hierarchies
- */
-export declare function clearAll(): void;
+ * SubagentTracker class for managing session hierarchies
+ */
+export declare class SubagentTracker {
+    private sessionHierarchies;
+    private sessionToRootMap;
+    private maxSubagentDepth;
+    constructor(config: PluginConfig);
+    /**
+     * Register a new subagent in the hierarchy
+     */
+    registerSubagent(sessionID: string, parentSessionID: string): boolean;
+    /**
+     * Get root session ID for a session
+     */
+    getRootSession(sessionID: string): string | null;
+    /**
+     * Get hierarchy for a session
+     */
+    getHierarchy(sessionID: string): SessionHierarchy | null;
+    /**
+     * Get or create hierarchy for a root session
+     */
+    private getOrCreateHierarchy;
+    /**
+     * Clean up stale hierarchies
+     */
+    cleanupStaleEntries(): void;
+    /**
+     * Clean up all hierarchies
+     */
+    clearAll(): void;
+}

package/dist/src/session/SubagentTracker.js

@@ -3,112 +3,119 @@
  */
 import { SESSION_ENTRY_TTL_MS } from '../types/index.js';
 /**
- * Session Hierarchy storage
+ * SubagentTracker class for managing session hierarchies
  */
-const sessionHierarchies = new Map();
-const sessionToRootMap = new Map();
-let maxSubagentDepth = 10;
-/**
- * Initialize subagent tracker with config
- */
-export function initSubagentTracker(config) {
-    maxSubagentDepth = config.maxSubagentDepth ?? 10;
-}
-/**
- * Register a new subagent in the hierarchy
- */
-export function registerSubagent(sessionID, parentSessionID, config) {
-    // Validate parent session exists
-    // Parent session must either be registered in sessionToRootMap or be a new root session
-    const parentRootSessionID = sessionToRootMap.get(parentSessionID);
-    // Determine root session - if parent doesn't exist, treat it as a new root
-    const rootSessionID = parentRootSessionID || parentSessionID;
-    // If parent is not a subagent but we're treating it as a root, create a hierarchy for it
-    // This allows sessions to become roots when their first subagent is registered
-    const hierarchy = getOrCreateHierarchy(rootSessionID, config);
-    const parentSubagent = hierarchy.subagents.get(parentSessionID);
-    const depth = parentSubagent ? parentSubagent.depth + 1 : 1;
-    // Enforce max depth
-    if (depth > maxSubagentDepth) {
-        return false;
+export class SubagentTracker {
+    sessionHierarchies;
+    sessionToRootMap;
+    maxSubagentDepth;
+    constructor(config) {
+        this.sessionHierarchies = new Map();
+        this.sessionToRootMap = new Map();
+        this.maxSubagentDepth = config.maxSubagentDepth ?? 10;
     }
-    const subagent = {
-        sessionID,
-        parentSessionID,
-        depth,
-        fallbackState: "none",
-        createdAt: Date.now(),
-        lastActivity: Date.now(),
-    };
-    hierarchy.subagents.set(sessionID, subagent);
-    sessionToRootMap.set(sessionID, rootSessionID);
-    hierarchy.lastActivity = Date.now();
-    return true;
-}
-/**
- * Get or create hierarchy for a root session
- */
-function getOrCreateHierarchy(rootSessionID, config) {
-    let hierarchy = sessionHierarchies.get(rootSessionID);
-    if (!hierarchy) {
-        hierarchy = {
-            rootSessionID,
-            subagents: new Map(),
-            sharedFallbackState: "none",
-            sharedConfig: config,
+    /**
+     * Register a new subagent in the hierarchy
+     */
+    registerSubagent(sessionID, parentSessionID) {
+        // Validate parent session exists
+        // Parent session must either be registered in sessionToRootMap or be a new root session
+        const parentRootSessionID = this.sessionToRootMap.get(parentSessionID);
+        // Determine root session - if parent doesn't exist, treat it as a new root
+        const rootSessionID = parentRootSessionID || parentSessionID;
+        // If parent is not a subagent but we're treating it as a root, create a hierarchy for it
+        // This allows sessions to become roots when their first subagent is registered
+        const hierarchy = this.getOrCreateHierarchy(rootSessionID);
+        const parentSubagent = hierarchy.subagents.get(parentSessionID);
+        const depth = parentSubagent ? parentSubagent.depth + 1 : 1;
+        // Enforce max depth
+        if (depth > this.maxSubagentDepth) {
+            return false;
+        }
+        const subagent = {
+            sessionID,
+            parentSessionID,
+            depth,
+            fallbackState: "none",
             createdAt: Date.now(),
             lastActivity: Date.now(),
         };
-        sessionHierarchies.set(rootSessionID, hierarchy);
-        sessionToRootMap.set(rootSessionID, rootSessionID);
+        hierarchy.subagents.set(sessionID, subagent);
+        this.sessionToRootMap.set(sessionID, rootSessionID);
+        hierarchy.lastActivity = Date.now();
+        return true;
     }
-    return hierarchy;
-}
-/**
- * Get root session ID for a session
- */
-export function getRootSession(sessionID) {
-    return sessionToRootMap.get(sessionID) || null;
-}
-/**
- * Get hierarchy for a session
- */
-export function getHierarchy(sessionID) {
-    const rootSessionID = getRootSession(sessionID);
-    return rootSessionID ? sessionHierarchies.get(rootSessionID) || null : null;
-}
-/**
- * Get all session hierarchies (for cleanup)
- */
-export function getAllHierarchies() {
-    return sessionHierarchies;
-}
-/**
- * Get session to root map (for cleanup)
- */
-export function getSessionToRootMap() {
-    return sessionToRootMap;
-}
-/**
- * Clean up stale hierarchies
- */
-export function cleanupStaleEntries() {
-    const now = Date.now();
-    for (const [rootSessionID, hierarchy] of sessionHierarchies.entries()) {
-        if (now - hierarchy.lastActivity > SESSION_ENTRY_TTL_MS) {
-            // Clean up all subagents in this hierarchy
-            for (const subagentID of hierarchy.subagents.keys()) {
-                sessionToRootMap.delete(subagentID);
+    /**
+     * Get root session ID for a session
+     */
+    getRootSession(sessionID) {
+        return this.sessionToRootMap.get(sessionID) || null;
+    }
+    /**
+     * Get hierarchy for a session
+     */
+    getHierarchy(sessionID) {
+        const rootSessionID = this.getRootSession(sessionID);
+        return rootSessionID && this.sessionHierarchies.has(rootSessionID) ? this.sessionHierarchies.get(rootSessionID) : null;
+    }
+    /**
+     * Get or create hierarchy for a root session
+     */
+    getOrCreateHierarchy(rootSessionID) {
+        let hierarchy = this.sessionHierarchies.get(rootSessionID);
+        if (!hierarchy) {
+            hierarchy = {
+                rootSessionID,
+                subagents: new Map(),
+                sharedFallbackState: "none",
+                sharedConfig: {
+                    fallbackModels: [],
+                    cooldownMs: 60 * 1000,
+                    enabled: true,
+                    fallbackMode: "cycle",
+                    log: {
+                        level: "warn",
+                        format: "simple",
+                        enableTimestamp: true,
+                    },
+                    metrics: {
+                        enabled: false,
+                        output: {
+                            console: true,
+                            format: "pretty",
+                        },
+                        resetInterval: "daily",
+                    },
+                },
+                createdAt: Date.now(),
+                lastActivity: Date.now(),
+            };
+            this.sessionHierarchies.set(rootSessionID, hierarchy);
+            this.sessionToRootMap.set(rootSessionID, rootSessionID);
+        }
+        return hierarchy;
+    }
+    /**
+     * Clean up stale hierarchies
+     */
+    cleanupStaleEntries() {
+        const now = Date.now();
+        for (const [rootSessionID, hierarchy] of this.sessionHierarchies.entries()) {
+            if (now - hierarchy.lastActivity > SESSION_ENTRY_TTL_MS) {
+                // Clean up all subagents in this hierarchy
+                for (const subagentID of hierarchy.subagents.keys()) {
+                    this.sessionToRootMap.delete(subagentID);
+                }
+                this.sessionHierarchies.delete(rootSessionID);
+                this.sessionToRootMap.delete(rootSessionID);
             }
-            sessionHierarchies.delete(rootSessionID);
-            sessionToRootMap.delete(rootSessionID);
         }
     }
-}
-/**
- * Clean up all hierarchies
- */
-export function clearAll() {
-    sessionHierarchies.clear();
-    sessionToRootMap.clear();
+    /**
+     * Clean up all hierarchies
+     */
+    clearAll() {
+        this.sessionHierarchies.clear();
+        this.sessionToRootMap.clear();
+    }
 }

package/package.json

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