openai-client-base 0.12.0

/*
 * OpenAI API
 *
 * The OpenAI REST API. Please see https://platform.openai.com/docs/api-reference for more details.
 *
 * The version of the OpenAPI document: 2.3.0
 *
 * Generated by: https://openapi-generator.tech
 */

#![allow(clippy::needless_return, clippy::into_iter_on_ref)]

use super::{configuration, ContentType, Error};
use crate::{apis::ResponseContent, models};
use reqwest;
use serde::{de::Error as _, Deserialize, Serialize};

/// struct for typed errors of method [`cancel_run`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CancelRunError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`create_assistant`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateAssistantError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`create_message`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateMessageError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`create_run`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateRunError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`create_thread`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateThreadError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`create_thread_and_run`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateThreadAndRunError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_assistant`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteAssistantError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_message`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteMessageError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_thread`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteThreadError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_assistant`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetAssistantError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_message`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetMessageError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_run`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetRunError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_run_step`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetRunStepError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_thread`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetThreadError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`list_assistants`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListAssistantsError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`list_messages`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListMessagesError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`list_run_steps`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListRunStepsError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`list_runs`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListRunsError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`modify_assistant`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ModifyAssistantError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`modify_message`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ModifyMessageError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`modify_run`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ModifyRunError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`modify_thread`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ModifyThreadError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`submit_tool_ouputs_to_run`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SubmitToolOuputsToRunError {
    UnknownValue(serde_json::Value),
}

#[bon::builder]
pub async fn cancel_run(
    configuration: &configuration::Configuration,
    thread_id: &str,
    run_id: &str,
) -> Result<models::RunObject, Error<CancelRunError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_thread_id = thread_id;
    let p_path_run_id = run_id;

    let uri_str = format!(
        "{}/threads/{thread_id}/runs/{run_id}/cancel",
        configuration.base_path,
        thread_id = crate::apis::urlencode(p_path_thread_id),
        run_id = crate::apis::urlencode(p_path_run_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RunObject`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RunObject`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CancelRunError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn create_assistant(
    configuration: &configuration::Configuration,
    create_assistant_request: models::CreateAssistantRequest,
) -> Result<models::AssistantObject, Error<CreateAssistantError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_assistant_request = create_assistant_request;

    let uri_str = format!("{}/assistants", configuration.base_path);
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_create_assistant_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AssistantObject`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AssistantObject`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAssistantError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn create_message(
    configuration: &configuration::Configuration,
    thread_id: &str,
    create_message_request: models::CreateMessageRequest,
) -> Result<models::MessageObject, Error<CreateMessageError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_thread_id = thread_id;
    let p_body_create_message_request = create_message_request;

    let uri_str = format!(
        "{}/threads/{thread_id}/messages",
        configuration.base_path,
        thread_id = crate::apis::urlencode(p_path_thread_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_create_message_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::MessageObject`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::MessageObject`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateMessageError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn create_run(
    configuration: &configuration::Configuration,
    thread_id: &str,
    create_run_request: models::CreateRunRequest,
    include_left_square_bracket_right_square_bracket: Option<Vec<String>>,
) -> Result<models::RunObject, Error<CreateRunError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_thread_id = thread_id;
    let p_body_create_run_request = create_run_request;
    let p_query_include_left_square_bracket_right_square_bracket =
        include_left_square_bracket_right_square_bracket;

    let uri_str = format!(
        "{}/threads/{thread_id}/runs",
        configuration.base_path,
        thread_id = crate::apis::urlencode(p_path_thread_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref param_value) = p_query_include_left_square_bracket_right_square_bracket {
        req_builder = match "multi" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("include[]".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "include[]",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_create_run_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RunObject`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RunObject`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateRunError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn create_thread(
    configuration: &configuration::Configuration,
    create_thread_request: Option<models::CreateThreadRequest>,
) -> Result<models::ThreadObject, Error<CreateThreadError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_thread_request = create_thread_request;

    let uri_str = format!("{}/threads", configuration.base_path);
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_create_thread_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ThreadObject`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ThreadObject`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateThreadError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn create_thread_and_run(
    configuration: &configuration::Configuration,
    create_thread_and_run_request: models::CreateThreadAndRunRequest,
) -> Result<models::RunObject, Error<CreateThreadAndRunError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_thread_and_run_request = create_thread_and_run_request;

    let uri_str = format!("{}/threads/runs", configuration.base_path);
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_create_thread_and_run_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RunObject`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RunObject`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateThreadAndRunError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn delete_assistant(
    configuration: &configuration::Configuration,
    assistant_id: &str,
) -> Result<models::DeleteAssistantResponse, Error<DeleteAssistantError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_assistant_id = assistant_id;

    let uri_str = format!(
        "{}/assistants/{assistant_id}",
        configuration.base_path,
        assistant_id = crate::apis::urlencode(p_path_assistant_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteAssistantResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeleteAssistantResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteAssistantError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn delete_message(
    configuration: &configuration::Configuration,
    thread_id: &str,
    message_id: &str,
) -> Result<models::DeleteMessageResponse, Error<DeleteMessageError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_thread_id = thread_id;
    let p_path_message_id = message_id;

    let uri_str = format!(
        "{}/threads/{thread_id}/messages/{message_id}",
        configuration.base_path,
        thread_id = crate::apis::urlencode(p_path_thread_id),
        message_id = crate::apis::urlencode(p_path_message_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteMessageResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeleteMessageResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteMessageError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn delete_thread(
    configuration: &configuration::Configuration,
    thread_id: &str,
) -> Result<models::DeleteThreadResponse, Error<DeleteThreadError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_thread_id = thread_id;

    let uri_str = format!(
        "{}/threads/{thread_id}",
        configuration.base_path,
        thread_id = crate::apis::urlencode(p_path_thread_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteThreadResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeleteThreadResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteThreadError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn get_assistant(
    configuration: &configuration::Configuration,
    assistant_id: &str,
) -> Result<models::AssistantObject, Error<GetAssistantError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_assistant_id = assistant_id;

    let uri_str = format!(
        "{}/assistants/{assistant_id}",
        configuration.base_path,
        assistant_id = crate::apis::urlencode(p_path_assistant_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AssistantObject`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AssistantObject`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetAssistantError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn get_message(
    configuration: &configuration::Configuration,
    thread_id: &str,
    message_id: &str,
) -> Result<models::MessageObject, Error<GetMessageError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_thread_id = thread_id;
    let p_path_message_id = message_id;

    let uri_str = format!(
        "{}/threads/{thread_id}/messages/{message_id}",
        configuration.base_path,
        thread_id = crate::apis::urlencode(p_path_thread_id),
        message_id = crate::apis::urlencode(p_path_message_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::MessageObject`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::MessageObject`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetMessageError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn get_run(
    configuration: &configuration::Configuration,
    thread_id: &str,
    run_id: &str,
) -> Result<models::RunObject, Error<GetRunError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_thread_id = thread_id;
    let p_path_run_id = run_id;

    let uri_str = format!(
        "{}/threads/{thread_id}/runs/{run_id}",
        configuration.base_path,
        thread_id = crate::apis::urlencode(p_path_thread_id),
        run_id = crate::apis::urlencode(p_path_run_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RunObject`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RunObject`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetRunError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn get_run_step(
    configuration: &configuration::Configuration,
    thread_id: &str,
    run_id: &str,
    step_id: &str,
    include_left_square_bracket_right_square_bracket: Option<Vec<String>>,
) -> Result<models::RunStepObject, Error<GetRunStepError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_thread_id = thread_id;
    let p_path_run_id = run_id;
    let p_path_step_id = step_id;
    let p_query_include_left_square_bracket_right_square_bracket =
        include_left_square_bracket_right_square_bracket;

    let uri_str = format!(
        "{}/threads/{thread_id}/runs/{run_id}/steps/{step_id}",
        configuration.base_path,
        thread_id = crate::apis::urlencode(p_path_thread_id),
        run_id = crate::apis::urlencode(p_path_run_id),
        step_id = crate::apis::urlencode(p_path_step_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_include_left_square_bracket_right_square_bracket {
        req_builder = match "multi" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("include[]".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "include[]",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RunStepObject`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RunStepObject`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetRunStepError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn get_thread(
    configuration: &configuration::Configuration,
    thread_id: &str,
) -> Result<models::ThreadObject, Error<GetThreadError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_thread_id = thread_id;

    let uri_str = format!(
        "{}/threads/{thread_id}",
        configuration.base_path,
        thread_id = crate::apis::urlencode(p_path_thread_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ThreadObject`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ThreadObject`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetThreadError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn list_assistants(
    configuration: &configuration::Configuration,
    limit: Option<i32>,
    order: Option<&str>,
    after: Option<&str>,
    before: Option<&str>,
) -> Result<models::ListAssistantsResponse, Error<ListAssistantsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_limit = limit;
    let p_query_order = order;
    let p_query_after = after;
    let p_query_before = before;

    let uri_str = format!("{}/assistants", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_order {
        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_after {
        req_builder = req_builder.query(&[("after", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_before {
        req_builder = req_builder.query(&[("before", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListAssistantsResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListAssistantsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListAssistantsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn list_messages(
    configuration: &configuration::Configuration,
    thread_id: &str,
    limit: Option<i32>,
    order: Option<&str>,
    after: Option<&str>,
    before: Option<&str>,
    run_id: Option<&str>,
) -> Result<models::ListMessagesResponse, Error<ListMessagesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_thread_id = thread_id;
    let p_query_limit = limit;
    let p_query_order = order;
    let p_query_after = after;
    let p_query_before = before;
    let p_query_run_id = run_id;

    let uri_str = format!(
        "{}/threads/{thread_id}/messages",
        configuration.base_path,
        thread_id = crate::apis::urlencode(p_path_thread_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_order {
        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_after {
        req_builder = req_builder.query(&[("after", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_before {
        req_builder = req_builder.query(&[("before", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_run_id {
        req_builder = req_builder.query(&[("run_id", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListMessagesResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListMessagesResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListMessagesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn list_run_steps(
    configuration: &configuration::Configuration,
    thread_id: &str,
    run_id: &str,
    limit: Option<i32>,
    order: Option<&str>,
    after: Option<&str>,
    before: Option<&str>,
    include_left_square_bracket_right_square_bracket: Option<Vec<String>>,
) -> Result<models::ListRunStepsResponse, Error<ListRunStepsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_thread_id = thread_id;
    let p_path_run_id = run_id;
    let p_query_limit = limit;
    let p_query_order = order;
    let p_query_after = after;
    let p_query_before = before;
    let p_query_include_left_square_bracket_right_square_bracket =
        include_left_square_bracket_right_square_bracket;

    let uri_str = format!(
        "{}/threads/{thread_id}/runs/{run_id}/steps",
        configuration.base_path,
        thread_id = crate::apis::urlencode(p_path_thread_id),
        run_id = crate::apis::urlencode(p_path_run_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_order {
        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_after {
        req_builder = req_builder.query(&[("after", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_before {
        req_builder = req_builder.query(&[("before", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_include_left_square_bracket_right_square_bracket {
        req_builder = match "multi" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("include[]".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "include[]",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListRunStepsResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListRunStepsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListRunStepsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn list_runs(
    configuration: &configuration::Configuration,
    thread_id: &str,
    limit: Option<i32>,
    order: Option<&str>,
    after: Option<&str>,
    before: Option<&str>,
) -> Result<models::ListRunsResponse, Error<ListRunsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_thread_id = thread_id;
    let p_query_limit = limit;
    let p_query_order = order;
    let p_query_after = after;
    let p_query_before = before;

    let uri_str = format!(
        "{}/threads/{thread_id}/runs",
        configuration.base_path,
        thread_id = crate::apis::urlencode(p_path_thread_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_order {
        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_after {
        req_builder = req_builder.query(&[("after", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_before {
        req_builder = req_builder.query(&[("before", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListRunsResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListRunsResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListRunsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn modify_assistant(
    configuration: &configuration::Configuration,
    assistant_id: &str,
    modify_assistant_request: models::ModifyAssistantRequest,
) -> Result<models::AssistantObject, Error<ModifyAssistantError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_assistant_id = assistant_id;
    let p_body_modify_assistant_request = modify_assistant_request;

    let uri_str = format!(
        "{}/assistants/{assistant_id}",
        configuration.base_path,
        assistant_id = crate::apis::urlencode(p_path_assistant_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_modify_assistant_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AssistantObject`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AssistantObject`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ModifyAssistantError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn modify_message(
    configuration: &configuration::Configuration,
    thread_id: &str,
    message_id: &str,
    modify_message_request: models::ModifyMessageRequest,
) -> Result<models::MessageObject, Error<ModifyMessageError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_thread_id = thread_id;
    let p_path_message_id = message_id;
    let p_body_modify_message_request = modify_message_request;

    let uri_str = format!(
        "{}/threads/{thread_id}/messages/{message_id}",
        configuration.base_path,
        thread_id = crate::apis::urlencode(p_path_thread_id),
        message_id = crate::apis::urlencode(p_path_message_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_modify_message_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::MessageObject`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::MessageObject`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ModifyMessageError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn modify_run(
    configuration: &configuration::Configuration,
    thread_id: &str,
    run_id: &str,
    modify_run_request: models::ModifyRunRequest,
) -> Result<models::RunObject, Error<ModifyRunError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_thread_id = thread_id;
    let p_path_run_id = run_id;
    let p_body_modify_run_request = modify_run_request;

    let uri_str = format!(
        "{}/threads/{thread_id}/runs/{run_id}",
        configuration.base_path,
        thread_id = crate::apis::urlencode(p_path_thread_id),
        run_id = crate::apis::urlencode(p_path_run_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_modify_run_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RunObject`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RunObject`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ModifyRunError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn modify_thread(
    configuration: &configuration::Configuration,
    thread_id: &str,
    modify_thread_request: models::ModifyThreadRequest,
) -> Result<models::ThreadObject, Error<ModifyThreadError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_thread_id = thread_id;
    let p_body_modify_thread_request = modify_thread_request;

    let uri_str = format!(
        "{}/threads/{thread_id}",
        configuration.base_path,
        thread_id = crate::apis::urlencode(p_path_thread_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_modify_thread_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ThreadObject`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ThreadObject`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ModifyThreadError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

#[bon::builder]
pub async fn submit_tool_ouputs_to_run(
    configuration: &configuration::Configuration,
    thread_id: &str,
    run_id: &str,
    submit_tool_outputs_run_request: models::SubmitToolOutputsRunRequest,
) -> Result<models::RunObject, Error<SubmitToolOuputsToRunError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_thread_id = thread_id;
    let p_path_run_id = run_id;
    let p_body_submit_tool_outputs_run_request = submit_tool_outputs_run_request;

    let uri_str = format!(
        "{}/threads/{thread_id}/runs/{run_id}/submit_tool_outputs",
        configuration.base_path,
        thread_id = crate::apis::urlencode(p_path_thread_id),
        run_id = crate::apis::urlencode(p_path_run_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_submit_tool_outputs_run_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RunObject`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RunObject`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<SubmitToolOuputsToRunError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}