OpenAI & Anthropic formats — native in the AI Reserve SDKs

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, 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

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)

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 ?? "");
}

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) }

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);
}

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}");
    }
}

Anthropic format

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"])

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);

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"])

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"));

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"]);

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 as Converse calls (429 retried with backoff, budget errors never retried).

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).

Reference

Endpoints

OpenAI & Anthropic formats — native in the AI Reserve SDKs

OpenAI format

Anthropic format

​OpenAI format

​Anthropic format

OpenAI format

Anthropic format