Struct Files 

pub struct Files { /* private fields */ }

Client for interacting with the OpenAI Files API.

This struct provides methods to upload, list, retrieve, delete files, and get file content. Use Files::new() to create a new instance.

Providers

The client supports two providers:

• OpenAI: Standard OpenAI API (default)
• Azure: Azure OpenAI Service

Example

use openai_tools::files::request::{Files, FilePurpose};

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

    // Upload a file for fine-tuning
    let file = files.upload_path("training_data.jsonl", FilePurpose::FineTune).await?;
    println!("Uploaded: {} ({})", file.filename, file.id);

    Ok(())
}

Implementations

impl Files

pub fn new() -> Result<Self>

Creates a new Files 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(Files) - A new Files client ready for use
• Err(OpenAIToolError) - If the API key is not found in the environment

Example

use openai_tools::files::request::Files;

let files = Files::new().expect("API key should be set");

pub fn with_auth(auth: AuthProvider) -> Self

Creates a new Files client with a custom authentication provider

pub fn azure() -> Result<Self>

Creates a new Files client for Azure OpenAI API

pub fn detect_provider() -> Result<Self>

Creates a new Files client by auto-detecting the provider

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

Creates a new Files client with URL-based provider detection

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

Creates a new Files client from URL using environment variables

pub fn auth(&self) -> &AuthProvider

Returns the authentication provider

pub fn base_url<T: AsRef<str>>(&mut self, url: T) -> &mut Self

Sets a custom API endpoint URL (OpenAI only)

Use this to point to alternative OpenAI-compatible APIs.

Arguments

• url - The base URL (e.g., “https://my-proxy.example.com/v1”)

Returns

A mutable reference to self for method chaining

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::files::request::Files;

let mut files = Files::new().unwrap();
files.timeout(Duration::from_secs(120));  // Longer timeout for file uploads

pub async fn upload_path( &self, file_path: &str, purpose: FilePurpose, ) -> Result<File>

Uploads a file from a file path.

The file will be uploaded with the specified purpose. Individual files can be up to 512 MB, and the total size of all files uploaded by one organization can be up to 100 GB.

Arguments

• file_path - Path to the file to upload
• purpose - The intended purpose of the uploaded file

Returns

• Ok(File) - The uploaded file object
• Err(OpenAIToolError) - If the file cannot be read or the upload fails

Example

use openai_tools::files::request::{Files, FilePurpose};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let files = Files::new()?;
    let file = files.upload_path("data.jsonl", FilePurpose::FineTune).await?;
    println!("Uploaded: {}", file.id);
    Ok(())
}

pub async fn upload_bytes( &self, content: &[u8], filename: &str, purpose: FilePurpose, ) -> Result<File>

Uploads a file from bytes.

The file will be uploaded with the specified filename and purpose.

Arguments

• content - The file content as bytes
• filename - The name to give the file
• purpose - The intended purpose of the uploaded file

Returns

• Ok(File) - The uploaded file object
• Err(OpenAIToolError) - If the upload fails

Example

use openai_tools::files::request::{Files, FilePurpose};

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

    let content = b"{\"messages\": [{\"role\": \"user\", \"content\": \"Hello\"}]}";
    let file = files.upload_bytes(content, "training.jsonl", FilePurpose::FineTune).await?;

    println!("Uploaded: {}", file.id);
    Ok(())
}

pub async fn list( &self, purpose: Option<FilePurpose>, ) -> Result<FileListResponse>

Lists all files that belong to the user’s organization.

Optionally filter by purpose.

Arguments

• purpose - Optional filter by file purpose

Returns

• Ok(FileListResponse) - The list of files
• Err(OpenAIToolError) - If the request fails

Example

use openai_tools::files::request::{Files, FilePurpose};

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

    // List all files
    let all_files = files.list(None).await?;
    println!("Total files: {}", all_files.data.len());

    // List only fine-tuning files
    let ft_files = files.list(Some(FilePurpose::FineTune)).await?;
    println!("Fine-tuning files: {}", ft_files.data.len());

    Ok(())
}

pub async fn retrieve(&self, file_id: &str) -> Result<File>

Retrieves details of a specific file.

Arguments

• file_id - The ID of the file to retrieve

Returns

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

Example

use openai_tools::files::request::Files;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let files = Files::new()?;
    let file = files.retrieve("file-abc123").await?;

    println!("File: {}", file.filename);
    println!("Size: {} bytes", file.bytes);
    println!("Purpose: {}", file.purpose);
    Ok(())
}

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

Deletes a file.

Arguments

• file_id - The ID of the file to delete

Returns

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

Example

use openai_tools::files::request::Files;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let files = Files::new()?;
    let result = files.delete("file-abc123").await?;

    if result.deleted {
        println!("File {} was deleted", result.id);
    }
    Ok(())
}

pub async fn content(&self, file_id: &str) -> Result<Vec<u8>>

Retrieves the content of a file.

Arguments

• file_id - The ID of the file to retrieve content from

Returns

• Ok(Vec<u8>) - The file content as bytes
• Err(OpenAIToolError) - If the file cannot be retrieved or the request fails

Example

use openai_tools::files::request::Files;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let files = Files::new()?;
    let content = files.content("file-abc123").await?;

    // Convert to string if it's text content
    let text = String::from_utf8(content)?;
    println!("Content: {}", text);
    Ok(())
}