Struct RunsApi 

pub struct RunsApi { /* private fields */ }

OpenAI Runs API client for managing assistant run execution

Implementations

impl RunsApi

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

Creates a new Runs API client with a custom base URL

Arguments

• api_key - Your OpenAI API key
• base_url - Custom API base URL

Example

use openai_rust_sdk::api::{runs::RunsApi, common::ApiClientConstructors};

let api = RunsApi::with_base_url("your-api-key", "https://api.openai.com")?;

pub async fn create_run<S: AsRef<str>>( &self, thread_id: S, request: RunRequest, ) -> Result<Run>

Create a run

Arguments

• thread_id - The ID of the thread to run
• request - The run request parameters

Example

use openai_rust_sdk::api::{runs::RunsApi, common::ApiClientConstructors};
use openai_rust_sdk::models::runs::RunRequest;

let api = RunsApi::new("your-api-key")?;
let request = RunRequest::builder()
    .assistant_id("asst_abc123")
    .instructions("Please analyze the data.")
    .build()?;

let run = api.create_run("thread_abc123", request).await?;
println!("Created run: {}", run.id);

pub async fn create_thread_and_run( &self, request: CreateThreadAndRunRequest, ) -> Result<Run>

Create a thread and run it in one request

Arguments

• request - The thread and run request parameters

Example

use openai_rust_sdk::api::{runs::RunsApi, common::ApiClientConstructors};
use openai_rust_sdk::models::runs::CreateThreadAndRunRequest;

let api = RunsApi::new("your-api-key")?;
let request = CreateThreadAndRunRequest::builder()
    .assistant_id("asst_abc123")
    .instructions("Please help me with this task.")
    .build()?;

let run = api.create_thread_and_run(request).await?;
println!("Created thread and run: {} in thread {}", run.id, run.thread_id);

pub async fn retrieve_run<S: AsRef<str>, R: AsRef<str>>( &self, thread_id: S, run_id: R, ) -> Result<Run>

Retrieve a run

Arguments

• thread_id - The ID of the thread
• run_id - The ID of the run to retrieve

Example

use openai_rust_sdk::api::{runs::RunsApi, common::ApiClientConstructors};

let api = RunsApi::new("your-api-key")?;
let run = api.retrieve_run("thread_abc123", "run_abc123").await?;
println!("Run status: {:?}", run.status);

pub async fn modify_run<S: AsRef<str>, R: AsRef<str>>( &self, thread_id: S, run_id: R, request: ModifyRunRequest, ) -> Result<Run>

Modify a run

Arguments

• thread_id - The ID of the thread
• run_id - The ID of the run to modify
• request - The modification request

Example

use openai_rust_sdk::api::{runs::RunsApi, common::ApiClientConstructors};
use openai_rust_sdk::models::runs::ModifyRunRequest;
use std::collections::HashMap;

let api = RunsApi::new("your-api-key")?;
let mut metadata = HashMap::new();
metadata.insert("updated".to_string(), "true".to_string());
let request = ModifyRunRequest { metadata: Some(metadata) };

let run = api.modify_run("thread_abc123", "run_abc123", request).await?;
println!("Modified run: {}", run.id);

pub async fn list_runs<S: AsRef<str>>( &self, thread_id: S, params: Option<ListRunsParams>, ) -> Result<ListRunsResponse>

List runs in a thread

Arguments

• thread_id - The ID of the thread
• params - Optional pagination parameters

Example

use openai_rust_sdk::api::{runs::RunsApi, common::ApiClientConstructors};
use openai_rust_sdk::models::runs::ListRunsParams;

let api = RunsApi::new("your-api-key")?;
let params = ListRunsParams { limit: Some(10), ..Default::default() };
let response = api.list_runs("thread_abc123", Some(params)).await?;
println!("Found {} runs", response.data.len());

pub async fn submit_tool_outputs<S: AsRef<str>, R: AsRef<str>>( &self, thread_id: S, run_id: R, request: SubmitToolOutputsRequest, ) -> Result<Run>

Submit tool outputs to a run

Arguments

• thread_id - The ID of the thread
• run_id - The ID of the run
• request - The tool outputs to submit

Example

use openai_rust_sdk::api::{runs::RunsApi, common::ApiClientConstructors};
use openai_rust_sdk::models::runs::{SubmitToolOutputsRequest, ToolOutput};

let api = RunsApi::new("your-api-key")?;
let request = SubmitToolOutputsRequest {
    tool_outputs: vec![
        ToolOutput {
            tool_call_id: "call_abc123".to_string(),
            output: "The result is 42".to_string(),
        }
    ],
};

let run = api.submit_tool_outputs("thread_abc123", "run_abc123", request).await?;
println!("Submitted tool outputs to run: {}", run.id);

pub async fn cancel_run<S: AsRef<str>, R: AsRef<str>>( &self, thread_id: S, run_id: R, ) -> Result<Run>

Cancel a run

Arguments

• thread_id - The ID of the thread
• run_id - The ID of the run to cancel

Example

use openai_rust_sdk::api::{runs::RunsApi, common::ApiClientConstructors};

let api = RunsApi::new("your-api-key")?;
let run = api.cancel_run("thread_abc123", "run_abc123").await?;
println!("Cancelled run: {}", run.id);

pub async fn list_run_steps<S: AsRef<str>, R: AsRef<str>>( &self, thread_id: S, run_id: R, params: Option<ListRunStepsParams>, ) -> Result<ListRunStepsResponse>

List run steps in a run

Arguments

• thread_id - The ID of the thread
• run_id - The ID of the run
• params - Optional pagination parameters

Example

use openai_rust_sdk::api::{runs::RunsApi, common::ApiClientConstructors};
use openai_rust_sdk::models::runs::ListRunStepsParams;

let api = RunsApi::new("your-api-key")?;
let params = ListRunStepsParams { limit: Some(10), ..Default::default() };
let response = api.list_run_steps("thread_abc123", "run_abc123", Some(params)).await?;
println!("Found {} run steps", response.data.len());

pub async fn retrieve_run_step<S: AsRef<str>, R: AsRef<str>, T: AsRef<str>>( &self, thread_id: S, run_id: R, step_id: T, ) -> Result<RunStep>

Retrieve a run step

Arguments

• thread_id - The ID of the thread
• run_id - The ID of the run
• step_id - The ID of the run step to retrieve

Example

use openai_rust_sdk::api::{runs::RunsApi, common::ApiClientConstructors};

let api = RunsApi::new("your-api-key")?;
let step = api.retrieve_run_step("thread_abc123", "run_abc123", "step_abc123").await?;
println!("Run step status: {:?}", step.status);

pub async fn submit_tool_outputs_stream<S: AsRef<str>, R: AsRef<str>>( &self, thread_id: S, run_id: R, request: SubmitToolOutputsRequest, ) -> Result<Run>

Submit tool outputs with streaming

Arguments

• thread_id - The ID of the thread
• run_id - The ID of the run
• request - The tool outputs to submit

Example

use openai_rust_sdk::api::{runs::RunsApi, common::ApiClientConstructors};
use openai_rust_sdk::models::runs::{SubmitToolOutputsRequest, ToolOutput};

let api = RunsApi::new("your-api-key")?;
let request = SubmitToolOutputsRequest {
    tool_outputs: vec![
        ToolOutput {
            tool_call_id: "call_abc123".to_string(),
            output: "The result is 42".to_string(),
        }
    ],
};

let run = api.submit_tool_outputs_stream("thread_abc123", "run_abc123", request).await?;
println!("Submitted tool outputs with streaming to run: {}", run.id);

pub async fn create_run_stream<S: AsRef<str>>( &self, thread_id: S, request: RunRequest, ) -> Result<Run>

Create a run with streaming

Arguments

• thread_id - The ID of the thread to run
• request - The run request parameters

Example

use openai_rust_sdk::api::{runs::RunsApi, common::ApiClientConstructors};
use openai_rust_sdk::models::runs::RunRequest;

let api = RunsApi::new("your-api-key")?;
let request = RunRequest::builder()
    .assistant_id("asst_abc123")
    .instructions("Please analyze the data.")
    .build()?;

let run = api.create_run_stream("thread_abc123", request).await?;
println!("Created streaming run: {}", run.id);

pub async fn create_thread_and_run_stream( &self, request: CreateThreadAndRunRequest, ) -> Result<Run>

Create a thread and run with streaming

Arguments

• request - The thread and run request parameters

Example

use openai_rust_sdk::api::{runs::RunsApi, common::ApiClientConstructors};
use openai_rust_sdk::models::runs::CreateThreadAndRunRequest;

let api = RunsApi::new("your-api-key")?;
let request = CreateThreadAndRunRequest::builder()
    .assistant_id("asst_abc123")
    .instructions("Please help me with this task.")
    .build()?;

let run = api.create_thread_and_run_stream(request).await?;
println!("Created streaming thread and run: {} in thread {}", run.id, run.thread_id);

Trait Implementations

impl ApiClientConstructors for RunsApi

fn from_http_client(http_client: HttpClient) -> Self

Create a new instance with the HTTP client

fn new<S: Into<String>>(api_key: S) -> Result<Self>

Creates a new API client

fn new_with_base_url<S: Into<String>>(api_key: S, base_url: S) -> Result<Self>

Creates a new API client with custom base URL

impl Clone for RunsApi

fn clone(&self) -> RunsApi

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RunsApi

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.