> ## Documentation Index
> Fetch the complete documentation index at: https://docs.aireserve.com/llms.txt
> Use this file to discover all available pages before exploring further.

# OpenAI & Anthropic formats — native in the AI Reserve SDKs

> All five AI Reserve SDKs speak all three gateway wire formats from one client — verbatim pass-throughs, no shape translation.

All five AI Reserve SDKs — Python, TypeScript, Go, Java, and Rust — speak all three of the gateway's wire formats
from one client: the Bedrock Converse surface you've seen above, plus **verbatim
pass-throughs of the OpenAI and Anthropic formats**. Same API key, same retries and
[exception taxonomy](/api-reference/errors), no extra dependency — and no shape translation:
requests go out exactly as you write them, responses come back exactly as the gateway
returns them. Both formats work with **every** gateway model; the gateway
bridges the wire format (GPT models answer Anthropic-format calls and vice versa).

| Surface                                              | Endpoint                         | Wire format                               |
| ---------------------------------------------------- | -------------------------------- | ----------------------------------------- |
| `client.chat.completions.create(…)`                  | `POST /v1/chat/completions`      | OpenAI Chat Completions                   |
| `client.messages.create(…)`                          | `POST /v1/messages`              | Anthropic Messages (Claude Code's format) |
| `client.messages.count_tokens(…)` / `countTokens(…)` | `POST /v1/messages/count_tokens` | Anthropic Messages (free — no inference)  |

## OpenAI format

<CodeGroup>
  ```python Python theme={"dark"}
  from audacity import Audacity

  client = Audacity()   # reads AUDACITY_API_KEY

  response = client.chat.completions.create(
      model="gpt-5.4-mini",
      messages=[{"role": "user", "content": "Hello!"}],
      max_tokens=256,
  )
  print(response["choices"][0]["message"]["content"])

  # stream=True returns a generator of raw OpenAI chunks
  for chunk in client.chat.completions.create(
      model="claude-sonnet-4-6",   # any gateway model
      messages=[{"role": "user", "content": "Write a haiku."}],
      stream=True,
  ):
      delta = chunk["choices"][0]["delta"] if chunk.get("choices") else {}
      print(delta.get("content", ""), end="", flush=True)
  ```

  ```typescript TypeScript theme={"dark"}
  import { Audacity } from "@audacity/sdk";

  const client = new Audacity(); // reads AUDACITY_API_KEY

  const response = await client.chat.completions.create({
    model: "gpt-5.4-mini",
    messages: [{ role: "user", content: "Hello!" }],
    max_tokens: 256,
  });
  console.log(response.choices[0]?.message?.content);

  // stream: true switches the return type to an AsyncIterable of raw chunks
  const stream = await client.chat.completions.create({
    model: "claude-sonnet-4-6", // any gateway model
    messages: [{ role: "user", content: "Write a haiku." }],
    stream: true,
  });
  for await (const chunk of stream) {
    process.stdout.write(chunk.choices?.[0]?.delta?.content ?? "");
  }
  ```

  ```go Go theme={"dark"}
  resp, err := client.Chat.Completions.Create(ctx, &audacityruntime.ChatCompletionCreateParams{
      Model:     "gpt-5.4-mini",
      Messages:  []map[string]interface{}{{"role": "user", "content": "Hello!"}},
      MaxTokens: audacity.Int32(256),
      Extra:     map[string]interface{}{"seed": 7}, // any other OpenAI field
  })
  if err != nil { log.Fatal(err) }
  fmt.Println(resp.Raw["choices"])

  // CreateStream returns raw chunk events; ends at data: [DONE]
  stream, err := client.Chat.Completions.CreateStream(ctx, &audacityruntime.ChatCompletionCreateParams{
      Model:    "claude-sonnet-4-6", // any gateway model
      Messages: []map[string]interface{}{{"role": "user", "content": "Write a haiku."}},
  })
  if err != nil { log.Fatal(err) }
  defer stream.Close()
  for event := range stream.Events() {
      fmt.Print(event)
  }
  if err := stream.Err(); err != nil { log.Fatal(err) }
  ```

  ```java Java theme={"dark"}
  Map<String, Object> resp = client.chat().completions().create(p -> p
      .model("gpt-5.4-mini")
      .addMessage("user", "Hello!")
      .maxTokens(256)
      .put("reasoning_effort", "low"));   // any field the gateway supports

  // Streaming yields raw OpenAI chunks; ends at data: [DONE].
  // The iterator holds a connection — use try-with-resources.
  try (var stream = client.chat().completions().createStreaming(p -> p
          .model("claude-sonnet-4-6") // any gateway model
          .addMessage("user", "Write a haiku."))) {
      stream.forEachRemaining(System.out::println);
  }
  ```

  ```rust Rust theme={"dark"}
  let response = client.chat_completions().create(json!({
      "model": "gpt-5.4-mini",
      "messages": [{"role": "user", "content": "Hello!"}],
      "max_tokens": 256,
  })).await?;
  println!("{}", response["choices"][0]["message"]["content"]);

  // create_stream yields raw chunk objects; ends at data: [DONE]
  let mut stream = client.chat_completions().create_stream(json!({
      "model": "claude-sonnet-4-6", // any gateway model
      "messages": [{"role": "user", "content": "Write a haiku."}],
  })).await?;
  while let Some(chunk) = stream.recv().await? {
      if let Some(delta) = chunk["choices"][0]["delta"]["content"].as_str() {
          print!("{delta}");
      }
  }
  ```
</CodeGroup>

## Anthropic format

<CodeGroup>
  ```python Python theme={"dark"}
  response = client.messages.create(
      model="claude-sonnet-4-6",
      max_tokens=256,
      messages=[{"role": "user", "content": "Hello!"}],
  )
  print(response["content"][0]["text"])

  # stream=True yields raw Anthropic events (message_start … message_stop)
  for event in client.messages.create(
      model="claude-sonnet-4-6",
      max_tokens=256,
      messages=[{"role": "user", "content": "Write a haiku."}],
      stream=True,
  ):
      if event["type"] == "content_block_delta":
          print(event["delta"].get("text", ""), end="", flush=True)

  # Free token counting
  count = client.messages.count_tokens(
      model="claude-sonnet-4-6",
      messages=[{"role": "user", "content": "How many tokens is this?"}],
  )
  print(count["input_tokens"])
  ```

  ```typescript TypeScript theme={"dark"}
  const message = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 256,
    messages: [{ role: "user", content: "Hello!" }],
  });
  console.log(message.content[0]?.["text"]);

  // stream: true yields raw Anthropic events (message_start … message_stop)
  const events = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 256,
    messages: [{ role: "user", content: "Write a haiku." }],
    stream: true,
  });
  for await (const event of events) {
    if (event.type === "content_block_delta") {
      process.stdout.write((event["delta"] as { text?: string }).text ?? "");
    }
  }

  // Free token counting
  const count = await client.messages.countTokens({
    model: "claude-sonnet-4-6",
    messages: [{ role: "user", content: "How many tokens is this?" }],
  });
  console.log(count.input_tokens);
  ```

  ```go Go theme={"dark"}
  msg, err := client.Messages.Create(ctx, &audacityruntime.MessageCreateParams{
      Model:     "claude-sonnet-4-6",
      MaxTokens: audacity.Int32(256),
      Messages:  []map[string]interface{}{{"role": "user", "content": "Hello!"}},
  })
  if err != nil { log.Fatal(err) }
  fmt.Println(msg.Raw["content"])

  // Free token counting
  count, err := client.Messages.CountTokens(ctx, &audacityruntime.CountTokensParams{
      Model:    "claude-sonnet-4-6",
      Messages: []map[string]interface{}{{"role": "user", "content": "How many tokens?"}},
  })
  if err != nil { log.Fatal(err) }
  fmt.Println(count.Raw["input_tokens"])
  ```

  ```java Java theme={"dark"}
  Map<String, Object> msg = client.messages().create(p -> p
      .model("claude-sonnet-4-6")
      .maxTokens(256)
      .addMessage("user", "Hello!"));

  // Streaming yields raw Anthropic events (message_start … message_stop)
  try (var events = client.messages().createStreaming(p -> p
          .model("claude-sonnet-4-6")
          .maxTokens(256)
          .addMessage("user", "Write a haiku."))) {
      events.forEachRemaining(System.out::println);
  }

  // Free token counting
  Map<String, Object> count = client.messages().countTokens(p -> p
      .model("claude-sonnet-4-6")
      .addMessage("user", "How many tokens?"));
  System.out.println(count.get("input_tokens"));
  ```

  ```rust Rust theme={"dark"}
  let message = client.messages().create(json!({
      "model": "claude-sonnet-4-6",
      "max_tokens": 256,
      "messages": [{"role": "user", "content": "Hello!"}],
  })).await?;
  println!("{}", message["content"][0]["text"]);

  // Streaming yields raw Anthropic events (message_start … message_stop)
  let mut events = client.messages().create_stream(json!({
      "model": "claude-sonnet-4-6",
      "max_tokens": 256,
      "messages": [{"role": "user", "content": "Write a haiku."}],
  })).await?;
  while let Some(event) = events.recv().await? {
      if event["type"] == "content_block_delta" {
          print!("{}", event["delta"]["text"].as_str().unwrap_or(""));
      }
  }

  // Free token counting
  let count = client.messages().count_tokens(json!({
      "model": "claude-sonnet-4-6",
      "messages": [{"role": "user", "content": "How many tokens?"}],
  })).await?;
  println!("{}", count["input_tokens"]);
  ```
</CodeGroup>

<Note>
  **Pass-through means future-proof.** The SDK never renames or strips request
  fields, so any parameter the gateway supports — including ones added after your SDK
  version shipped — works immediately. Streaming follows each provider's own protocol:
  OpenAI streams end at `data: [DONE]`; Anthropic streams end with a
  `message_stop` event. Mid-stream errors raise
  `ModelStreamErrorException`, and standard HTTP errors map through the same
  [taxonomy](/api-reference/errors) as Converse calls (429 retried with backoff, budget errors
  never retried).
</Note>

Available in all five SDKs from v0.5.0: `audacity-sdk` (Python),
`@audacity/sdk` (TypeScript), `audacity-sdk-go` (Go),
`com.audacityinvestments:audacity-sdk` (Java), and `audacity-sdk`
(Rust). Prefer no new dependency at all? Point the official
`openai`/`anthropic` packages at the gateway
([guide](/connect)).