Struct Client 

pub struct Client { /* private fields */ }

Implementations

impl Client

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

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

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

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

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 the raw body in the error when either step fails.

This is the path that create_chat and the other create_* methods use for the success branch. Routing everything through a single helper guarantees that callers never see a bare “error decoding response body” from reqwest without 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(())
}