Error Handling

{
  "error": {
    "message": "Human-readable error description",
    "type": "error_type",
    "code": "error_code"
  }
}

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

{
  "error": {
    "message": "Insufficient credits to complete this request",
    "type": "payment_error",
    "code": "insufficient_credits"
  }
}

{
  "error": {
    "message": "Invalid value for 'temperature': must be between 0 and 2",
    "type": "invalid_request_error",
    "code": "invalid_parameter"
  }
}

{
  "error": {
    "message": "Rate limit exceeded. Please slow down.",
    "type": "rate_limit_error",
    "code": "rate_limit_exceeded"
  }
}

import requests
from requests.exceptions import RequestException
 
def make_api_request(messages):
    try:
        response = requests.post(
            "https://api.elyxir.ai/v1/chat/completions",
            headers={
                "Authorization": "Bearer elyxir_your_api_key",
                "Content-Type": "application/json"
            },
            json={"model": "gpt-4o-mini", "messages": messages}
        )
 
        # Raise exception for 4xx/5xx status codes
        response.raise_for_status()
        return response.json()
 
    except requests.exceptions.HTTPError as e:
        error_data = e.response.json().get("error", {})
 
        if e.response.status_code == 401:
            print("Authentication failed. Check your API key.")
        elif e.response.status_code == 402:
            print("Insufficient credits. Add credits to continue.")
        elif e.response.status_code == 429:
            print("Rate limited. Waiting before retry...")
            # Implement backoff
        else:
            print(f"API error: {error_data.get('message')}")
 
        return None
 
    except RequestException as e:
        print(f"Request failed: {e}")
        return None

import time
import random
 
def request_with_backoff(messages, max_retries=5):
    for attempt in range(max_retries):
        try:
            response = make_api_request(messages)
            if response:
                return response
        except RateLimitError:
            if attempt < max_retries - 1:
                # Exponential backoff with jitter
                wait_time = (2 ** attempt) + random.uniform(0, 1)
                print(f"Rate limited. Waiting {wait_time:.2f}s...")
                time.sleep(wait_time)
            else:
                raise
    return None

def validate_request(model, messages):
    if not model:
        raise ValueError("Model is required")
    if not messages or not isinstance(messages, list):
        raise ValueError("Messages must be a non-empty list")
    for msg in messages:
        if "role" not in msg or "content" not in msg:
            raise ValueError("Each message must have role and content")

response = requests.post(
    url,
    headers=headers,
    json=data,
    timeout=30  # 30 second timeout
)