uarp-sdk 0.5.7

// Code generated by @uarp/codegen from spec/openapi.json. DO NOT EDIT.
//!
//! Team management and team chat

#![allow(unused_imports, clippy::too_many_arguments)]

use reqwest::Method;
use serde::{Deserialize, Serialize};

use crate::client::{Client, Request, NO_BODY, NO_QUERY};
use crate::error::Result;
use crate::generated::models;
use crate::multipart::{field_text, FilePart};
use crate::sse::EventStream;
use crate::util::encode_path;

/// Query and header parameters for `getTeamChatHistory`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetTeamChatHistoryParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub thread_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub include_internal: Option<bool>,
}

/// Query and header parameters for `streamTeamChatEvents`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct StreamTeamChatEventsParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub thread_id: Option<String>,
}

/// Team management and team chat
#[derive(Debug, Clone)]
pub struct TeamsApi {
    pub(crate) client: Client,
}

impl Client {
    /// Team management and team chat
    pub fn teams(&self) -> TeamsApi {
        TeamsApi { client: self.clone() }
    }
}

impl TeamsApi {
    /// Add graph edge
    ///
    /// `POST /api/v1/teams/{teamId}/graph/edges`
    ///
    /// Required scopes: `agents:write`.
    pub async fn add_team_graph_edge(&self, team_id: &str, body: &models::AddTeamGraphEdgeRequest) -> Result<serde_json::Map<String, serde_json::Value>> {
        self.client
            .request_json(Request {
                method: Method::POST,
                path: format!("/api/v1/teams/{}/graph/edges", encode_path(team_id)),
                query: NO_QUERY,
                body: Some(body),
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

    /// Add graph node
    ///
    /// `POST /api/v1/teams/{teamId}/graph/nodes`
    ///
    /// Required scopes: `agents:write`.
    pub async fn add_team_graph_node(&self, team_id: &str, body: &models::AddTeamGraphNodeRequest) -> Result<serde_json::Map<String, serde_json::Value>> {
        self.client
            .request_json(Request {
                method: Method::POST,
                path: format!("/api/v1/teams/{}/graph/nodes", encode_path(team_id)),
                query: NO_QUERY,
                body: Some(body),
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

    /// Create a team
    ///
    /// `POST /api/v1/teams`
    ///
    /// Required scopes: `agents:write`.
    pub async fn create(&self, body: &models::TeamCreate) -> Result<models::Team> {
        self.client
            .request_json(Request {
                method: Method::POST,
                path: "/api/v1/teams".to_string(),
                query: NO_QUERY,
                body: Some(body),
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

    /// Delete team
    ///
    /// `DELETE /api/v1/teams/{teamId}`
    ///
    /// Required scopes: `agents:write`.
    pub async fn delete(&self, team_id: &str) -> Result<models::DeleteTeamResponse> {
        self.client
            .request_json(Request {
                method: Method::DELETE,
                path: format!("/api/v1/teams/{}", encode_path(team_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

    /// Remove edge
    ///
    /// `DELETE /api/v1/teams/{teamId}/graph/edges/{edgeId}`
    ///
    /// Required scopes: `agents:write`.
    pub async fn delete_team_graph_edge(&self, team_id: &str, edge_id: &str) -> Result<models::DeleteTeamGraphEdgeResponse> {
        self.client
            .request_json(Request {
                method: Method::DELETE,
                path: format!("/api/v1/teams/{}/graph/edges/{}", encode_path(team_id), encode_path(edge_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

    /// Remove node
    ///
    /// `DELETE /api/v1/teams/{teamId}/graph/nodes/{agentId}`
    ///
    /// Required scopes: `agents:write`.
    pub async fn delete_team_graph_node(&self, team_id: &str, agent_id: &str) -> Result<models::DeleteTeamGraphNodeResponse> {
        self.client
            .request_json(Request {
                method: Method::DELETE,
                path: format!("/api/v1/teams/{}/graph/nodes/{}", encode_path(team_id), encode_path(agent_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

    /// Get team
    ///
    /// `GET /api/v1/teams/{teamId}`
    ///
    /// Required scopes: `agents:read`.
    pub async fn get(&self, team_id: &str) -> Result<models::Team> {
        self.client
            .request_json(Request {
                method: Method::GET,
                path: format!("/api/v1/teams/{}", encode_path(team_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: false,
            })
            .await
    }

    /// Get team chat history
    ///
    /// `GET /api/v1/teams/{teamId}/chat`
    ///
    /// Required scopes: `agents:read`.
    pub async fn get_team_chat_history(&self, team_id: &str, params: &GetTeamChatHistoryParams) -> Result<models::GetTeamChatHistoryResponse> {
        self.client
            .request_json(Request {
                method: Method::GET,
                path: format!("/api/v1/teams/{}/chat", encode_path(team_id)),
                query: Some(params),
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: false,
            })
            .await
    }

    /// Get full team graph
    ///
    /// `GET /api/v1/teams/{teamId}/graph`
    ///
    /// Required scopes: `agents:read`.
    pub async fn get_team_graph(&self, team_id: &str) -> Result<models::GetTeamGraphResponse> {
        self.client
            .request_json(Request {
                method: Method::GET,
                path: format!("/api/v1/teams/{}/graph", encode_path(team_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: false,
            })
            .await
    }

    /// Get graph node
    ///
    /// `GET /api/v1/teams/{teamId}/graph/nodes/{agentId}`
    ///
    /// Required scopes: `agents:read`.
    pub async fn get_team_graph_node(&self, team_id: &str, agent_id: &str) -> Result<serde_json::Map<String, serde_json::Value>> {
        self.client
            .request_json(Request {
                method: Method::GET,
                path: format!("/api/v1/teams/{}/graph/nodes/{}", encode_path(team_id), encode_path(agent_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: false,
            })
            .await
    }

    /// Get specific team run
    ///
    /// `GET /api/v1/teams/{teamId}/runs/{teamRunId}`
    ///
    /// Required scopes: `agents:read`.
    pub async fn get_team_run(&self, team_id: &str, team_run_id: &str) -> Result<serde_json::Map<String, serde_json::Value>> {
        self.client
            .request_json(Request {
                method: Method::GET,
                path: format!("/api/v1/teams/{}/runs/{}", encode_path(team_id), encode_path(team_run_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: false,
            })
            .await
    }

    /// Get team run messages
    ///
    /// `GET /api/v1/teams/{teamId}/runs/{teamRunId}/messages`
    ///
    /// Required scopes: `agents:read`.
    pub async fn get_team_run_messages(&self, team_id: &str, team_run_id: &str) -> Result<models::GetTeamRunMessagesResponse> {
        self.client
            .request_json(Request {
                method: Method::GET,
                path: format!("/api/v1/teams/{}/runs/{}/messages", encode_path(team_id), encode_path(team_run_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: false,
            })
            .await
    }

    /// List teams
    ///
    /// `GET /api/v1/teams`
    ///
    /// Required scopes: `agents:read`.
    pub async fn list(&self) -> Result<models::ListTeamsResponse> {
        self.client
            .request_json(Request {
                method: Method::GET,
                path: "/api/v1/teams".to_string(),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: false,
            })
            .await
    }

    /// List graph edges
    ///
    /// `GET /api/v1/teams/{teamId}/graph/edges`
    ///
    /// Required scopes: `agents:read`.
    pub async fn list_team_graph_edges(&self, team_id: &str) -> Result<models::ListTeamGraphEdgesResponse> {
        self.client
            .request_json(Request {
                method: Method::GET,
                path: format!("/api/v1/teams/{}/graph/edges", encode_path(team_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: false,
            })
            .await
    }

    /// List graph nodes
    ///
    /// `GET /api/v1/teams/{teamId}/graph/nodes`
    ///
    /// Required scopes: `agents:read`.
    pub async fn list_team_graph_nodes(&self, team_id: &str) -> Result<models::ListTeamGraphNodesResponse> {
        self.client
            .request_json(Request {
                method: Method::GET,
                path: format!("/api/v1/teams/{}/graph/nodes", encode_path(team_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: false,
            })
            .await
    }

    /// List runs for a team
    ///
    /// `GET /api/v1/teams/{teamId}/runs`
    ///
    /// Required scopes: `agents:read`.
    pub async fn list_team_runs(&self, team_id: &str) -> Result<models::ListTeamRunsResponse> {
        self.client
            .request_json(Request {
                method: Method::GET,
                path: format!("/api/v1/teams/{}/runs", encode_path(team_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: false,
            })
            .await
    }

    /// Start a team run
    ///
    /// `POST /api/v1/teams/{teamId}/runs`
    ///
    /// Required scopes: `agents:write`.
    pub async fn start_team_run(&self, team_id: &str, body: &models::StartTeamRunRequest) -> Result<serde_json::Map<String, serde_json::Value>> {
        self.client
            .request_json(Request {
                method: Method::POST,
                path: format!("/api/v1/teams/{}/runs", encode_path(team_id)),
                query: NO_QUERY,
                body: Some(body),
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

    /// SSE stream for team chat
    ///
    /// `GET /api/v1/teams/{teamId}/chat/events`
    ///
    /// Required scopes: `agents:read`.
    ///
    /// Returns a server-sent event stream.
    pub fn stream_team_chat_events(&self, team_id: &str, params: &StreamTeamChatEventsParams) -> EventStream {
        self.client.request_stream(
            &format!("/api/v1/teams/{}/chat/events", encode_path(team_id)),
            Some(params),
            Vec::new(),
        )
    }

    /// Stream team run events (SSE)
    ///
    /// `GET /api/v1/teams/{teamId}/runs/{runId}/events`
    ///
    /// Required scopes: `agents:read`.
    ///
    /// Returns a server-sent event stream.
    pub fn stream_team_run_events(&self, team_id: &str, run_id: &str) -> EventStream {
        self.client.request_stream(
            &format!("/api/v1/teams/{}/runs/{}/events", encode_path(team_id), encode_path(run_id)),
            NO_QUERY,
            Vec::new(),
        )
    }

    /// Update team
    ///
    /// `PUT /api/v1/teams/{teamId}`
    ///
    /// Required scopes: `agents:write`.
    pub async fn update(&self, team_id: &str, body: &models::TeamUpdate) -> Result<models::Team> {
        self.client
            .request_json(Request {
                method: Method::PUT,
                path: format!("/api/v1/teams/{}", encode_path(team_id)),
                query: NO_QUERY,
                body: Some(body),
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

    /// Update graph node
    ///
    /// `PATCH /api/v1/teams/{teamId}/graph/nodes/{agentId}`
    ///
    /// Required scopes: `agents:write`.
    pub async fn update_team_graph_node(&self, team_id: &str, agent_id: &str, body: &models::UpdateTeamGraphNodeRequest) -> Result<serde_json::Map<String, serde_json::Value>> {
        self.client
            .request_json(Request {
                method: Method::PATCH,
                path: format!("/api/v1/teams/{}/graph/nodes/{}", encode_path(team_id), encode_path(agent_id)),
                query: NO_QUERY,
                body: Some(body),
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }
}