Error Handling

{
  "error": {
    "message": "Human-readable error message",
    "type": "error_category",
    "code": "specific_error_code",
    "param": "field_name" // Optional: which parameter caused the error
  }
}

{
  "error": {
    "message": "Invalid request body",
    "type": "invalid_request_error",
    "code": "invalid_body"
  }
}

{
  "error": {
    "message": "Invalid API key provided.",
    "type": "authentication_error",
    "code": "invalid_api_key"
  }
}

{
  "error": {
    "message": "Insufficient credits. Please purchase more credits to continue using the API.",
    "type": "insufficient_credits_error",
    "code": "insufficient_credits"
  }
}

{
  "error": {
    "message": "Rate limit exceeded. Free users are limited to 10 requests per minute.",
    "type": "rate_limit_error",
    "code": "rate_limit_exceeded",
    "retry_after": 45
  }
}

{
  "error": {
    "message": "An internal error occurred. Please try again.",
    "type": "api_error",
    "code": "internal_error"
  }
}

from openai import OpenAI
import time

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.xtrix.workers.dev/v1"
)

def safe_api_call(func, *args, **kwargs):
    max_retries = 3
    retry_delay = 1

    for attempt in range(max_retries):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            error_message = str(e)

            # Handle different error types
            if hasattr(e, 'status'):
                if e.status == 401:
                    print("Authentication error. Check your API key.")
                    raise
                elif e.status == 402:
                    print("Insufficient credits. Please add credits to your account.")
                    raise
                elif e.status == 429:
                    # Rate limited - implement exponential backoff
                    wait_time = retry_delay * (2 ** attempt)
                    print(f"Rate limited. Waiting {wait_time} seconds...")
                    time.sleep(wait_time)
                    continue
                elif e.status >= 500:
                    # Server error - retry
                    if attempt < max_retries - 1:
                        print(f"Server error. Retrying in {retry_delay} seconds...")
                        time.sleep(retry_delay)
                        continue

            # If we can't handle it, re-raise
            raise

    raise Exception("Max retries exceeded")

# Usage
try:
    response = safe_api_call(
        client.chat.completions.create,
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": "Hello!"}]
    )
except Exception as e:
    print(f"Failed to complete request: {e}")

class APIError extends Error {
  constructor(message, status, type, code) {
    super(message);
    this.status = status;
    this.type = type;
    this.code = code;
  }
}

async function safeAPICall(apiFunc, ...args) {
  const maxRetries = 3;
  let retryDelay = 1000;

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await apiFunc(...args);
    } catch (error) {
      // Parse error details
      const status = error.status || 500;
      const errorData = error.response?.data?.error || {};

      // Handle different error types
      switch (status) {
        case 401:
          throw new APIError(
            'Authentication failed. Check your API key.',
            401,
            'authentication_error',
            errorData.code
          );

        case 402:
          throw new APIError(
            'Insufficient credits. Please add credits.',
            402,
            'insufficient_credits_error',
            errorData.code
          );

        case 429:
          // Rate limited - exponential backoff
          const waitTime = retryDelay * Math.pow(2, attempt);
          console.log(`Rate limited. Waiting ${waitTime}ms...`);
          await new Promise((resolve) => setTimeout(resolve, waitTime));
          continue;

        case 500:
        case 502:
        case 503:
          // Server errors - retry
          if (attempt < maxRetries - 1) {
            console.log(`Server error. Retrying in ${retryDelay}ms...`);
            await new Promise((resolve) => setTimeout(resolve, retryDelay));
            continue;
          }
          break;
      }

      // Can't handle this error
      throw error;
    }
  }

  throw new Error('Max retries exceeded');
}

// Usage
try {
  const response = await safeAPICall(
    openai.chat.completions.create.bind(openai),
    {
      model: 'gpt-3.5-turbo',
      messages: [{ role: 'user', content: 'Hello!' }],
    }
  );
} catch (error) {
  console.error('Failed to complete request:', error.message);
}

def exponential_backoff(attempt, base_delay=1, max_delay=60):
    """Calculate delay with exponential backoff and jitter"""
    delay = min(base_delay * (2 ** attempt), max_delay)
    jitter = random.uniform(0, delay * 0.1)  # 10% jitter
    return delay + jitter

class CircuitBreaker {
  constructor(threshold = 5, timeout = 60000) {
    this.failureCount = 0;
    this.threshold = threshold;
    this.timeout = timeout;
    this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
    this.nextAttempt = Date.now();
  }

  async call(func, ...args) {
    if (this.state === 'OPEN') {
      if (Date.now() < this.nextAttempt) {
        throw new Error('Circuit breaker is OPEN');
      }
      this.state = 'HALF_OPEN';
    }

    try {
      const result = await func(...args);
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }

  onSuccess() {
    this.failureCount = 0;
    this.state = 'CLOSED';
  }

  onFailure() {
    this.failureCount++;
    if (this.failureCount >= this.threshold) {
      this.state = 'OPEN';
      this.nextAttempt = Date.now() + this.timeout;
    }
  }
}

def get_response_with_fallback(prompt, model="gpt-3.5-turbo"):
    models = ["gpt-3.5-turbo", "gpt-3.5-turbo-16k", "gpt-4"]

    for fallback_model in models:
        try:
            return client.chat.completions.create(
                model=fallback_model,
                messages=[{"role": "user", "content": prompt}]
            )
        except Exception as e:
            if hasattr(e, 'status') and e.status == 400:
                # Model not available, try next
                continue
            else:
                # Other error, re-raise
                raise

    # All models failed
    raise Exception("All models unavailable")

# Bad
response = client.chat.completions.create(...)
print(response.choices[0].message.content)

# Good
try:
    response = client.chat.completions.create(...)
    print(response.choices[0].message.content)
except Exception as e:
    print(f"Error: {e}")
    # Handle appropriately

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

try:
    response = make_api_call()
except Exception as e:
    logger.error(f"API call failed: {e}", exc_info=True)
    # Include request details for debugging
    logger.error(f"Request params: {request_params}")

const retry = async (fn, retries = 3, delay = 1000) => {
  try {
    return await fn();
  } catch (error) {
    if (retries === 0) throw error;

    // Only retry on retryable errors
    const retryableStatuses = [429, 500, 502, 503, 504];
    if (!retryableStatuses.includes(error.status)) {
      throw error;
    }

    await new Promise((resolve) => setTimeout(resolve, delay));
    return retry(fn, retries - 1, delay * 2);
  }
};

def validate_messages(messages):
    """Validate messages before API call"""
    if not messages:
        raise ValueError("Messages cannot be empty")

    for msg in messages:
        if 'role' not in msg or 'content' not in msg:
            raise ValueError("Each message must have 'role' and 'content'")

        if msg['role'] not in ['system', 'user', 'assistant']:
            raise ValueError(f"Invalid role: {msg['role']}")

    return True

from collections import defaultdict
from datetime import datetime, timedelta

class ErrorMonitor:
    def __init__(self):
        self.errors = defaultdict(list)

    def log_error(self, error_type, error_code):
        self.errors[error_type].append({
            'code': error_code,
            'timestamp': datetime.now()
        })
        self.cleanup_old_errors()

    def cleanup_old_errors(self):
        cutoff = datetime.now() - timedelta(hours=24)
        for error_type in self.errors:
            self.errors[error_type] = [
                e for e in self.errors[error_type]
                if e['timestamp'] > cutoff
            ]

    def get_error_stats(self):
        stats = {}
        for error_type, errors in self.errors.items():
            stats[error_type] = {
                'count': len(errors),
                'recent': len([e for e in errors
                             if e['timestamp'] > datetime.now() - timedelta(hours=1)])
            }
        return stats