Crate openai_interface 

A low-level Rust interface for interacting with OpenAI’s API.

This crate provides a simple, efficient, and low-level way to interact with OpenAI’s API, supporting both streaming and non-streaming responses. It leverages Rust’s powerful type system for safety and performance, while exposing the full flexibility of the API.

Features

• Chat Completions: Full support for OpenAI’s chat completion and completion API, including both streaming and non-streaming responses, and multimodal user messages (text / image / audio / file content parts).
• Responses: Create model responses with the Responses API (string or item-based input, function tools, built-in web search, streaming events), retrieve and delete stored responses. Tested against DeepSeek and Qwen.
• Models: List, retrieve and delete models.
• Embeddings: Create embedding vectors from text input.
• Moderations: Classify whether text and/or image input is potentially harmful (untested).
• Images: Generate, edit, and create variations of images (untested).
• Audio: Text-to-speech, transcription, and translation endpoints (untested).
• Files: Support for the OpenAI file API (upload, list, retrieve, delete, download content).
• Streaming and Non-streaming: Support for both streaming and non-streaming responses.
• Strong Typing: Complete type definitions for all API requests and responses, utilizing Rust’s powerful type system.
• Configurable HTTP Client: Every request method takes a reqwest::Client, so proxies, timeouts and connection pooling are under your control. See rest::default_client for a sensible default.
• Error Handling: Comprehensive error handling with detailed error types defined in the errors module. Failed requests carry the API’s error message, type and code.
• Async/Await: Built with async/await support.
• Musl Support: Designed to work with musl libc out-of-the-box.
• Multiple Provider Support: Expected to work with OpenAI, DeepSeek, Qwen, and other compatible API providers.

Cargo Features

To keep the request and response types strictly OpenAI-compatible, fields that are proprietary to other providers are opt-in via cargo features. OpenAI-compatible parameters such as reasoning_effort are always available on the request types, regardless of features:

• deepseek: Enables DeepSeek’s proprietary fields — the Beta chat prefix completion fields (prefix / reasoning_content on assistant messages), the thinking and user_id request parameters, reasoning_content in responses and logprobs, prompt_cache_hit_tokens / prompt_cache_miss_tokens usage statistics, and the insufficient_system_resource finish reason. See api-docs.deepseek.com.

• qwen: Enables Qwen’s proprietary fields — the chat request parameters enable_thinking, thinking_budget and top_k, the Responses API input part input_file, the built-in tools (web_extractor, code_interpreter, web_search_image, image_search, file_search, mcp), the corresponding output items and streaming events, and the x_details / x_tools usage statistics. See the Qwen OpenAI-compatible Chat API docs and the Qwen Responses API docs.

Implemented APIs

• Chat Completions (create / retrieve / update / delete)
• Responses (create / retrieve / delete)
• Completions
• Models (list / retrieve / delete)
• Embeddings
• Moderations (untested)
• Images (generate / edit / variation, untested)
• Audio (speech / transcriptions / translations, untested)
• Files (create / list / retrieve / delete / download content)

Examples

Non-streaming Chat Completion

This example demonstrates how to make a non-streaming request to the chat completion API.

use openai_interface::chat::create::request::{Message, RequestBody};
use openai_interface::chat::create::response::no_streaming::ChatCompletion;
use openai_interface::rest::{default_client, post::PostNoStream};

const DEEPSEEK_CHAT_URL: &'static str = "https://api.deepseek.com";
const DEEPSEEK_MODEL: &'static str = "deepseek-v4-flash";

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let request = RequestBody {
        messages: vec![
            Message::System {
                content: "You are a helpful assistant.".to_string(),
                name: None,
            },
            Message::User {
                content: "Hello, how are you?".into(),
                name: None,
            },
        ],
        model: DEEPSEEK_MODEL.to_string(),
        stream: Some(false),
        ..Default::default()
    };

    // Send the request
    let chat_completion: ChatCompletion = request
        .get_response(&default_client(), DEEPSEEK_CHAT_URL, "YOUR_API_KEY")
        .await?;
    let text = chat_completion.choices[0]
        .message
        .content
        .as_deref()
        .unwrap();
    println!("{:?}", text);
    Ok(())
}

Streaming Chat Completion

This example demonstrates how to handle streaming responses from the API. As with the non-streaming example, all API parameters can be adjusted directly through the request struct.

use openai_interface::chat::create::request::{Message, RequestBody};
use openai_interface::chat::create::response::streaming::ChatCompletionChunk;
use openai_interface::rest::{default_client, post::PostStream};
use futures_util::StreamExt;

const DEEPSEEK_CHAT_URL: &'static str = "https://api.deepseek.com";
const DEEPSEEK_MODEL: &'static str = "deepseek-v4-flash";

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let request = RequestBody {
        messages: vec![
            Message::System {
                content: "You are a helpful assistant.".to_string(),
                name: None,
            },
            Message::User {
                content: "Who are you?".into(),
                name: None,
            },
        ],
        model: DEEPSEEK_MODEL.to_string(),
        stream: Some(true),
        ..Default::default()
    };

    // Send the request
    let mut response_stream = request
        .get_stream_response(&default_client(), DEEPSEEK_CHAT_URL, "YOUR_API_KEY")
        .await?;

    let mut message = String::new();

    while let Some(chunk_result) = response_stream.next().await {
        let chunk: ChatCompletionChunk = chunk_result?;
        if let Some(content) = chunk.choices[0].delta.content.as_deref() {
            println!("content chunk: {}", content);
            message.push_str(content);
        }
    }

    println!("complete message: {}", message);
    Ok(())
}

Musl Build

This crate is designed to work with musl libc, making it suitable for lightweight deployments in containerized environments. Longer compile times may be required as OpenSSL needs to be built from source.

To build for musl:

rustup target add x86_64-unknown-linux-musl
cargo build --target x86_64-unknown-linux-musl

Modules

audio

Turn audio into text or text into audio.

batches

The Batches API: run async batch processing jobs over collections of requests via /batches.

chat

Chat Completions API Module

completions

Given a prompt, the model will return one or more predicted completions, and can also return the probabilities of alternative tokens at each position. Compared to the chat API, this one does not provide the ability to have multiple rounds of conversation. This API is getting deprecated in favor of the chat API.

containers

The Containers API: manage container objects via /containers.

conversations

The Conversations API: manage conversation state via /conversations.

embeddings

Get a vector representation of a given input that can be easily consumed by machine learning models and algorithms.

errors

evals

The Evals API: manage evaluation runs via /evals.

files

File management module for OpenAI API integration.

fine_tuning

The Fine-tuning API: manage fine-tuning jobs via /fine_tuning.

images

Given a prompt and/or an input image, the model will generate a new image.

models

List and describe the various models available in the API.

moderations

Given text and/or image inputs, classifies if those inputs are potentially harmful.

pagination

Cursor pagination helpers shared by list endpoints.

realtime

The Realtime API (HTTP part): create ephemeral client sessions via /realtime.

responses

The Responses API: create model responses and retrieve stored ones.

rest

REST API client module for OpenAI interface

uploads

The Uploads API: upload large files in multiple parts via /uploads.

vector_stores

The Vector Stores API: manage vector stores via /vector_stores.