SDK quickstart

pip install audacity-sdk

npm install @audacity/sdk
# or
bun add @audacity/sdk

go get github.com/Audacity-Investments/audacity-sdk-go

<dependency>
  <groupId>com.audacityinvestments</groupId>
  <artifactId>audacity-sdk</artifactId>
  <version>0.6.0</version>
</dependency>

[dependencies]
audacity-sdk = "0.6.0"
tokio = { version = "1", features = ["rt-multi-thread", "macros"] }

from audacity import Audacity

client = Audacity(api_key="aireserve_api_…")   # or set AIRESERVE_API_KEY

response = client.converse(
    modelId="gpt-5.4-mini",
    messages=[{"role": "user", "content": [{"text": "What is 2+2?"}]}],
    inferenceConfig={"maxTokens": 256, "temperature": 0.0},
)

print(response["output"]["message"]["content"][0]["text"])
print(response["stopReason"])   # "end_turn"
print(response["usage"])        # {"inputTokens": …, "outputTokens": …, "totalTokens": …}
print(response["metrics"])      # {"latencyMs": …}

import { AudacityRuntimeClient, ConverseCommand } from "@audacity/sdk";

const client = new AudacityRuntimeClient({ apiKey: process.env.AIRESERVE_API_KEY });

const response = await client.send(
  new ConverseCommand({
    modelId: "gpt-5.4-mini",
    messages: [{ role: "user", content: [{ text: "Hello!" }] }],
    inferenceConfig: { maxTokens: 500, temperature: 0.2 },
  })
);

console.log(response.output?.message?.content?.[0]?.text);
// response.stopReason, response.usage, response.metrics.latencyMs also populated

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/Audacity-Investments/audacity-sdk-go"
    "github.com/Audacity-Investments/audacity-sdk-go/audacityruntime"
    "github.com/Audacity-Investments/audacity-sdk-go/audacityruntime/types"
)

func main() {
    // Reads AIRESERVE_API_KEY from the environment.
    client := audacityruntime.New(audacityruntime.Options{})

    resp, err := client.Converse(context.Background(), &audacityruntime.ConverseInput{
        ModelId: audacity.String("gpt-5.4-mini"),
        Messages: []types.Message{{
            Role:    types.ConversationRoleUser,
            Content: []types.ContentBlock{
                &types.ContentBlockMemberText{Value: "Hello, world!"},
            },
        }},
        InferenceConfig: &types.InferenceConfiguration{
            MaxTokens:   audacity.Int32(500),
            Temperature: audacity.Float32(0.2),
        },
    })
    if err != nil {
        log.Fatal(err)
    }

    out := resp.Output.(*types.ConverseOutputMemberMessage)
    text := out.Value.Content[0].(*types.ContentBlockMemberText).Value
    fmt.Println(text)
}

import com.audacity.sdk.*;

var client = AudacityRuntimeClient.builder()
    .apiKey(System.getenv("AIRESERVE_API_KEY"))
    .build();

ConverseResponse response = client.converse(request -> request
    .modelId("gpt-5.4-mini")
    .messages(Message.builder()
        .role(ConversationRole.USER)
        .content(ContentBlock.fromText("What is 2 + 2?"))
        .build())
    .inferenceConfig(cfg -> cfg.maxTokens(500).temperature(0.2f)));

System.out.println(response.output().message().content().get(0).text());
System.out.printf("Stop reason : %s%n", response.stopReason());
System.out.printf("Input tokens: %d%n", response.usage().inputTokens());
System.out.printf("Latency ms  : %d%n", response.metrics().latencyMs());

use audacity_sdk::{Client, ContentBlock, ConversationRole, Message};

#[tokio::main]
async fn main() -> Result<(), audacity_sdk::Error> {
    // Reads AIRESERVE_API_KEY from the environment.
    let client = Client::from_env()?;

    let response = client.converse()
        .model_id("gpt-5.4-mini")
        .messages(
            Message::builder()
                .role(ConversationRole::User)
                .content(ContentBlock::Text("Hello!".into()))
                .build()?
        )
        .inference_config(
            audacity_sdk::InferenceConfiguration::builder()
                .max_tokens(500)
                .temperature(0.2)
                .build()
        )
        .send()
        .await?;

    let text = response
        .output().unwrap()
        .as_message().unwrap()
        .content().first().unwrap()
        .as_text().unwrap();

    println!("{text}");
    Ok(())
}