Struct Client 

pub struct Client { /* private fields */ }

Implementations

impl Client

pub fn new(api_key: &str) -> Client

Create a new client with the shared optimized HTTP client. Uses connection pooling with keep-alive for high-throughput workloads.

Examples found in repository

examples/chat_example.rs (line 6)

async fn main() {
    let client = openai_rust::Client::new(&std::env::var("OPENAI_API_KEY").unwrap());
    let args = openai_rust::chat::ChatArguments::new(
        "gpt-3.5-turbo",
        vec![openai_rust::chat::Message {
            role: "user".to_owned(),
            content: "Hello GPT!".to_owned(),
        }],
    );
    let res = client.create_chat(args, None).await.unwrap();
    println!("{}", res);
}

examples/chat_stream_example.rs (line 8)

async fn main() {
    let client = openai_rust::Client::new(&std::env::var("OPENAI_API_KEY").unwrap());
    let args = openai_rust::chat::ChatArguments::new(
        "gpt-3.5-turbo",
        vec![openai_rust::chat::Message {
            role: "user".to_owned(),
            content: "Hello GPT!".to_owned(),
        }],
    );
    let mut res = client.create_chat_stream(args, None).await.unwrap();
    while let Some(chunk) = res.next().await {
        print!("{}", chunk.unwrap());
        std::io::stdout().flush().unwrap();
    }
}

pub fn new_with_client(api_key: &str, req_client: Client) -> Client

Create a new client with a custom reqwest::Client. Use this when you need custom TLS, proxy, or connection pool settings.

pub fn new_with_base_url(api_key: &str, base_url: &str) -> Client

Create a new client with the shared optimized HTTP client and custom base URL.

pub fn new_with_client_and_base_url( api_key: &str, req_client: Client, base_url: &str, ) -> Client

Create a new client with a custom reqwest::Client and custom base URL.

pub fn shared_client() -> &'static Client

Get a reference to the shared HTTP client for advanced usage.

pub fn with_max_retries(self, max_retries: u32) -> Self

Override the per-call retry budget (default: 3). 0 disables retries.

pub async fn read_and_parse_json<T: DeserializeOwned>( res: Response, error_context: &str, ) -> Result<T, Error>

Read the response body as text and deserialize it as JSON, surfacing the HTTP status and a (truncated) raw body in the error message.

This is the path that every create_* / list_models method uses for the success branch. Routing everything through a single helper guarantees that callers never see a bare reqwest “error decoding response body” with no context, which previously made it impossible to tell whether a 200 response was actually a non-UTF-8 binary blob, a truncated stream, or some other transport-level failure.

pub async fn list_models( &self, opt_url_path: Option<String>, ) -> Result<Vec<Model>, Error>

pub async fn create_chat( &self, args: ChatArguments, opt_url_path: Option<String>, ) -> Result<ChatCompletion, Error>

Examples found in repository

examples/chat_example.rs (line 14)

async fn main() {
    let client = openai_rust::Client::new(&std::env::var("OPENAI_API_KEY").unwrap());
    let args = openai_rust::chat::ChatArguments::new(
        "gpt-3.5-turbo",
        vec![openai_rust::chat::Message {
            role: "user".to_owned(),
            content: "Hello GPT!".to_owned(),
        }],
    );
    let res = client.create_chat(args, None).await.unwrap();
    println!("{}", res);
}

pub async fn create_chat_stream( &self, args: ChatArguments, opt_url_path: Option<String>, ) -> Result<ChatCompletionChunkStream>

Examples found in repository

examples/chat_stream_example.rs (line 16)

async fn main() {
    let client = openai_rust::Client::new(&std::env::var("OPENAI_API_KEY").unwrap());
    let args = openai_rust::chat::ChatArguments::new(
        "gpt-3.5-turbo",
        vec![openai_rust::chat::Message {
            role: "user".to_owned(),
            content: "Hello GPT!".to_owned(),
        }],
    );
    let mut res = client.create_chat_stream(args, None).await.unwrap();
    while let Some(chunk) = res.next().await {
        print!("{}", chunk.unwrap());
        std::io::stdout().flush().unwrap();
    }
}

pub async fn create_completion( &self, args: CompletionArguments, opt_url_path: Option<String>, ) -> Result<CompletionResponse>

pub async fn create_embeddings( &self, args: EmbeddingsArguments, opt_url_path: Option<String>, ) -> Result<EmbeddingsResponse>

pub async fn create_image_old( &self, args: ImageArguments, opt_url_path: Option<String>, ) -> Result<Vec<String>>

pub async fn create_image( &self, args: ImageArguments, opt_url_path: Option<String>, ) -> Result<Vec<String>>

pub async fn create_responses( &self, args: ResponsesArguments, opt_url_path: Option<String>, ) -> Result<ResponsesCompletion, Error>

Create a response using xAI’s Responses API with agentic tool calling.

This method calls the /v1/responses endpoint which supports server-side tools like web_search, x_search, code_execution, and more.

Arguments

• args - The ResponsesArguments containing model, input messages, and tools
• opt_url_path - Optional URL path override (defaults to /v1/responses)

Example

use openai_rust2::chat::{ResponsesArguments, ResponsesMessage, GrokTool};
use openai_rust2::Client;

async fn example() -> anyhow::Result<()> {
    let client = Client::new_with_base_url("your-api-key", "https://api.x.ai/v1");
    let args = ResponsesArguments::new(
        "grok-4-1-fast-reasoning",
        vec![ResponsesMessage {
            role: "user".to_string(),
            content: "What is the current Bitcoin price?".to_string(),
        }],
    ).with_tools(vec![GrokTool::web_search()]);

    let response = client.create_responses(args, None).await?;
    println!("{}", response.get_text_content());
    Ok(())
}

pub async fn create_openai_responses( &self, args: OpenAIResponsesArguments, opt_url_path: Option<String>, ) -> Result<ResponsesCompletion, Error>

Create a response using OpenAI’s Responses API with agentic tool calling.

This method calls the /v1/responses endpoint which supports server-side tools like web_search, file_search, and code_interpreter.

Supported models: gpt-5, gpt-4o, and other models with tool support.

Arguments

• args - The OpenAIResponsesArguments containing model, input messages, and tools
• opt_url_path - Optional URL path override (defaults to /v1/responses)

Example

use openai_rust2::chat::{OpenAIResponsesArguments, ResponsesMessage, OpenAITool};
use openai_rust2::Client;

async fn example() -> anyhow::Result<()> {
    let client = Client::new("your-openai-api-key");
    let args = OpenAIResponsesArguments::new(
        "gpt-5",
        vec![ResponsesMessage {
            role: "user".to_string(),
            content: "What are the latest developments in AI?".to_string(),
        }],
    ).with_tools(vec![OpenAITool::web_search()]);

    let response = client.create_openai_responses(args, None).await?;
    println!("{}", response.get_text_content());
    Ok(())
}

Trait Implementations

impl Default for Client

fn default() -> Self

Returns the “default value” for a type.