@vacbo/opencode-anthropic-fix 0.1.7 → 0.1.9

package/src/circuit-breaker.ts

@@ -1,31 +1,31 @@
 export enum CircuitState {
-  CLOSED = "CLOSED",
-  OPEN = "OPEN",
-  HALF_OPEN = "HALF_OPEN",
+    CLOSED = "CLOSED",
+    OPEN = "OPEN",
+    HALF_OPEN = "HALF_OPEN",
 }
 
 export const BreakerState = CircuitState;
 
 export interface CircuitBreakerOptions {
-  clientId?: string;
-  failureThreshold?: number;
-  resetTimeoutMs?: number;
+    clientId?: string;
+    failureThreshold?: number;
+    resetTimeoutMs?: number;
 }
 
 export interface CircuitBreakerConfig {
-  clientId?: string;
-  failureThreshold: number;
-  resetTimeoutMs: number;
+    clientId?: string;
+    failureThreshold: number;
+    resetTimeoutMs: number;
 }
 
 export interface CircuitBreakerSuccess<T> {
-  success: true;
-  data: T;
+    success: true;
+    data: T;
 }
 
 export interface CircuitBreakerFailure {
-  success: false;
-  error: string;
+    success: false;
+    error: string;
 }
 
 export type CircuitBreakerResult<T> = CircuitBreakerSuccess<T> | CircuitBreakerFailure;
@@ -36,200 +36,200 @@ const DEFAULT_RESET_TIMEOUT_MS = 30_000;
 const pendingClientBreakers = new Map<string, CircuitBreaker>();
 
 function normalizeConfig(options: CircuitBreakerOptions = {}): CircuitBreakerConfig {
-  return {
-    clientId: options.clientId,
-    failureThreshold: Math.max(1, Math.trunc(options.failureThreshold ?? DEFAULT_FAILURE_THRESHOLD)),
-    resetTimeoutMs: Math.max(0, Math.trunc(options.resetTimeoutMs ?? DEFAULT_RESET_TIMEOUT_MS)),
-  };
+    return {
+        clientId: options.clientId,
+        failureThreshold: Math.max(1, Math.trunc(options.failureThreshold ?? DEFAULT_FAILURE_THRESHOLD)),
+        resetTimeoutMs: Math.max(0, Math.trunc(options.resetTimeoutMs ?? DEFAULT_RESET_TIMEOUT_MS)),
+    };
 }
 
 function getErrorMessage(error: unknown): string {
-  if (error instanceof Error && error.message) {
-    return error.message;
-  }
+    if (error instanceof Error && error.message) {
+        return error.message;
+    }
 
-  if (typeof error === "string" && error) {
-    return error;
-  }
+    if (typeof error === "string" && error) {
+        return error;
+    }
 
-  return "Unknown error";
+    return "Unknown error";
 }
 
 function isPromiseLike<T>(value: T | Promise<T>): value is Promise<T> {
-  return typeof value === "object" && value !== null && "then" in value;
+    return typeof value === "object" && value !== null && "then" in value;
 }
 
 function releasePendingClientBreaker(clientId: string, breaker: CircuitBreaker): void {
-  queueMicrotask(() => {
-    if (pendingClientBreakers.get(clientId) === breaker) {
-      pendingClientBreakers.delete(clientId);
-    }
-  });
+    queueMicrotask(() => {
+        if (pendingClientBreakers.get(clientId) === breaker) {
+            pendingClientBreakers.delete(clientId);
+        }
+    });
 }
 
 export class CircuitBreaker {
-  private readonly config: CircuitBreakerConfig;
-
-  private state = CircuitState.CLOSED;
-  private failureCount = 0;
-  private openedAt: number | null = null;
-  private resetTimer: ReturnType<typeof setTimeout> | null = null;
+    private readonly config: CircuitBreakerConfig;
 
-  constructor(options: CircuitBreakerOptions = {}) {
-    this.config = normalizeConfig(options);
-  }
+    private state = CircuitState.CLOSED;
+    private failureCount = 0;
+    private openedAt: number | null = null;
+    private resetTimer: ReturnType<typeof setTimeout> | null = null;
 
-  getState(): CircuitState {
-    return this.state;
-  }
-
-  getFailureCount(): number {
-    return this.failureCount;
-  }
-
-  getOpenedAt(): number | null {
-    return this.openedAt;
-  }
-
-  getConfig(): CircuitBreakerConfig {
-    return { ...this.config };
-  }
+    constructor(options: CircuitBreakerOptions = {}) {
+        this.config = normalizeConfig(options);
+    }
 
-  canExecute(): boolean {
-    return this.state !== CircuitState.OPEN;
-  }
+    getState(): CircuitState {
+        return this.state;
+    }
 
-  recordSuccess(): void {
-    if (this.state === CircuitState.HALF_OPEN) {
-      this.transitionToClosed();
-      return;
+    getFailureCount(): number {
+        return this.failureCount;
     }
 
-    if (this.state === CircuitState.CLOSED) {
-      this.failureCount = 0;
+    getOpenedAt(): number | null {
+        return this.openedAt;
     }
-  }
 
-  recordFailure(): void {
-    if (this.state === CircuitState.HALF_OPEN) {
-      this.transitionToOpen();
-      return;
+    getConfig(): CircuitBreakerConfig {
+        return { ...this.config };
     }
 
-    if (this.state === CircuitState.OPEN) {
-      return;
+    canExecute(): boolean {
+        return this.state !== CircuitState.OPEN;
     }
 
-    this.failureCount += 1;
+    recordSuccess(): void {
+        if (this.state === CircuitState.HALF_OPEN) {
+            this.transitionToClosed();
+            return;
+        }
 
-    if (this.failureCount >= this.config.failureThreshold) {
-      this.transitionToOpen();
+        if (this.state === CircuitState.CLOSED) {
+            this.failureCount = 0;
+        }
     }
-  }
 
-  transitionToHalfOpen(): void {
-    this.clearResetTimer();
-    this.state = CircuitState.HALF_OPEN;
-    this.openedAt = null;
-    this.failureCount = 0;
-  }
+    recordFailure(): void {
+        if (this.state === CircuitState.HALF_OPEN) {
+            this.transitionToOpen();
+            return;
+        }
+
+        if (this.state === CircuitState.OPEN) {
+            return;
+        }
+
+        this.failureCount += 1;
+
+        if (this.failureCount >= this.config.failureThreshold) {
+            this.transitionToOpen();
+        }
+    }
 
-  execute<T>(
-    operation: () => T | Promise<T>,
-  ): CircuitBreakerResult<Awaited<T>> | Promise<CircuitBreakerResult<Awaited<T>>> {
-    if (!this.canExecute()) {
-      return {
-        success: false,
-        error: "Circuit breaker is OPEN",
-      };
+    transitionToHalfOpen(): void {
+        this.clearResetTimer();
+        this.state = CircuitState.HALF_OPEN;
+        this.openedAt = null;
+        this.failureCount = 0;
     }
 
-    try {
-      const result = operation();
+    execute<T>(
+        operation: () => T | Promise<T>,
+    ): CircuitBreakerResult<Awaited<T>> | Promise<CircuitBreakerResult<Awaited<T>>> {
+        if (!this.canExecute()) {
+            return {
+                success: false,
+                error: "Circuit breaker is OPEN",
+            };
+        }
+
+        try {
+            const result = operation();
+
+            if (isPromiseLike(result)) {
+                return result
+                    .then((data) => {
+                        this.recordSuccess();
+                        return {
+                            success: true,
+                            data: data as Awaited<T>,
+                        } satisfies CircuitBreakerSuccess<Awaited<T>>;
+                    })
+                    .catch((error: unknown) => {
+                        this.recordFailure();
+                        return {
+                            success: false,
+                            error: getErrorMessage(error),
+                        } satisfies CircuitBreakerFailure;
+                    });
+            }
 
-      if (isPromiseLike(result)) {
-        return result
-          .then((data) => {
             this.recordSuccess();
             return {
-              success: true,
-              data: data as Awaited<T>,
-            } satisfies CircuitBreakerSuccess<Awaited<T>>;
-          })
-          .catch((error: unknown) => {
+                success: true,
+                data: result as Awaited<T>,
+            };
+        } catch (error) {
             this.recordFailure();
             return {
-              success: false,
-              error: getErrorMessage(error),
-            } satisfies CircuitBreakerFailure;
-          });
-      }
-
-      this.recordSuccess();
-      return {
-        success: true,
-        data: result as Awaited<T>,
-      };
-    } catch (error) {
-      this.recordFailure();
-      return {
-        success: false,
-        error: getErrorMessage(error),
-      };
-    }
-  }
-
-  dispose(): void {
-    this.clearResetTimer();
-  }
-
-  private transitionToClosed(): void {
-    this.clearResetTimer();
-    this.state = CircuitState.CLOSED;
-    this.failureCount = 0;
-    this.openedAt = null;
-  }
-
-  private transitionToOpen(): void {
-    this.clearResetTimer();
-    this.state = CircuitState.OPEN;
-    this.openedAt = Date.now();
-    this.scheduleHalfOpenTransition();
-  }
-
-  private scheduleHalfOpenTransition(): void {
-    this.resetTimer = setTimeout(() => {
-      this.resetTimer = null;
-      if (this.state === CircuitState.OPEN) {
-        this.transitionToHalfOpen();
-      }
-    }, this.config.resetTimeoutMs);
-
-    this.resetTimer.unref?.();
-  }
-
-  private clearResetTimer(): void {
-    if (!this.resetTimer) {
-      return;
-    }
-
-    clearTimeout(this.resetTimer);
-    this.resetTimer = null;
-  }
+                success: false,
+                error: getErrorMessage(error),
+            };
+        }
+    }
+
+    dispose(): void {
+        this.clearResetTimer();
+    }
+
+    private transitionToClosed(): void {
+        this.clearResetTimer();
+        this.state = CircuitState.CLOSED;
+        this.failureCount = 0;
+        this.openedAt = null;
+    }
+
+    private transitionToOpen(): void {
+        this.clearResetTimer();
+        this.state = CircuitState.OPEN;
+        this.openedAt = Date.now();
+        this.scheduleHalfOpenTransition();
+    }
+
+    private scheduleHalfOpenTransition(): void {
+        this.resetTimer = setTimeout(() => {
+            this.resetTimer = null;
+            if (this.state === CircuitState.OPEN) {
+                this.transitionToHalfOpen();
+            }
+        }, this.config.resetTimeoutMs);
+
+        this.resetTimer.unref?.();
+    }
+
+    private clearResetTimer(): void {
+        if (!this.resetTimer) {
+            return;
+        }
+
+        clearTimeout(this.resetTimer);
+        this.resetTimer = null;
+    }
 }
 
 export function createCircuitBreaker(options: CircuitBreakerOptions = {}): CircuitBreaker {
-  if (!options.clientId) {
-    return new CircuitBreaker(options);
-  }
-
-  const existingBreaker = pendingClientBreakers.get(options.clientId);
-  if (existingBreaker) {
-    return existingBreaker;
-  }
-
-  const breaker = new CircuitBreaker(options);
-  pendingClientBreakers.set(options.clientId, breaker);
-  releasePendingClientBreaker(options.clientId, breaker);
-  return breaker;
+    if (!options.clientId) {
+        return new CircuitBreaker(options);
+    }
+
+    const existingBreaker = pendingClientBreakers.get(options.clientId);
+    if (existingBreaker) {
+        return existingBreaker;
+    }
+
+    const breaker = new CircuitBreaker(options);
+    pendingClientBreakers.set(options.clientId, breaker);
+    releasePendingClientBreaker(options.clientId, breaker);
+    return breaker;
 }