Error responses

{
  "error": {
    "message": "The model 'gpt-9' does not exist or is not available.",
    "type": "invalid_request_error",
    "param": "model",
    "code": "model_not_found"
  }
}

import os
import time
import httpx

headers = {"Authorization": f"Bearer {os.environ['ASTRODYNE_API_KEY']}"}
body = {"model": "YOUR_MODEL_ID",
        "messages": [{"role": "user", "content": "Hello"}]}


def complete(http, attempt=0):
    response = http.post("/v1/chat/completions", headers=headers, json=body)

    # Log this on every outcome, success or failure. It is what support needs.
    request_id = response.headers.get("X-Astrodyne-Request-Id")

    if response.status_code == 200:
        return response.json()

    # Every failure has this exact shape. Branch on code, never on message.
    error = response.json()["error"]
    code = error["code"]

    if response.status_code == 401:
        raise SystemExit(f"Bad credential ({code}). Check ASTRODYNE_API_KEY.")

    if response.status_code == 403:
        # Authenticated, but this account may not use the API. Retrying
        # cannot help and nothing was charged.
        raise SystemExit(f"Access denied ({code}).")

    if response.status_code == 404:
        # The model is unknown OR not permitted for this key — deliberately
        # indistinguishable. Call /v1/models to see what you may use.
        raise SystemExit(f"Not found ({code}): {error['param']}")

    if response.status_code == 409:
        # An Idempotency-Key collision. idempotency_in_progress is worth
        # waiting on; idempotency_conflict means the body changed.
        if code == "idempotency_in_progress" and attempt < 5:
            time.sleep(2 ** attempt)
            return complete(http, attempt + 1)
        raise SystemExit(f"Conflict ({code}).")

    if response.status_code == 429:
        # Honour Retry-After when it is there; back off when it is not.
        wait = float(response.headers.get("Retry-After", 2 ** attempt))
        if attempt < 5:
            time.sleep(wait)
            return complete(http, attempt + 1)
        raise SystemExit("Rate limited; giving up.")

    if response.status_code >= 500:
        # billing_error is the one 5xx you must NOT retry: the request
        # completed and the charge is already flagged for review.
        if code == "billing_error":
            raise SystemExit(f"Billing error; quote request id {request_id}.")
        if attempt < 5:
            time.sleep(2 ** attempt)
            return complete(http, attempt + 1)

    raise SystemExit(f"Unhandled {response.status_code} {code} ({request_id})")


with httpx.Client(base_url="https://api.astrodyne.ai", timeout=60) as http:
    print(complete(http)["choices"][0]["message"]["content"])

const headers = {
  Authorization: `Bearer ${process.env.ASTRODYNE_API_KEY}`,
  "Content-Type": "application/json",
};
const body = JSON.stringify({
  model: "YOUR_MODEL_ID",
  messages: [{ role: "user", content: "Hello" }],
});

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

async function complete(attempt = 0) {
  const response = await fetch("https://api.astrodyne.ai/v1/chat/completions", {
    method: "POST", headers, body,
  });

  // Log this on every outcome. It is what support needs.
  const requestId = response.headers.get("X-Astrodyne-Request-Id");
  if (response.ok) return response.json();

  // Every failure has this exact shape. Branch on code, never on message.
  const { error } = await response.json();

  if (response.status === 401) throw new Error(`Bad credential (${error.code})`);
  if (response.status === 403) throw new Error(`Access denied (${error.code})`);
  if (response.status === 404) throw new Error(`Not found (${error.code})`);

  if (response.status === 409) {
    if (error.code === "idempotency_in_progress" && attempt < 5) {
      await sleep(2 ** attempt * 1000);
      return complete(attempt + 1);
    }
    throw new Error(`Conflict (${error.code})`);
  }

  if (response.status === 429 && attempt < 5) {
    const wait = Number(response.headers.get("Retry-After") ?? 2 ** attempt);
    await sleep(wait * 1000);
    return complete(attempt + 1);
  }

  if (response.status >= 500) {
    // billing_error is the one 5xx you must NOT retry.
    if (error.code === "billing_error") {
      throw new Error(`Billing error; quote request id ${requestId}`);
    }
    if (attempt < 5) {
      await sleep(2 ** attempt * 1000);
      return complete(attempt + 1);
    }
  }

  throw new Error(`Unhandled ${response.status} ${error.code} (${requestId})`);
}

const result = await complete();
console.log(result.choices[0].message.content);

data: {"object": "error", "error": {"message": "...", "type": "service_unavailable", "param": null, "code": "service_unavailable"}}