@azumag/opencode-rate-limit-fallback 1.35.0 → 1.36.0

package/dist/index.d.ts

@@ -8,3 +8,4 @@ export declare const RateLimitFallback: Plugin;
 export default RateLimitFallback;
 export type { PluginConfig, MetricsConfig, FallbackModel, FallbackMode, CircuitBreakerConfig, CircuitBreakerState, CircuitBreakerStateType } from "./src/types/index.js";
 export type { LogConfig, Logger } from "./logger.js";
+export { Logger as LoggerClass } from "./logger.js";

package/dist/index.js

@@ -7,9 +7,12 @@ 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 { SubagentTracker } from "./src/session/SubagentTracker.js";
 import { CLEANUP_INTERVAL_MS } from "./src/types/index.js";
+import { ConfigValidator } from "./src/config/Validator.js";
+import { ErrorPatternRegistry } from "./src/errors/PatternRegistry.js";
+import { HealthTracker } from "./src/health/HealthTracker.js";
+import { DiagnosticReporter } from "./src/diagnostics/Reporter.js";
 // ============================================================================
 // Event Type Guards
 // ============================================================================
@@ -70,38 +73,76 @@ export const RateLimitFallback = async ({ client, directory, worktree }) => {
     else {
         logger.info("No config file found, using defaults");
     }
+    // Initialize configuration validator
+    const validator = new ConfigValidator(logger);
+    const validation = configSource
+        ? validator.validateFile(configSource, config.configValidation)
+        : validator.validate(config, config.configValidation);
+    if (!validation.isValid && config.configValidation?.strict) {
+        logger.error("Configuration validation failed in strict mode. Plugin will not load.");
+        logger.error(`Errors: ${validation.errors.map(e => `${e.path}: ${e.message}`).join(', ')}`);
+        return {};
+    }
+    if (validation.errors.length > 0) {
+        logger.warn(`Configuration validation found ${validation.errors.length} error(s)`);
+    }
+    if (validation.warnings.length > 0) {
+        logger.warn(`Configuration validation found ${validation.warnings.length} warning(s)`);
+    }
     if (!config.enabled) {
         return {};
     }
+    // Initialize error pattern registry
+    const errorPatternRegistry = new ErrorPatternRegistry(logger);
+    if (config.errorPatterns?.custom) {
+        errorPatternRegistry.registerMany(config.errorPatterns.custom);
+    }
+    // Initialize health tracker
+    let healthTracker;
+    if (config.enableHealthBasedSelection) {
+        healthTracker = new HealthTracker(config, logger);
+        logger.info("Health-based model selection enabled");
+    }
+    // Initialize diagnostic reporter
+    const diagnostics = new DiagnosticReporter(config, configSource || 'default', healthTracker, undefined, // circuitBreaker will be initialized in FallbackHandler
+    errorPatternRegistry, logger);
+    // Log startup diagnostics if verbose mode
+    if (config.verbose) {
+        logger.debug("Verbose mode enabled - showing diagnostic information");
+        diagnostics.logCurrentConfig();
+    }
     // Initialize components
     const subagentTracker = new SubagentTracker(config);
     const metricsManager = new MetricsManager(config.metrics ?? { enabled: false, output: { console: true, format: "pretty" }, resetInterval: "daily" }, logger);
-    const fallbackHandler = new FallbackHandler(config, client, logger, metricsManager, subagentTracker);
+    const fallbackHandler = new FallbackHandler(config, client, logger, metricsManager, subagentTracker, healthTracker);
     // Cleanup stale entries periodically
     const cleanupInterval = setInterval(() => {
         subagentTracker.cleanupStaleEntries();
         fallbackHandler.cleanupStaleEntries();
+        if (healthTracker) {
+            healthTracker.cleanupOldEntries();
+        }
     }, CLEANUP_INTERVAL_MS);
     return {
         event: async ({ event }) => {
             // Handle session.error events
             if (isSessionErrorEvent(event)) {
                 const { sessionID, error } = event.properties;
-                if (sessionID && error && isRateLimitError(error)) {
+                if (sessionID && error && errorPatternRegistry.isRateLimitError(error)) {
                     await fallbackHandler.handleRateLimitFallback(sessionID, "", "");
                 }
             }
             // Handle message.updated events
             if (isMessageUpdatedEvent(event)) {
                 const info = event.properties.info;
-                if (info?.error && isRateLimitError(info.error)) {
+                if (info?.error && errorPatternRegistry.isRateLimitError(info.error)) {
                     await fallbackHandler.handleRateLimitFallback(info.sessionID, info.providerID || "", info.modelID || "");
                 }
                 else if (info?.status === "completed" && !info?.error && info?.id) {
                     // Record fallback success
                     fallbackHandler.handleMessageUpdated(info.sessionID, info.id, false, false);
                 }
-                else if (info?.error && !isRateLimitError(info.error) && info?.id) {
+                else if (info?.error && !errorPatternRegistry.isRateLimitError(info.error) && info?.id) {
                     // Record non-rate-limit error
                     fallbackHandler.handleMessageUpdated(info.sessionID, info.id, true, false);
                 }
@@ -137,7 +178,11 @@ export const RateLimitFallback = async ({ client, directory, worktree }) => {
             subagentTracker.clearAll();
             metricsManager.destroy();
             fallbackHandler.destroy();
+            if (healthTracker) {
+                healthTracker.destroy();
+            }
         },
     };
 };
 export default RateLimitFallback;
+export { Logger as LoggerClass } from "./logger.js";

package/dist/src/circuitbreaker/CircuitBreaker.d.ts

@@ -47,7 +47,14 @@ export declare class CircuitBreaker {
      */
     private getOrCreateCircuit;
     /**
-     * Destroy the circuit breaker and clean up resources
+     * Get all circuit states
+     */
+    getAllStates(): {
+        modelKey: string;
+        state: CircuitBreakerState;
+    }[];
+    /**
+     * Destroy circuit breaker and clean up resources
      */
     destroy(): void;
 }

package/dist/src/circuitbreaker/CircuitBreaker.js

@@ -199,7 +199,17 @@ export class CircuitBreaker {
         return circuit;
     }
     /**
-     * Destroy the circuit breaker and clean up resources
+     * Get all circuit states
+     */
+    getAllStates() {
+        const result = [];
+        for (const [modelKey, circuit] of this.circuits.entries()) {
+            result.push({ modelKey, state: circuit.getState() });
+        }
+        return result;
+    }
+    /**
+     * Destroy circuit breaker and clean up resources
      */
     destroy() {
         this.circuits.clear();

package/dist/src/config/Validator.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Configuration validation and diagnostics
+ */
+import type { PluginConfig } from '../types/index.js';
+/**
+ * Validation error details
+ */
+export interface ValidationError {
+    path: string;
+    message: string;
+    severity: 'error' | 'warning';
+    value?: unknown;
+}
+/**
+ * Validation result
+ */
+export interface ValidationResult {
+    isValid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationError[];
+    config: PluginConfig;
+}
+/**
+ * Validation configuration
+ */
+export interface ConfigValidationOptions {
+    strict?: boolean;
+    logWarnings?: boolean;
+}
+/**
+ * Diagnostics configuration
+ */
+export interface DiagnosticsInfo {
+    configSource: string;
+    config: PluginConfig;
+    validation: ValidationResult;
+    defaultsApplied: string[];
+}
+/**
+ * Configuration Validator class
+ */
+export declare class ConfigValidator {
+    private logger?;
+    constructor(logger?: {
+        warn: (msg: string) => void;
+        error: (msg: string) => void;
+    });
+    /**
+     * Validate a configuration object
+     */
+    validate(config: Partial<PluginConfig>, options?: ConfigValidationOptions): ValidationResult;
+    /**
+     * Validate a configuration file
+     */
+    validateFile(filePath: string, options?: ConfigValidationOptions): ValidationResult;
+    /**
+     * Get diagnostics information for the current configuration
+     */
+    getDiagnostics(config: PluginConfig, configSource: string, defaultsApplied?: string[]): DiagnosticsInfo;
+    /**
+     * Format diagnostics as human-readable text
+     */
+    formatDiagnostics(diagnostics: DiagnosticsInfo): string;
+}