Struct Models 

pub struct Models { /* private fields */ }

Client for interacting with the OpenAI Models API.

This struct provides methods to list, retrieve, and delete models. Use Models::new() to create a new instance.

Example

use openai_tools::models::request::Models;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let models = Models::new()?;

    // Get details of a specific model
    let model = models.retrieve("gpt-4o-mini").await?;
    println!("Model: {} (created: {})", model.id, model.created);

    Ok(())
}

Implementations

impl Models

pub fn new() -> Result<Self>

Creates a new Models client for OpenAI API.

Initializes the client by loading the OpenAI API key from the environment variable OPENAI_API_KEY. Supports .env file loading via dotenvy.

Returns

• Ok(Models) - A new Models client ready for use
• Err(OpenAIToolError) - If the API key is not found in the environment

Example

use openai_tools::models::request::Models;

let models = Models::new().expect("API key should be set");

pub fn with_auth(auth: AuthProvider) -> Self

Creates a new Models client with a custom authentication provider

pub fn azure() -> Result<Self>

Creates a new Models client for Azure OpenAI API

pub fn detect_provider() -> Result<Self>

Creates a new Models client by auto-detecting the provider

pub fn with_url<S: Into<String>>(base_url: S, api_key: S) -> Self

Creates a new Models client with URL-based provider detection

pub fn from_url<S: Into<String>>(url: S) -> Result<Self>

Creates a new Models client from URL using environment variables

pub fn auth(&self) -> &AuthProvider

Returns the authentication provider

pub fn timeout(&mut self, timeout: Duration) -> &mut Self

Sets the request timeout duration.

Arguments

• timeout - The maximum time to wait for a response

Returns

A mutable reference to self for method chaining

Example

use std::time::Duration;
use openai_tools::models::request::Models;

let mut models = Models::new().unwrap();
models.timeout(Duration::from_secs(30));

pub async fn list(&self) -> Result<ModelsListResponse>

Lists all available models.

Returns a list of models that are currently available in the OpenAI API.

Returns

• Ok(ModelsListResponse) - The list of available models
• Err(OpenAIToolError) - If the request fails or response parsing fails

Example

use openai_tools::models::request::Models;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let models = Models::new()?;
    let response = models.list().await?;

    println!("Found {} models", response.data.len());
    for model in &response.data {
        println!("- {}", model.id);
    }
    Ok(())
}

pub async fn retrieve(&self, model_id: &str) -> Result<Model>

Retrieves details of a specific model.

Gets information about a model by its ID, including when it was created and who owns it.

Arguments

• model_id - The ID of the model to retrieve (e.g., “gpt-4o-mini”)

Returns

• Ok(Model) - The model details
• Err(OpenAIToolError) - If the model is not found or the request fails

Example

use openai_tools::models::request::Models;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let models = Models::new()?;
    let model = models.retrieve("gpt-4o-mini").await?;

    println!("Model: {}", model.id);
    println!("Owned by: {}", model.owned_by);
    println!("Created: {}", model.created);
    Ok(())
}

pub async fn delete(&self, model_id: &str) -> Result<DeleteResponse>

Deletes a fine-tuned model.

You must have the Owner role in your organization or be allowed to delete models. This only works for fine-tuned models that you have created.

Arguments

• model_id - The ID of the fine-tuned model to delete

Returns

• Ok(DeleteResponse) - Confirmation of deletion
• Err(OpenAIToolError) - If the model cannot be deleted or the request fails

Example

use openai_tools::models::request::Models;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let models = Models::new()?;

    // Delete a fine-tuned model
    let result = models.delete("ft:gpt-4o-mini:my-org:my-model:abc123").await?;
    if result.deleted {
        println!("Model {} was deleted", result.id);
    }
    Ok(())
}