supaclaw 1.0.0

package/dist/error-handling.js

@@ -0,0 +1,301 @@
+"use strict";
+/**
+ * Error handling and retry logic for OpenClaw Memory
+ *
+ * Provides:
+ * - Custom error types
+ * - Retry logic with exponential backoff
+ * - Circuit breaker pattern
+ * - Error recovery strategies
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreaker = exports.RateLimitError = exports.ValidationError = exports.EmbeddingError = exports.DatabaseError = exports.OpenClawError = void 0;
+exports.retry = retry;
+exports.wrapDatabaseOperation = wrapDatabaseOperation;
+exports.wrapEmbeddingOperation = wrapEmbeddingOperation;
+exports.validateInput = validateInput;
+exports.safeJsonParse = safeJsonParse;
+exports.withTimeout = withTimeout;
+exports.gracefulFallback = gracefulFallback;
+exports.batchWithErrorHandling = batchWithErrorHandling;
+// Custom error types
+class OpenClawError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'OpenClawError';
+    }
+}
+exports.OpenClawError = OpenClawError;
+class DatabaseError extends OpenClawError {
+    constructor(message, details) {
+        super(message, 'DATABASE_ERROR', details);
+        this.name = 'DatabaseError';
+    }
+}
+exports.DatabaseError = DatabaseError;
+class EmbeddingError extends OpenClawError {
+    constructor(message, details) {
+        super(message, 'EMBEDDING_ERROR', details);
+        this.name = 'EmbeddingError';
+    }
+}
+exports.EmbeddingError = EmbeddingError;
+class ValidationError extends OpenClawError {
+    constructor(message, details) {
+        super(message, 'VALIDATION_ERROR', details);
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+class RateLimitError extends OpenClawError {
+    constructor(message, details) {
+        super(message, 'RATE_LIMIT_ERROR', details);
+        this.name = 'RateLimitError';
+    }
+}
+exports.RateLimitError = RateLimitError;
+const DEFAULT_RETRY_OPTIONS = {
+    maxAttempts: 3,
+    initialDelayMs: 1000,
+    maxDelayMs: 10000,
+    backoffMultiplier: 2,
+    shouldRetry: (error) => {
+        // Retry on network errors, rate limits, and transient database errors
+        if (error instanceof RateLimitError)
+            return true;
+        if (error instanceof DatabaseError) {
+            // Don't retry validation/constraint errors
+            const msg = error.message.toLowerCase();
+            return !msg.includes('constraint') && !msg.includes('invalid');
+        }
+        // Retry on network errors
+        if (error.message.includes('ECONNREFUSED'))
+            return true;
+        if (error.message.includes('ETIMEDOUT'))
+            return true;
+        if (error.message.includes('ENOTFOUND'))
+            return true;
+        return false;
+    },
+    onRetry: () => { }, // No-op by default
+};
+/**
+ * Retry a function with exponential backoff
+ */
+async function retry(fn, options) {
+    const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };
+    let lastError;
+    for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            // Don't retry if we've exhausted attempts or error is non-retryable
+            if (attempt >= opts.maxAttempts || !opts.shouldRetry(lastError)) {
+                throw lastError;
+            }
+            // Calculate delay with exponential backoff
+            const delay = Math.min(opts.initialDelayMs * Math.pow(opts.backoffMultiplier, attempt - 1), opts.maxDelayMs);
+            opts.onRetry(attempt, lastError);
+            // Wait before retrying
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+    }
+    throw lastError;
+}
+/**
+ * Circuit breaker pattern
+ * Prevents cascading failures by failing fast when error rate is high
+ */
+class CircuitBreaker {
+    failureThreshold;
+    recoveryTimeMs;
+    successThreshold;
+    failures = 0;
+    successes = 0;
+    lastFailureTime = 0;
+    state = 'closed';
+    constructor(failureThreshold = 5, recoveryTimeMs = 60000, // 1 minute
+    successThreshold = 2) {
+        this.failureThreshold = failureThreshold;
+        this.recoveryTimeMs = recoveryTimeMs;
+        this.successThreshold = successThreshold;
+    }
+    async execute(fn) {
+        // If circuit is open, check if recovery time has passed
+        if (this.state === 'open') {
+            const now = Date.now();
+            if (now - this.lastFailureTime > this.recoveryTimeMs) {
+                this.state = 'half-open';
+                this.successes = 0;
+            }
+            else {
+                throw new OpenClawError('Circuit breaker is open', 'CIRCUIT_BREAKER_OPEN', { failures: this.failures, lastFailureTime: this.lastFailureTime });
+            }
+        }
+        try {
+            const result = await fn();
+            this.onSuccess();
+            return result;
+        }
+        catch (error) {
+            this.onFailure();
+            throw error;
+        }
+    }
+    onSuccess() {
+        this.failures = 0;
+        if (this.state === 'half-open') {
+            this.successes++;
+            if (this.successes >= this.successThreshold) {
+                this.state = 'closed';
+                this.successes = 0;
+            }
+        }
+    }
+    onFailure() {
+        this.failures++;
+        this.lastFailureTime = Date.now();
+        if (this.failures >= this.failureThreshold) {
+            this.state = 'open';
+        }
+    }
+    reset() {
+        this.failures = 0;
+        this.successes = 0;
+        this.lastFailureTime = 0;
+        this.state = 'closed';
+    }
+    getState() {
+        return {
+            state: this.state,
+            failures: this.failures,
+            successes: this.successes,
+            lastFailureTime: this.lastFailureTime,
+        };
+    }
+}
+exports.CircuitBreaker = CircuitBreaker;
+/**
+ * Wrap database operations with error handling
+ */
+function wrapDatabaseOperation(operation, errorContext) {
+    return retry(async () => {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            throw new DatabaseError(`${errorContext}: ${error.message}`, error);
+        }
+    }, {
+        maxAttempts: 3,
+        initialDelayMs: 500,
+        onRetry: (attempt, error) => {
+            console.warn(`Retrying ${errorContext} (attempt ${attempt}):`, error.message);
+        },
+    });
+}
+/**
+ * Wrap embedding operations with error handling
+ */
+function wrapEmbeddingOperation(operation, errorContext) {
+    return retry(async () => {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            const err = error;
+            // Check for rate limit errors
+            if (err.message.includes('rate_limit') || err.message.includes('429')) {
+                throw new RateLimitError(`${errorContext}: Rate limit exceeded`, error);
+            }
+            throw new EmbeddingError(`${errorContext}: ${err.message}`, error);
+        }
+    }, {
+        maxAttempts: 3,
+        initialDelayMs: 2000, // Longer delay for API rate limits
+        backoffMultiplier: 3, // More aggressive backoff
+        onRetry: (attempt, error) => {
+            console.warn(`Retrying ${errorContext} (attempt ${attempt}):`, error.message);
+        },
+    });
+}
+/**
+ * Validate inputs
+ */
+function validateInput(condition, message, details) {
+    if (!condition) {
+        throw new ValidationError(message, details);
+    }
+}
+/**
+ * Safe JSON parse
+ */
+function safeJsonParse(json, fallback) {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return fallback;
+    }
+}
+/**
+ * Safe async operation with timeout
+ */
+async function withTimeout(promise, timeoutMs, errorMessage = 'Operation timed out') {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new OpenClawError(errorMessage, 'TIMEOUT')), timeoutMs)),
+    ]);
+}
+/**
+ * Graceful degradation helper
+ */
+async function gracefulFallback(primary, fallback, errorContext) {
+    try {
+        return await primary();
+    }
+    catch (error) {
+        console.warn(`${errorContext} failed, using fallback:`, error.message);
+        return await fallback();
+    }
+}
+/**
+ * Batch operation with error handling
+ * Continues processing even if some items fail
+ */
+async function batchWithErrorHandling(items, operation, options) {
+    const opts = {
+        continueOnError: true,
+        onError: () => { },
+        ...options,
+    };
+    const results = await Promise.allSettled(items.map(async (item) => ({
+        item,
+        result: await operation(item),
+    })));
+    return results.map((result, index) => {
+        const item = items[index];
+        if (result.status === 'fulfilled') {
+            return {
+                success: true,
+                result: result.value.result,
+                item,
+            };
+        }
+        else {
+            const error = result.reason;
+            opts.onError(item, error);
+            return {
+                success: false,
+                error,
+                item,
+            };
+        }
+    });
+}