Error Handling

{
  "error": "Bad Request",
  "message": "Invalid model name: 'invalid-model-xyz'"
}

{
  "error": "Bad Request",
  "message": "Missing required field: 'input'"
}

{
  "error": "Bad Request",
  "message": "Invalid type for 'temperature': expected number, got string"
}

{
  "error": "Bad Request",
  "message": "temperature must be between 0 and 2, got 3.5"
}

import requests
from typing import Optional

def make_safe_request(payload: dict) -> Optional[dict]:
    try:
        response = requests.post(
            "https://api.concentrate.ai/v1/responses",
            headers={"Authorization": "Bearer YOUR_API_KEY"},
            json=payload,
            timeout=30
        )

        # Handle different status codes
        if response.status_code == 200:
            return response.json()
        elif response.status_code == 400:
            print(f"Bad request: {response.json()['message']}")
        elif response.status_code == 401:
            print("Authentication failed - check API key")
        elif response.status_code == 402:
            print("Insufficient credits - please add funds")
        elif response.status_code == 424:
            print(f"Provider error: {response.json()['message']}")
            # Implement retry or try alternative provider
        elif response.status_code == 429:
            retry_after = int(response.headers.get('Retry-After', 60))
            print(f"Rate limited - retry after {retry_after}s")
        elif response.status_code == 500:
            print("Server error - will retry")

        return None

    except requests.exceptions.Timeout:
        print("Request timed out")
    except requests.exceptions.ConnectionError:
        print("Connection failed")
    except Exception as e:
        print(f"Unexpected error: {str(e)}")

    return None

async function makeRequestWithLogging(payload) {
  const startTime = Date.now();

  try {
    const response = await fetch("https://api.concentrate.ai/v1/responses", {
      method: "POST",
      headers: {
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json"
      },
      body: JSON.stringify(payload)
    });

    const data = await response.json();
    const duration = Date.now() - startTime;

    // Log all requests
    console.log({
      timestamp: new Date().toISOString(),
      status: response.status,
      model: payload.model,
      duration,
      success: response.ok
    });

    if (!response.ok) {
      // Log error details
      console.error({
        error: data.error,
        message: data.message,
        payload
      });
    }

    return data;
  } catch (error) {
    console.error({
      timestamp: new Date().toISOString(),
      error: error.message,
      payload
    });
    throw error;
  }
}

from datetime import datetime, timedelta

class CircuitBreaker:
    def __init__(self, failure_threshold=5, timeout=60):
        self.failure_threshold = failure_threshold
        self.timeout = timeout
        self.failures = 0
        self.last_failure_time = None
        self.state = "closed"  # closed, open, half-open

    def call(self, func, *args, **kwargs):
        if self.state == "open":
            if datetime.now() - self.last_failure_time > timedelta(seconds=self.timeout):
                self.state = "half-open"
            else:
                raise Exception("Circuit breaker is open")

        try:
            result = func(*args, **kwargs)
            self.on_success()
            return result
        except Exception as e:
            self.on_failure()
            raise

    def on_success(self):
        self.failures = 0
        self.state = "closed"

    def on_failure(self):
        self.failures += 1
        self.last_failure_time = datetime.now()
        if self.failures >= self.failure_threshold:
            self.state = "open"

# Usage
breaker = CircuitBreaker()

try:
    response = breaker.call(make_api_request, payload)
except Exception as e:
    print(f"Request failed: {e}")

interface RequestPayload {
  model: string;
  input: string | Message[];
  temperature?: number;
  max_output_tokens?: number;
}

function validatePayload(payload: RequestPayload): string[] {
  const errors: string[] = [];

  if (!payload.model) {
    errors.push("model is required");
  }

  if (!payload.input) {
    errors.push("input is required");
  }

  if (payload.temperature !== undefined) {
    if (payload.temperature < 0 || payload.temperature > 2) {
      errors.push("temperature must be between 0 and 2");
    }
  }

  if (payload.max_output_tokens !== undefined) {
    if (payload.max_output_tokens < 1) {
      errors.push("max_output_tokens must be positive");
    }
  }

  return errors;
}

// Usage
const payload = { model: "gpt-5.2", input: "Hello" };
const errors = validatePayload(payload);

if (errors.length > 0) {
  console.error("Validation errors:", errors);
} else {
  // Make request
}