@revenium/anthropic 1.0.0

package/dist/esm/utils/circuit-breaker.js

@@ -0,0 +1,223 @@
+/**
+ * Circuit breaker pattern implementation for handling repeated failures
+ */
+import { CIRCUIT_BREAKER_CONFIG } from '../constants.js';
+/**
+ * Circuit breaker states
+ */
+export var CircuitState;
+(function (CircuitState) {
+    CircuitState["CLOSED"] = "CLOSED";
+    CircuitState["OPEN"] = "OPEN";
+    CircuitState["HALF_OPEN"] = "HALF_OPEN"; // Testing if service recovered
+})(CircuitState || (CircuitState = {}));
+/**
+ * Default circuit breaker configuration
+ */
+export const DEFAULT_CIRCUIT_CONFIG = {
+    failureThreshold: CIRCUIT_BREAKER_CONFIG.FAILURE_THRESHOLD,
+    recoveryTimeout: CIRCUIT_BREAKER_CONFIG.RECOVERY_TIMEOUT,
+    successThreshold: CIRCUIT_BREAKER_CONFIG.SUCCESS_THRESHOLD,
+    timeWindow: CIRCUIT_BREAKER_CONFIG.TIME_WINDOW
+};
+/**
+ * Circuit breaker implementation
+ */
+export class CircuitBreaker {
+    constructor(config = DEFAULT_CIRCUIT_CONFIG) {
+        this.config = config;
+        this.state = CircuitState.CLOSED;
+        this.failureCount = 0;
+        this.successCount = 0;
+        this.lastFailureTime = 0;
+        this.failures = []; // Timestamps of failures
+        this.lastCleanupTime = 0;
+        this.maxFailureHistorySize = CIRCUIT_BREAKER_CONFIG.MAX_FAILURE_HISTORY_SIZE;
+        this.lastCleanupTime = Date.now();
+    }
+    /**
+     * Execute a function with circuit breaker protection
+     */
+    async execute(fn) {
+        if (this.state === CircuitState.OPEN) {
+            if (this.shouldAttemptRecovery()) {
+                this.state = CircuitState.HALF_OPEN;
+                this.successCount = 0;
+            }
+            else {
+                throw new Error('Circuit breaker is OPEN - failing fast');
+            }
+        }
+        try {
+            const result = await fn();
+            this.onSuccess();
+            return result;
+        }
+        catch (error) {
+            this.onFailure();
+            throw error;
+        }
+    }
+    /**
+     * Check if circuit breaker allows execution
+     */
+    canExecute() {
+        if (this.state === CircuitState.CLOSED || this.state === CircuitState.HALF_OPEN)
+            return true;
+        if (this.state === CircuitState.OPEN && this.shouldAttemptRecovery())
+            return true;
+        return false;
+    }
+    /**
+     * Get current circuit breaker state
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Get circuit breaker statistics
+     */
+    getStats() {
+        const now = Date.now();
+        const recentFailures = this.failures.filter(timestamp => now - timestamp < this.config.timeWindow).length;
+        let timeUntilRecovery;
+        if (this.state === CircuitState.OPEN) {
+            const timeSinceLastFailure = now - this.lastFailureTime;
+            timeUntilRecovery = Math.max(0, this.config.recoveryTimeout - timeSinceLastFailure);
+        }
+        return {
+            state: this.state,
+            failureCount: this.failureCount,
+            successCount: this.successCount,
+            recentFailures,
+            timeUntilRecovery
+        };
+    }
+    /**
+     * Reset circuit breaker to closed state
+     */
+    reset() {
+        this.state = CircuitState.CLOSED;
+        this.failureCount = 0;
+        this.successCount = 0;
+        this.lastFailureTime = 0;
+        this.lastCleanupTime = Date.now();
+        this.failures = [];
+    }
+    /**
+     * Handle successful execution
+     */
+    onSuccess() {
+        if (this.state === CircuitState.HALF_OPEN) {
+            this.successCount++;
+            if (this.successCount >= this.config.successThreshold) {
+                this.state = CircuitState.CLOSED;
+                this.failureCount = 0;
+                this.failures = [];
+            }
+        }
+        else if (this.state === CircuitState.CLOSED) {
+            // Reset failure count on success in closed state
+            this.failureCount = 0;
+            this.performPeriodicCleanup();
+        }
+    }
+    /**
+     * Handle failed execution
+     */
+    onFailure() {
+        const now = Date.now();
+        this.failureCount++;
+        this.lastFailureTime = now;
+        // Prevent unbounded growth of failures array
+        if (this.failures.length >= this.maxFailureHistorySize) {
+            this.failures = this.failures.slice(-Math.floor(this.maxFailureHistorySize / 2));
+        }
+        this.failures.push(now);
+        this.cleanupOldFailures();
+        if (this.state === CircuitState.HALF_OPEN) {
+            // Go back to open state on any failure in half-open
+            this.state = CircuitState.OPEN;
+            this.successCount = 0;
+        }
+        else if (this.state === CircuitState.CLOSED) {
+            // Check if we should open the circuit
+            const recentFailures = this.failures.filter(timestamp => now - timestamp < this.config.timeWindow).length;
+            if (recentFailures >= this.config.failureThreshold) {
+                this.state = CircuitState.OPEN;
+            }
+        }
+    }
+    /**
+     * Check if we should attempt recovery from open state
+     */
+    shouldAttemptRecovery() {
+        const now = Date.now();
+        return now - this.lastFailureTime >= this.config.recoveryTimeout;
+    }
+    /**
+     * Remove old failure timestamps outside the time window
+     */
+    cleanupOldFailures() {
+        const now = Date.now();
+        this.failures = this.failures.filter(timestamp => now - timestamp < this.config.timeWindow);
+    }
+    /**
+     * Perform periodic cleanup to prevent memory leaks
+     * Only runs cleanup if enough time has passed since last cleanup
+     */
+    performPeriodicCleanup() {
+        const now = Date.now();
+        const timeSinceLastCleanup = now - this.lastCleanupTime;
+        // Use constants for cleanup thresholds
+        if (timeSinceLastCleanup > CIRCUIT_BREAKER_CONFIG.CLEANUP_INTERVAL ||
+            this.failures.length > CIRCUIT_BREAKER_CONFIG.CLEANUP_SIZE_THRESHOLD) {
+            this.cleanupOldFailures();
+            this.lastCleanupTime = now;
+        }
+    }
+}
+/**
+ * Global circuit breaker instance for Revenium API calls
+ */
+let globalCircuitBreaker = null;
+/**
+ * Get or create the global circuit breaker instance
+ */
+export function getCircuitBreaker(config) {
+    if (!globalCircuitBreaker) {
+        const finalConfig = config ? { ...DEFAULT_CIRCUIT_CONFIG, ...config } : DEFAULT_CIRCUIT_CONFIG;
+        globalCircuitBreaker = new CircuitBreaker(finalConfig);
+    }
+    return globalCircuitBreaker;
+}
+/**
+ * Reset the global circuit breaker
+ */
+export function resetCircuitBreaker() {
+    if (globalCircuitBreaker) {
+        globalCircuitBreaker.reset();
+    }
+}
+/**
+ * Check if the global circuit breaker allows execution
+ */
+export function canExecuteRequest() {
+    const circuitBreaker = getCircuitBreaker();
+    return circuitBreaker.canExecute();
+}
+/**
+ * Execute a function with global circuit breaker protection
+ */
+export async function executeWithCircuitBreaker(fn) {
+    const circuitBreaker = getCircuitBreaker();
+    return circuitBreaker.execute(fn);
+}
+/**
+ * Get global circuit breaker statistics
+ */
+export function getCircuitBreakerStats() {
+    const circuitBreaker = getCircuitBreaker();
+    return circuitBreaker.getStats();
+}
+//# sourceMappingURL=circuit-breaker.js.map

package/dist/esm/utils/error-handling.js

@@ -0,0 +1,216 @@
+/**
+ * Error handling utilities for Anthropic middleware with structured errors and context building
+ */
+import { RETRY_CONFIG } from '../constants.js';
+/**
+ * Base error class for Revenium middleware errors
+ */
+export class ReveniumError extends Error {
+    constructor(message, code, context) {
+        super(message);
+        this.name = 'ReveniumError';
+        this.code = code;
+        this.context = context;
+        // Maintain proper stack trace for where our error was thrown
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ReveniumError);
+        }
+    }
+}
+/**
+ * Configuration-related errors
+ */
+export class ConfigurationError extends ReveniumError {
+    constructor(message, context) {
+        super(message, 'CONFIGURATION_ERROR', context);
+        this.name = 'ConfigurationError';
+    }
+}
+/**
+ * Anthropic SDK patching errors
+ */
+export class AnthropicPatchingError extends ReveniumError {
+    constructor(message, context) {
+        super(message, 'ANTHROPIC_PATCHING_ERROR', context);
+        this.name = 'AnthropicPatchingError';
+    }
+}
+/**
+ * Request processing errors
+ */
+export class RequestProcessingError extends ReveniumError {
+    constructor(message, context) {
+        super(message, 'REQUEST_PROCESSING_ERROR', context);
+        this.name = 'RequestProcessingError';
+    }
+}
+/**
+ * Revenium API communication errors
+ */
+export class ReveniumApiError extends ReveniumError {
+    constructor(message, statusCode, responseBody, context) {
+        super(message, 'REVENIUM_API_ERROR', context);
+        this.name = 'ReveniumApiError';
+        this.statusCode = statusCode;
+        this.responseBody = responseBody;
+    }
+}
+/**
+ * Validation errors
+ */
+export class ValidationError extends ReveniumError {
+    constructor(message, validationErrors, context) {
+        super(message, 'VALIDATION_ERROR', context);
+        this.name = 'ValidationError';
+        this.validationErrors = validationErrors;
+    }
+}
+/**
+ * Stream processing errors
+ */
+export class StreamProcessingError extends ReveniumError {
+    constructor(message, context) {
+        super(message, 'STREAM_PROCESSING_ERROR', context);
+        this.name = 'StreamProcessingError';
+    }
+}
+/**
+ * Error context builder for consistent error reporting
+ */
+export class ErrorContext {
+    constructor() {
+        this.context = {};
+    }
+    /**
+     * Add request ID to error context
+     */
+    withRequestId(requestId) {
+        this.context.requestId = requestId;
+        return this;
+    }
+    /**
+     * Add model information to error context
+     */
+    withModel(model) {
+        this.context.model = model;
+        return this;
+    }
+    /**
+     * Add duration to error context
+     */
+    withDuration(duration) {
+        this.context.duration = duration;
+        return this;
+    }
+    /**
+     * Add HTTP status to error context
+     */
+    withStatus(status) {
+        this.context.status = status;
+        return this;
+    }
+    /**
+     * Add custom field to error context
+     */
+    with(key, value) {
+        this.context[key] = value;
+        return this;
+    }
+    /**
+     * Build the context object
+     */
+    build() {
+        return { ...this.context };
+    }
+}
+/**
+ * Safe error message extraction
+ */
+export function getErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    if (error && typeof error === 'object' && 'message' in error) {
+        const message = error.message;
+        if (typeof message === 'string')
+            return message;
+    }
+    return 'Unknown error occurred';
+}
+/**
+ * Safe error stack extraction
+ */
+export function getErrorStack(error) {
+    if (error instanceof Error && error.stack)
+        return error.stack;
+    return;
+}
+/**
+ * Create error context builder
+ */
+export function createErrorContext() {
+    return new ErrorContext();
+}
+/**
+ * Handle and log errors consistently
+ */
+export function handleError(error, logger, context) {
+    const message = getErrorMessage(error);
+    const stack = getErrorStack(error);
+    const logContext = {
+        ...context,
+        error: message,
+        stack: stack
+    };
+    if (error instanceof ReveniumError) {
+        logContext.errorCode = error.code;
+        logContext.errorContext = error.context;
+        if (error instanceof ReveniumApiError) {
+            logContext.statusCode = error.statusCode;
+            logContext.responseBody = error.responseBody;
+        }
+        if (error instanceof ValidationError) {
+            logContext.validationErrors = error.validationErrors;
+        }
+    }
+    logger.error('Error occurred', logContext);
+}
+/**
+ * Wrap async function with error handling
+ */
+export function withErrorHandling(fn, errorHandler) {
+    return async (...args) => {
+        try {
+            return await fn(...args);
+        }
+        catch (error) {
+            errorHandler(error, ...args);
+            return undefined;
+        }
+    };
+}
+/**
+ * Retry function with exponential backoff
+ */
+export async function withRetry(fn, maxRetries = RETRY_CONFIG.BASE_DELAY / 1000, // Convert to attempts for backward compatibility
+baseDelay = RETRY_CONFIG.BASE_DELAY) {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === maxRetries) {
+                break;
+            }
+            // Exponential backoff with jitter using constants
+            const delay = Math.min(baseDelay * Math.pow(2, attempt), RETRY_CONFIG.MAX_DELAY);
+            const jitter = Math.random() * RETRY_CONFIG.JITTER_FACTOR * delay;
+            await new Promise(resolve => setTimeout(resolve, delay + jitter));
+        }
+    }
+    throw lastError;
+}
+//# sourceMappingURL=error-handling.js.map