openai-client-base 0.16.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 [`accept_live_session`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AcceptLiveSessionError {
    Status400(models::ErrorResponse),
    Status404(models::ErrorResponse),
    Status409(models::ErrorResponse),
    Status429(models::ErrorResponse),
    Status500(String),
    Status503(models::ErrorResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`create_live`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateLiveError {
    Status400(models::ErrorResponse),
    Status413(models::ErrorResponse),
    Status429(models::ErrorResponse),
    Status500(String),
    Status502(String),
    Status503(models::ErrorResponse),
    Status504(models::ErrorResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`download_live_recording`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DownloadLiveRecordingError {
    Status400(models::ErrorResponse),
    Status404(models::ErrorResponse),
    Status429(models::ErrorResponse),
    Status500(models::ErrorResponse),
    Status503(models::ErrorResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`fork_live_session`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ForkLiveSessionError {
    Status400(models::ErrorResponse),
    Status404(String),
    Status413(models::ErrorResponse),
    Status429(models::ErrorResponse),
    Status500(String),
    Status503(models::ErrorResponse),
    UnknownValue(serde_json::Value),
}

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

/// struct for typed errors of method [`refer_live_session`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReferLiveSessionError {
    Status400(models::ErrorResponse),
    Status404(models::ErrorResponse),
    Status500(String),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`reject_live_session`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RejectLiveSessionError {
    Status400(models::ErrorResponse),
    Status404(models::ErrorResponse),
    Status409(models::ErrorResponse),
    Status500(String),
    UnknownValue(serde_json::Value),
}

/// Accept an incoming SIP call. Supply session with type live, the model, and startup configuration. Before accepting calls, follow the [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting) to write frontend conversation instructions and a separate backend prompt. SIP media format is negotiated; omit audio.format.
#[bon::builder]
pub async fn accept_live_session(
    configuration: &configuration::Configuration,
    session_id: &str,
    live_call_accept_request: models::LiveCallAcceptRequest,
) -> Result<(), Error<AcceptLiveSessionError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_session_id = session_id;
    let p_body_live_call_accept_request = live_call_accept_request;

    let uri_str = format!(
        "{}/live/sessions/{session_id}/accept",
        configuration.base_path,
        session_id = crate::apis::urlencode(p_path_session_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_live_call_accept_request);

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

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<AcceptLiveSessionError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Create a Live WebRTC session or place an outbound SIP call. Start with the [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting) for session configuration and [Telephony and SIP](https://developers.openai.com/api/docs/guides/voice-sip?api=live#place-an-outbound-call) for trunk setup and call monitoring.  Set transport.type to `webrtc` and supply an SDP offer, or set it to `sip` and supply an E.164 destination and trunk credentials. Outbound SIP calling must be enabled for your organization. Ringing is limited to 3 minutes and connected calls to 2 hours; these limits are not configurable in the request.  Returns `201 Created` after session initialization. WebRTC responses include an SDP answer. SIP responses do not wait for the callee to answer. Attach a sideband connection using session.id to monitor SIP call progress.  Each SIP request creates a new call. If a request times out or the connection fails, retry with caution: the original request may have succeeded, and a retry can place another call.
#[bon::builder]
pub async fn create_live(
    configuration: &configuration::Configuration,
    live_session_create_request: models::LiveSessionCreateRequest,
) -> Result<models::LiveSessionCreateResponse, Error<CreateLiveError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_live_session_create_request = live_session_create_request;

    let uri_str = format!("{}/live/sessions", 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_live_session_create_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::LiveSessionCreateResponse`"))),
            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::LiveSessionCreateResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateLiveError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Get Live session content
#[bon::builder]
pub async fn download_live_recording(
    configuration: &configuration::Configuration,
    session_id: &str,
) -> Result<reqwest::Response, Error<DownloadLiveRecordingError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_session_id = session_id;

    let uri_str = format!(
        "{}/live/sessions/{session_id}/content",
        configuration.base_path,
        session_id = crate::apis::urlencode(p_path_session_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();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(resp)
    } else {
        let content = resp.text().await?;
        let entity: Option<DownloadLiveRecordingError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Fork a stored Live session onto a new WebRTC connection.
#[bon::builder]
pub async fn fork_live_session(
    configuration: &configuration::Configuration,
    session_id: &str,
    live_fork_request: models::LiveForkRequest,
) -> Result<models::LiveCreateResponse, Error<ForkLiveSessionError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_session_id = session_id;
    let p_body_live_fork_request = live_fork_request;

    let uri_str = format!(
        "{}/live/sessions/{session_id}/fork",
        configuration.base_path,
        session_id = crate::apis::urlencode(p_path_session_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_live_fork_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::LiveCreateResponse`"))),
            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::LiveCreateResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ForkLiveSessionError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// End a SIP call identified by session_id.
#[bon::builder]
pub async fn hangup_live_session(
    configuration: &configuration::Configuration,
    session_id: &str,
) -> Result<(), Error<HangupLiveSessionError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_session_id = session_id;

    let uri_str = format!(
        "{}/live/sessions/{session_id}/hangup",
        configuration.base_path,
        session_id = crate::apis::urlencode(p_path_session_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();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<HangupLiveSessionError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Transfer a SIP call to another destination. Supply a nonblank target_uri for the SIP Refer-To header.
#[bon::builder]
pub async fn refer_live_session(
    configuration: &configuration::Configuration,
    session_id: &str,
    live_call_refer_request: models::LiveCallReferRequest,
) -> Result<(), Error<ReferLiveSessionError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_session_id = session_id;
    let p_body_live_call_refer_request = live_call_refer_request;

    let uri_str = format!(
        "{}/live/sessions/{session_id}/refer",
        configuration.base_path,
        session_id = crate::apis::urlencode(p_path_session_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_live_call_refer_request);

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

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<ReferLiveSessionError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}

/// Reject an incoming SIP call. Send a required SIP rejection status_code between 300 and 699.
#[bon::builder]
pub async fn reject_live_session(
    configuration: &configuration::Configuration,
    session_id: &str,
    live_call_reject_request: models::LiveCallRejectRequest,
) -> Result<(), Error<RejectLiveSessionError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_session_id = session_id;
    let p_body_live_call_reject_request = live_call_reject_request;

    let uri_str = format!(
        "{}/live/sessions/{session_id}/reject",
        configuration.base_path,
        session_id = crate::apis::urlencode(p_path_session_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_live_call_reject_request);

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

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<RejectLiveSessionError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(Box::new(ResponseContent {
            status,
            content,
            entity,
        })))
    }
}