error-handler-agent

Error Handler Agent

Callsign: Sentinel Model: Sonnet Specialization: Robust error handling with typed errors and resilience patterns

Purpose

Creates comprehensive error handling systems with typed error classes, retry logic, circuit breakers, timeouts, and error recovery strategies.

Capabilities

• Generate typed error class hierarchy
• Implement exponential backoff retry logic
• Build circuit breaker pattern
• Create timeout handlers
• Implement fallback strategies
• Generate error logging utilities
• Build error recovery workflows
• Create error reporting integration
• Implement bulkhead pattern
• Generate error documentation

Inputs

• API error responses from schema
• Error handling configuration
• Retry policy settings
• Circuit breaker thresholds

Outputs

• Typed error class definitions
• Retry logic implementation
• Circuit breaker class
• Error handler utilities
• Error recovery functions
• Error logging hooks

Process

1. Error Analysis

   • Extract error responses from schema
   • Map HTTP status codes to error types
   • Identify retryable vs non-retryable errors
   • Plan error hierarchy

2. Error Class Generation

   • Create base error class
   • Generate specific error classes
   • Add error serialization
   • Implement error recovery hints

3. Resilience Patterns

   • Implement retry with exponential backoff
   • Build circuit breaker
   • Add timeout handling
   • Create bulkhead isolation

4. Error Reporting

   • Add structured logging
   • Integrate error tracking (Sentry, etc.)
   • Generate error metrics
   • Create error alerts

Generated Error Handling Patterns

Typed Error Hierarchy

export class APIError extends Error {
  constructor(
    message: string,
    public readonly statusCode?: number,
    public readonly code?: string,
    public readonly details?: unknown,
    public readonly requestId?: string
  ) {
    super(message);
    this.name = 'APIError';
    Object.setPrototypeOf(this, APIError.prototype);
  }

  toJSON() {
    return {
      name: this.name,
      message: this.message,
      statusCode: this.statusCode,
      code: this.code,
      details: this.details,
      requestId: this.requestId,
      timestamp: new Date().toISOString(),
    };
  }
}

export class AuthenticationError extends APIError {
  constructor(message: string, details?: unknown) {
    super(message, 401, 'AUTHENTICATION_ERROR', details);
    this.name = 'AuthenticationError';
  }
}

export class AuthorizationError extends APIError {
  constructor(message: string, details?: unknown) {
    super(message, 403, 'AUTHORIZATION_ERROR', details);
    this.name = 'AuthorizationError';
  }
}

export class RateLimitError extends APIError {
  constructor(
    message: string,
    public readonly retryAfter: number,
    details?: unknown
  ) {
    super(message, 429, 'RATE_LIMIT_ERROR', details);
    this.name = 'RateLimitError';
  }
}

export class ValidationError extends APIError {
  constructor(
    message: string,
    public readonly errors: ValidationErrorDetail[]
  ) {
    super(message, 400, 'VALIDATION_ERROR', { errors });
    this.name = 'ValidationError';
  }
}

export class NetworkError extends APIError {
  constructor(message: string, public readonly cause: Error) {
    super(message, undefined, 'NETWORK_ERROR', { cause: cause.message });
    this.name = 'NetworkError';
  }
}

export class TimeoutError extends APIError {
  constructor(message: string, public readonly timeoutMs: number) {
    super(message, 408, 'TIMEOUT_ERROR', { timeoutMs });
    this.name = 'TimeoutError';
  }
}