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

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

@@ -0,0 +1,44 @@
+/**
+ * Circuit State - State machine for individual circuit breaker state
+ */
+import type { CircuitBreakerConfig, CircuitBreakerState, CircuitBreakerStateType } from '../types/index.js';
+/**
+ * Return type for canExecute method
+ */
+export interface CanExecuteResult {
+    allowed: boolean;
+    transition?: {
+        from: CircuitBreakerStateType;
+        to: CircuitBreakerStateType;
+    };
+}
+/**
+ * CircuitState class - Manages state transitions for a single circuit
+ */
+export declare class CircuitState {
+    state: CircuitBreakerState;
+    private halfOpenCalls;
+    private config;
+    constructor(config: CircuitBreakerConfig);
+    /**
+     * Handle a successful request
+     */
+    onSuccess(): void;
+    /**
+     * Handle a failed request
+     */
+    onFailure(): void;
+    /**
+     * Check if a request can be executed through this circuit
+     * @returns Object with allowed flag and optional transition info
+     */
+    canExecute(): CanExecuteResult;
+    /**
+     * Get the current state
+     */
+    getState(): CircuitBreakerState;
+    /**
+     * Reset the circuit to CLOSED state
+     */
+    reset(): void;
+}

package/dist/src/circuitbreaker/CircuitState.js

@@ -0,0 +1,128 @@
+/**
+ * Circuit State - State machine for individual circuit breaker state
+ */
+/**
+ * CircuitState class - Manages state transitions for a single circuit
+ */
+export class CircuitState {
+    state;
+    halfOpenCalls = 0;
+    config;
+    constructor(config) {
+        this.config = config;
+        this.state = {
+            state: 'CLOSED',
+            failureCount: 0,
+            successCount: 0,
+            lastFailureTime: 0,
+            lastSuccessTime: 0,
+            nextAttemptTime: 0,
+        };
+    }
+    /**
+     * Handle a successful request
+     */
+    onSuccess() {
+        const now = Date.now();
+        this.state.lastSuccessTime = now;
+        switch (this.state.state) {
+            case 'CLOSED':
+                // Reset failure count on success
+                this.state.failureCount = 0;
+                break;
+            case 'HALF_OPEN':
+                this.state.successCount++;
+                this.state.failureCount = 0;
+                // Close circuit if success threshold reached
+                if (this.state.successCount >= this.config.successThreshold) {
+                    this.state.state = 'CLOSED';
+                    this.state.successCount = 0;
+                    this.halfOpenCalls = 0;
+                }
+                break;
+            case 'OPEN':
+                // Should not receive success in OPEN state
+                break;
+        }
+    }
+    /**
+     * Handle a failed request
+     */
+    onFailure() {
+        const now = Date.now();
+        this.state.lastFailureTime = now;
+        switch (this.state.state) {
+            case 'CLOSED':
+                this.state.failureCount++;
+                // Open circuit if failure threshold reached
+                if (this.state.failureCount >= this.config.failureThreshold) {
+                    this.state.state = 'OPEN';
+                    this.state.nextAttemptTime = now + this.config.recoveryTimeoutMs;
+                    this.state.successCount = 0;
+                }
+                break;
+            case 'HALF_OPEN':
+                // Re-open circuit on failure
+                this.state.state = 'OPEN';
+                this.state.nextAttemptTime = now + this.config.recoveryTimeoutMs;
+                this.state.failureCount++;
+                this.state.successCount = 0;
+                this.halfOpenCalls = 0;
+                break;
+            case 'OPEN':
+                // Already open, just update count
+                this.state.failureCount++;
+                break;
+        }
+    }
+    /**
+     * Check if a request can be executed through this circuit
+     * @returns Object with allowed flag and optional transition info
+     */
+    canExecute() {
+        const now = Date.now();
+        switch (this.state.state) {
+            case 'CLOSED':
+                return { allowed: true };
+            case 'OPEN':
+                // Check if recovery timeout has elapsed
+                if (now >= this.state.nextAttemptTime) {
+                    // Transition to HALF_OPEN for test request
+                    const transition = { from: 'OPEN', to: 'HALF_OPEN' };
+                    this.state.state = 'HALF_OPEN';
+                    this.halfOpenCalls = 0;
+                    return { allowed: true, transition };
+                }
+                return { allowed: false };
+            case 'HALF_OPEN':
+                // Limit calls in HALF_OPEN state
+                if (this.halfOpenCalls < this.config.halfOpenMaxCalls) {
+                    this.halfOpenCalls++;
+                    return { allowed: true };
+                }
+                return { allowed: false };
+            default:
+                return { allowed: false };
+        }
+    }
+    /**
+     * Get the current state
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Reset the circuit to CLOSED state
+     */
+    reset() {
+        this.state = {
+            state: 'CLOSED',
+            failureCount: 0,
+            successCount: 0,
+            lastFailureTime: 0,
+            lastSuccessTime: 0,
+            nextAttemptTime: 0,
+        };
+        this.halfOpenCalls = 0;
+    }
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Circuit Breaker Module
+ *
+ * Provides circuit breaker pattern implementation to prevent cascading failures
+ * by automatically disabling models that are consistently failing.
+ */
+export { CircuitBreaker } from './CircuitBreaker.js';
+export { CircuitState, type CanExecuteResult } from './CircuitState.js';

package/dist/src/circuitbreaker/index.js

@@ -0,0 +1,8 @@
+/**
+ * Circuit Breaker Module
+ *
+ * Provides circuit breaker pattern implementation to prevent cascading failures
+ * by automatically disabling models that are consistently failing.
+ */
+export { CircuitBreaker } from './CircuitBreaker.js';
+export { CircuitState } from './CircuitState.js';

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;
+}