Errors

from warpllm import WarpLLM, RateLimitError, APIConnectionError, APIStatusError

client = WarpLLM()

try:
    completion = client.chat_completions({"model": model, "messages": messages})
except RateLimitError as e:
    # Waiting fixes one of the two failures a 429 covers, never the other.
    if e.code == "insufficient_quota":
        top_up()
    else:
        back_off(e.headers.get("retry-after"))
except APIConnectionError:
    # No status and no body: the provider was never reached.
    retry_with_backoff()
except APIStatusError as e:
    log.error("upstream %s: %s", e.status_code, e.message)

import { WarpLLM, RateLimitError, APIConnectionError, APIError } from '@warpllm/warpllm'

const client = new WarpLLM()

try {
  const completion = await client.chatCompletions({ model, messages })
} catch (err) {
  if (err instanceof RateLimitError) {
    if (err.code === 'insufficient_quota') await topUp()
    else await backOff(err.headers?.['retry-after'])
  } else if (err instanceof APIConnectionError) {
    await retryWithBackoff()
  } else if (err instanceof APIError) {
    log.error(`upstream ${err.status}: ${err.message}`)
  } else {
    throw err
  }
}

use warpllm::{Error, Origin};

match client.chat_completions(request).await {
    Ok(completion) => handle(completion),
    Err(Error::QuotaExceeded(e)) => top_up(&e),
    Err(Error::RateLimited(e)) => back_off(e.retry_after),
    Err(e) if e.origin() == Origin::Gateway => {
        // Never reached the provider; retrying the same call changes nothing.
        log::error!("warpllm: {e} ({})", e.code());
    }
    Err(e) => log::error!("provider: {e} ({})", e.code()),
}

e.message      # what went wrong
e.status_code  # only on APIStatusError and its subclasses
e.code         # the failure's own slug — the field that separates 429s
e.type         # OpenAI error family, e.g. "invalid_request_error"
e.param        # not modeled yet; always None
e.request_id   # the upstream's request id, when it sent one
e.headers      # retry-after and x-request-id, when the upstream sent them
e.body         # the error object as it came off the wire

err.message    // what went wrong
err.status     // undefined when the provider was never reached
err.code       // the failure's own slug — the field that separates 429s
err.type       // OpenAI error family, e.g. "invalid_request_error"
err.param      // not modeled yet
err.requestID  // the upstream's request id, when it sent one
err.headers    // retry-after and x-request-id, when the upstream sent them
err.error      // the error object as it came off the wire