Error Handling

{
  "error": {
    "code": "invalid_request",
    "message": "The 'content' field is required",
    "type": "validation_error",
    "param": "content",
    "status": 400,
    "request_id": "req_abc123xyz"
  }
}

from hebbrix import Hebbrix
from hebbrix.exceptions import (
    HebbrixError,
    AuthenticationError,
    RateLimitError,
    ValidationError,
    NotFoundError
)

client = Hebbrix()

try:
    memory = client.memories.create(content="Test memory")
except AuthenticationError as e:
    # Invalid or missing API key
    print(f"Auth error: {e.message}")
    print(f"Check your API key configuration")

except RateLimitError as e:
    # Too many requests
    print(f"Rate limited. Retry after {e.retry_after} seconds")
    import time
    time.sleep(e.retry_after)
    # Retry the request

except ValidationError as e:
    # Invalid request parameters
    print(f"Validation error: {e.message}")
    print(f"Invalid param: {e.param}")

except NotFoundError as e:
    # Resource doesn't exist
    print(f"Not found: {e.message}")

except HebbrixError as e:
    # Catch-all for other API errors
    print(f"API error [{e.status_code}]: {e.message}")
    print(f"Request ID: {e.request_id}")
    # Log for debugging

import {
  Hebbrix,
  HebbrixError,
  AuthenticationError,
  RateLimitError,
  ValidationError,
  NotFoundError
} from 'hebbrix';

const client = new Hebbrix();

try {
  const memory = await client.memories.create({ content: 'Test memory' });
} catch (error) {
  if (error instanceof AuthenticationError) {
    // Invalid or missing API key
    console.error(`Auth error: ${error.message}`);

  } else if (error instanceof RateLimitError) {
    // Too many requests
    console.error(`Rate limited. Retry after ${error.retryAfter}s`);
    await new Promise(r => setTimeout(r, error.retryAfter * 1000));
    // Retry the request

  } else if (error instanceof ValidationError) {
    // Invalid request parameters
    console.error(`Validation error: ${error.message}`);
    console.error(`Invalid param: ${error.param}`);

  } else if (error instanceof NotFoundError) {
    // Resource doesn't exist
    console.error(`Not found: ${error.message}`);

  } else if (error instanceof HebbrixError) {
    // Catch-all for other API errors
    console.error(`API error [${error.status}]: ${error.message}`);
    console.error(`Request ID: ${error.requestId}`);

  } else {
    throw error; // Re-throw unknown errors
  }
}

HTTP/1.1 429 Too Many Requests
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1705312800
Retry-After: 45

{
  "error": {
    "code": "rate_limit_exceeded",
    "message": "Rate limit exceeded. Please retry after 45 seconds.",
    "type": "rate_limit_error",
    "status": 429,
    "request_id": "req_xyz789"
  }
}

import time
import random
from hebbrix import Hebbrix
from hebbrix.exceptions import RateLimitError, HebbrixError

def make_request_with_retry(client, max_retries=5):
    """Make a request with exponential backoff retry."""

    for attempt in range(max_retries):
        try:
            return client.memories.create(content="Test")

        except RateLimitError as e:
            if attempt == max_retries - 1:
                raise  # Give up after max retries

            # Use Retry-After header if provided
            wait_time = e.retry_after if e.retry_after else (2 ** attempt)

            # Add jitter to prevent thundering herd
            jitter = random.uniform(0, 1)
            sleep_time = wait_time + jitter

            print(f"Rate limited. Retrying in {sleep_time:.1f}s (attempt {attempt + 1})")
            time.sleep(sleep_time)

        except HebbrixError as e:
            if e.status_code >= 500:
                # Retry on server errors
                wait_time = 2 ** attempt
                print(f"Server error. Retrying in {wait_time}s")
                time.sleep(wait_time)
            else:
                raise  # Don't retry client errors