// A. canonical (every model/resource endpoint)
{"error": {"message": "Missing required parameter: 'model'.", "type": "invalid_request_error", "param": "model", "code": "missing_required_parameter"}}
// B. bare string (Administration endpoints without the scope — HTTP 403)
{"error": "You have insufficient permissions for this operation. Missing scopes: api.management.read. Check that you have the correct role in your organization, and if you're using a restricted API key, that it has the necessary scopes."}
// C. empty body (Cloudflare edge, unknown URL) — HTTP 404, only CF-RAY header, no x-request-id
// D. streaming (after HTTP 200): SSE `event: error` / `response.failed` carrying {code, message, param, sequence_number}
// E. optional extensions: error.misalignment {classification, message, continuation_instruction}; error.moderation_details {moderation_stage, categories[]}

import random, time
import openai
from openai import OpenAI

client = OpenAI(max_retries=0, timeout=60)   # do our own retry so we can honour long Retry-After and log everything
NON_RETRYABLE_429 = {"insufficient_quota", "credit_balance_exhausted", "organization_spend_limit_exceeded",
                     "project_spend_limit_exceeded", "organization_usage_limit_exceeded"}

def call_with_retry(fn, attempts=5, cap=30.0):
    for attempt in range(1, attempts + 1):
        try:
            return fn()
        except (openai.APIConnectionError, openai.APITimeoutError) as e:
            delay = min(cap, 0.5 * 2 ** attempt) * (1 + random.random() / 4)
        except openai.RateLimitError as e:                       # 429
            if e.code in NON_RETRYABLE_429 or (e.body or {}).get("type") == "insufficient_quota":
                raise                                              # billing problem: retrying cannot help
            ra = e.response.headers.get("retry-after") or e.response.headers.get("retry-after-ms")
            delay = (float(ra) / (1000 if "ms" in str(e.response.headers.get("retry-after-ms", "")) else 1)) if ra and ra.replace(".", "").isdigit() else min(cap, 0.5 * 2 ** attempt)
            delay += random.random() / 4
        except openai.InternalServerError as e:                  # 500 / 502 / 503 server_is_overloaded / 504
            if e.response.headers.get("x-should-retry") == "false":
                raise
            ra = e.response.headers.get("retry-after")
            delay = float(ra) if ra and ra.isdigit() else min(cap, 0.5 * 2 ** attempt) * (1 + random.random() / 4)
        except openai.PermissionDeniedError as e:                # 403 — never retry; may be a safety block
            if e.code in {"misalignment_policy_violation", "cyber_policy"}:
                notify_operator(e); raise
            raise
        except openai.APIStatusError as e:                       # 400/401/404/405/409/422 …
            log.error("openai %s %s code=%s param=%s req=%s", e.status_code, e.message, e.code, e.param, e.request_id)
            raise
        if attempt == attempts:
            raise
        time.sleep(delay)

resp = call_with_retry(lambda: client.responses.create(model="gpt-5.4-nano", input="Reply with OK.", max_output_tokens=16))
if resp.status == "incomplete":                                   # not an exception!
    print("incomplete:", resp.incomplete_details.reason)         # max_output_tokens | max_messages | content_filter | steered
print(resp.output_text, resp._request_id)

import OpenAI from "openai";
const client = new OpenAI({ maxRetries: 0, timeout: 60_000 });
const NON_RETRYABLE_429 = new Set(["insufficient_quota", "credit_balance_exhausted", "organization_spend_limit_exceeded", "project_spend_limit_exceeded", "organization_usage_limit_exceeded"]);
const sleep = (s: number) => new Promise((r) => setTimeout(r, s * 1000));

export async function withRetry<T>(fn: () => Promise<T>, attempts = 5, cap = 30): Promise<T> {
  for (let attempt = 1; ; attempt++) {
    try {
      return await fn();
    } catch (err) {
      const backoff = Math.min(cap, 0.5 * 2 ** attempt) * (1 + Math.random() / 4);
      let delay: number | null = null;
      if (err instanceof OpenAI.APIConnectionError) delay = backoff;                       // network / timeout
      else if (err instanceof OpenAI.RateLimitError) {                                     // 429
        const type = (err.error as any)?.type;
        if ((err.code && NON_RETRYABLE_429.has(err.code)) || type === "insufficient_quota") throw err;
        const ra = err.headers?.get("retry-after-ms") ?? err.headers?.get("retry-after");
        delay = ra && !Number.isNaN(Number(ra)) ? Number(ra) / (err.headers?.get("retry-after-ms") ? 1000 : 1) + Math.random() / 4 : backoff;
      } else if (err instanceof OpenAI.InternalServerError) {                              // 500/502/503/504
        if (err.headers?.get("x-should-retry") === "false") throw err;
        const ra = err.headers?.get("retry-after");
        delay = ra && !Number.isNaN(Number(ra)) ? Number(ra) : backoff;
      } else if (err instanceof OpenAI.PermissionDeniedError) {                            // 403 — never retry
        if (err.code === "misalignment_policy_violation" || err.code === "cyber_policy") notifyOperator(err);
        throw err;
      } else if (err instanceof OpenAI.APIError) {                                          // 400/401/404/405/409/422
        console.error("openai", err.status, err.code, err.param, err.requestID, err.message);
        throw err;
      } else throw err;
      if (attempt >= attempts) throw err;
      await sleep(delay);
    }
  }
}

const resp = await withRetry(() => client.responses.create({ model: "gpt-5.4-nano", input: "Reply with OK.", max_output_tokens: 16 }));
if (resp.status === "incomplete") console.warn("incomplete:", resp.incomplete_details?.reason);
console.log(resp.output_text, resp._request_id);