Errors & retries

from audacity.exceptions import SdkError

try:
    response = client.converse(modelId="gpt-5.4-mini", messages=[…])
except client.exceptions.ThrottlingException as e:
    print(f"Rate limited: {e.message}, retry after {e.retry_after_seconds}s")
except client.exceptions.AccessDeniedException as e:
    print(f"Auth error [{e.status_code}]: {e.message}")
except client.exceptions.ServiceQuotaExceededException as e:
    print(f"Budget exhausted: {e.message}")
except SdkError as e:
    print(f"Network/decode error: {e.message}")

import {
  AccessDeniedException,
  ThrottlingException,
  MissingApiKeyError,
  AudacityError,
} from "@audacity/sdk";

try {
  const res = await client.send(new ConverseCommand({ /* … */ }));
} catch (err) {
  if (err instanceof MissingApiKeyError) {
    console.error("No API key configured");
  } else if (err instanceof AccessDeniedException) {
    console.error("Auth failed:", err.message, "requestId:", err.requestId);
  } else if (err instanceof ThrottlingException) {
    console.error("Rate limited. Retry after:", err.retryAfterSeconds, "s");
  } else if (err instanceof AudacityError) {
    // All SDK errors are instances of AudacityError
    console.error(err.name, err.statusCode, err.errorCode);
  }
}

_, err := client.Converse(ctx, input)
switch {
case err == nil:
    // success
case errors.Is(err, &types.MissingAPIKeyError{}):
    log.Fatal("set AIRESERVE_API_KEY")
default:
    var throttle *types.ThrottlingException
    var quota *types.ServiceQuotaExceededException
    var accessDenied *types.AccessDeniedException

    switch {
    case errors.As(err, &throttle):
        fmt.Printf("rate limited (retry-after=%v)\n", throttle.RetryAfterSeconds)
    case errors.As(err, &quota):
        fmt.Println("budget exhausted — will not retry")
    case errors.As(err, &accessDenied):
        fmt.Println("check your API key")
    default:
        log.Fatal(err)
    }
}

try {
    ConverseResponse resp = client.converse(request -> request
        .modelId("gpt-5.4-mini")
        .messages(Message.builder()
            .role(ConversationRole.USER)
            .content(ContentBlock.fromText("Hi"))
            .build()));
} catch (ThrottlingException e) {
    System.err.printf("Rate limited. Retry-After: %s s%n", e.retryAfterSeconds());
} catch (AccessDeniedException e) {
    System.err.println("Auth failed: " + e.getMessage());
} catch (ServiceQuotaExceededException e) {
    System.err.println("Budget or quota exceeded — not retried");
} catch (AudacityException e) {
    System.err.printf("SDK error [%d] %s%n", e.statusCode(), e.getMessage());
}

use audacity_sdk::Error;

match client.converse().model_id("m").messages(msg).send().await {
    Ok(resp) => { /* use resp */ }
    Err(Error::Throttling(d)) => {
        eprintln!("Rate limited (retry after {:?}s): {}", d.retry_after_seconds, d.message);
    }
    Err(Error::AccessDenied(d)) => {
        eprintln!("Access denied [{}]: {}", d.error_code.unwrap_or_default(), d.message);
    }
    Err(Error::MissingApiKey) => {
        eprintln!("Set AIRESERVE_API_KEY");
    }
    Err(e) => eprintln!("Other error: {e}"),
}

// /v1/chat/completions, /v1/responses, /v1/embeddings, /v1/models, ...
{
  "success": false,
  "error": {
    "code": "SERVICE_UNAVAILABLE",
    "message": "AI Reserve could not reach its inference engine. This is on our side; you were not charged.",
    "request_id": "7a0c1e0e-…",
    "source": "platform",
    "hint": "AI Reserve could not reach its inference engine. You were not charged. Retry shortly.",
    "details": { "upstream_error": { "…": "sanitized provider body, when one exists" } }
  }
}

// 402 — the one error these routes answer in the OpenAI error shape
{
  "error": {
    "message": "Team budget reached for Platform. Contact your administrator to raise the limit.",
    "type": "usage_cap_error",
    "param": null,
    "code": "usage_cap_exceeded"
  }
}

// /v1/messages — the Anthropic envelope; `type` follows the HTTP status,
// the request id travels in the request-id header
{
  "type": "error",
  "error": {
    "type": "api_error",
    "message": "AI Reserve could not reach its inference engine. This is on our side; you were not charged."
  }
}

// /model/{modelId}/converse — `__type` also travels in the x-amzn-ErrorType
// header, the request id in x-amzn-RequestId (boto3: ResponseMetadata.RequestId)
{
  "__type": "ServiceUnavailableException",
  "message": "AI Reserve could not reach its inference engine. This is on our side; you were not charged."
}