uarp-sdk 0.5.7

// Code generated by @uarp/codegen from spec/openapi.json. DO NOT EDIT.
//!
//! Agent CRUD and versioning

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

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

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::pagination::CursorGuard;
use crate::util::encode_path;

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

/// Query and header parameters for `getAgentSystemCard`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAgentSystemCardParams {
    /// Output format (default: json)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub format: Option<models::GetAgentSystemCardFormat>,
}

/// Query and header parameters for `getAgentVersionDiff`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAgentVersionDiffParams {
    /// Version number to compare against (defaults to versionNum-1)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub compare_to: Option<i64>,
}

/// Query and header parameters for `listAgents`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAgentsParams {
    /// Filter by workspace
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub workspace_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Opaque pagination cursor returned by previous page response. Use `has_more` to detect if
    /// more pages exist.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    /// Include bridge agents whose Snaga CLI is not currently `serve`-ing. By default offline
    /// ghosts are hidden from main pickers.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub include_offline: Option<bool>,
}

/// Agent CRUD and versioning
#[derive(Debug, Clone)]
pub struct AgentsApi {
    pub(crate) client: Client,
}

impl Client {
    /// Agent CRUD and versioning
    pub fn agents(&self) -> AgentsApi {
        AgentsApi { client: self.clone() }
    }
}

impl AgentsApi {
    /// Activate agent
    ///
    /// `POST /api/v1/agents/{agentId}/activate`
    ///
    /// Required scopes: `agents:write`.
    pub async fn activate_agent(&self, agent_id: &str) -> Result<serde_json::Map<String, serde_json::Value>> {
        self.client
            .request_json(Request {
                method: Method::POST,
                path: format!("/api/v1/agents/{}/activate", encode_path(agent_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

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

    /// Create or update FRIA report
    ///
    /// `POST /api/v1/agents/{agentId}/fria`
    ///
    /// Required scopes: `agents:write`.
    pub async fn create_agent_fria(&self, agent_id: &str, body: &models::CreateAgentFriaRequest) -> Result<serde_json::Map<String, serde_json::Value>> {
        self.client
            .request_json(Request {
                method: Method::POST,
                path: format!("/api/v1/agents/{}/fria", encode_path(agent_id)),
                query: NO_QUERY,
                body: Some(body),
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

    /// Create a version snapshot of an agent
    ///
    /// `POST /api/v1/agents/{agentId}/versions`
    ///
    /// Required scopes: `agents:write`.
    pub async fn create_agent_version(&self, agent_id: &str, body: &models::CreateAgentVersionRequest) -> Result<serde_json::Value> {
        self.client
            .request_json(Request {
                method: Method::POST,
                path: format!("/api/v1/agents/{}/versions", encode_path(agent_id)),
                query: NO_QUERY,
                body: Some(body),
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

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

    /// Delete agent identity
    ///
    /// `DELETE /api/v1/agents/{agentId}/identity`
    ///
    /// Required scopes: `agents:write`.
    pub async fn delete_agent_identity(&self, agent_id: &str) -> Result<()> {
        self.client
            .request_empty(Request {
                method: Method::DELETE,
                path: format!("/api/v1/agents/{}/identity", encode_path(agent_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

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

    /// Get agent activity stats
    ///
    /// `GET /api/v1/agents/{agentId}/activity-stats`
    ///
    /// Required scopes: `agents:read`.
    pub async fn get_agent_activity_stats(&self, agent_id: &str, params: &GetAgentActivityStatsParams) -> Result<models::GetAgentActivityStatsResponse> {
        self.client
            .request_json(Request {
                method: Method::GET,
                path: format!("/api/v1/agents/{}/activity-stats", encode_path(agent_id)),
                query: Some(params),
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: false,
            })
            .await
    }

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

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

    /// Get agent identity (public key)
    ///
    /// `GET /api/v1/agents/{agentId}/identity`
    ///
    /// Required scopes: `agents:read`.
    pub async fn get_agent_identity(&self, agent_id: &str) -> Result<models::GetAgentIdentityResponse> {
        self.client
            .request_json(Request {
                method: Method::GET,
                path: format!("/api/v1/agents/{}/identity", encode_path(agent_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: false,
            })
            .await
    }

    /// Read the EU AI Act risk classification
    ///
    /// `GET /api/v1/agents/{agentId}/risk-classification`
    ///
    /// Required scopes: `agents:read`.
    pub async fn get_agent_risk_classification(&self, agent_id: &str) -> Result<models::RiskClassification> {
        self.client
            .request_json(Request {
                method: Method::GET,
                path: format!("/api/v1/agents/{}/risk-classification", encode_path(agent_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: false,
            })
            .await
    }

    /// Get EU AI Act Annex IV system card
    ///
    /// `GET /api/v1/agents/{agentId}/system-card`
    ///
    /// Required scopes: `agents:read`.
    pub async fn get_agent_system_card(&self, agent_id: &str, params: &GetAgentSystemCardParams) -> Result<serde_json::Map<String, serde_json::Value>> {
        self.client
            .request_json(Request {
                method: Method::GET,
                path: format!("/api/v1/agents/{}/system-card", encode_path(agent_id)),
                query: Some(params),
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: false,
            })
            .await
    }

    /// Get traffic split configuration
    ///
    /// `GET /api/v1/agents/{agentId}/traffic`
    ///
    /// Required scopes: `agents:read`.
    pub async fn get_agent_traffic(&self, agent_id: &str) -> Result<models::GetAgentTrafficResponse> {
        self.client
            .request_json(Request {
                method: Method::GET,
                path: format!("/api/v1/agents/{}/traffic", encode_path(agent_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: false,
            })
            .await
    }

    /// Diff between two agent versions
    ///
    /// `GET /api/v1/agents/{agentId}/versions/{versionNum}/diff`
    ///
    /// Required scopes: `agents:read`.
    pub async fn get_agent_version_diff(&self, agent_id: &str, version_num: i64, params: &GetAgentVersionDiffParams) -> Result<models::GetAgentVersionDiffResponse> {
        self.client
            .request_json(Request {
                method: Method::GET,
                path: format!("/api/v1/agents/{}/versions/{}/diff", encode_path(agent_id), encode_path(&version_num.to_string())),
                query: Some(params),
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: false,
            })
            .await
    }

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

    /// Stream every item returned by `listAgents`, following the `cursor` cursor until the server
    /// reports no further pages.
    pub fn list_all<'a>(&'a self, params: &'a ListAgentsParams) -> impl Stream<Item = Result<models::Agent>> + 'a {
        async_stream::try_stream! {
            let mut guard = CursorGuard::new();
            let mut cursor = params.cursor.clone();
            loop {
                let mut page_params = params.clone();
                page_params.cursor = cursor.clone();
                let page = self.list(&page_params).await?;
                let items = page.items;
                let was_empty = items.is_empty();
                for item in items {
                    yield item;
                }
                match guard.advance(page.cursor, Some(page.has_more), was_empty) {
                    Some(next) => cursor = Some(next),
                    None => break,
                }
            }
        }
    }

    /// List version snapshots for an agent
    ///
    /// Returns the ordered version history for an agent. Lazily creates v1 from the current config
    /// if no versions exist yet.
    ///
    /// `GET /api/v1/agents/{agentId}/versions`
    ///
    /// Required scopes: `agents:read`.
    pub async fn list_agent_versions(&self, agent_id: &str) -> Result<models::ListAgentVersionsResponse> {
        self.client
            .request_json(Request {
                method: Method::GET,
                path: format!("/api/v1/agents/{}/versions", encode_path(agent_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: false,
            })
            .await
    }

    /// Partial update agent
    ///
    /// `PATCH /api/v1/agents/{agentId}`
    ///
    /// Required scopes: `agents:write`.
    pub async fn patch(&self, agent_id: &str, body: &serde_json::Map<String, serde_json::Value>) -> Result<models::Agent> {
        self.client
            .request_json(Request {
                method: Method::PATCH,
                path: format!("/api/v1/agents/{}", encode_path(agent_id)),
                query: NO_QUERY,
                body: Some(body),
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

    /// Rollback an agent to a previous version
    ///
    /// `POST /api/v1/agents/{agentId}/rollback`
    ///
    /// Required scopes: `agents:write`.
    pub async fn rollback_agent(&self, agent_id: &str, body: &models::RollbackAgentRequest) -> Result<serde_json::Value> {
        self.client
            .request_json(Request {
                method: Method::POST,
                path: format!("/api/v1/agents/{}/rollback", encode_path(agent_id)),
                query: NO_QUERY,
                body: Some(body),
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

    /// Rotate agent identity
    ///
    /// `POST /api/v1/agents/{agentId}/identity/rotate`
    ///
    /// Required scopes: `agents:write`.
    pub async fn rotate_agent_identity(&self, agent_id: &str) -> Result<models::RotateAgentIdentityResponse> {
        self.client
            .request_json(Request {
                method: Method::POST,
                path: format!("/api/v1/agents/{}/identity/rotate", encode_path(agent_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

    /// Set agent capabilities
    ///
    /// `PUT /api/v1/agents/{agentId}/capabilities`
    ///
    /// Required scopes: `agents:write`.
    pub async fn set_agent_capabilities(&self, agent_id: &str, body: &serde_json::Map<String, serde_json::Value>) -> Result<models::SetAgentCapabilitiesResponse> {
        self.client
            .request_json(Request {
                method: Method::PUT,
                path: format!("/api/v1/agents/{}/capabilities", encode_path(agent_id)),
                query: NO_QUERY,
                body: Some(body),
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

    /// Set traffic split configuration
    ///
    /// `PUT /api/v1/agents/{agentId}/traffic`
    ///
    /// Required scopes: `agents:write`.
    pub async fn set_agent_traffic(&self, agent_id: &str, body: &models::SetAgentTrafficRequest) -> Result<serde_json::Map<String, serde_json::Value>> {
        self.client
            .request_json(Request {
                method: Method::PUT,
                path: format!("/api/v1/agents/{}/traffic", encode_path(agent_id)),
                query: NO_QUERY,
                body: Some(body),
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

    /// Suspend agent
    ///
    /// `POST /api/v1/agents/{agentId}/suspend`
    ///
    /// Required scopes: `agents:write`.
    pub async fn suspend_agent(&self, agent_id: &str, body: &models::SuspendAgentRequest) -> Result<serde_json::Map<String, serde_json::Value>> {
        self.client
            .request_json(Request {
                method: Method::POST,
                path: format!("/api/v1/agents/{}/suspend", encode_path(agent_id)),
                query: NO_QUERY,
                body: Some(body),
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

    /// Terminate/delete agent
    ///
    /// `POST /api/v1/agents/{agentId}/terminate`
    ///
    /// Required scopes: `agents:write`.
    pub async fn terminate_agent(&self, agent_id: &str) -> Result<models::TerminateAgentResponse> {
        self.client
            .request_json(Request {
                method: Method::POST,
                path: format!("/api/v1/agents/{}/terminate", encode_path(agent_id)),
                query: NO_QUERY,
                body: NO_BODY,
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }

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

    /// Update EU AI Act risk classification (admin only)
    ///
    /// `PATCH /api/v1/agents/{agentId}/risk-classification`
    ///
    /// Required scopes: `agents:write`.
    pub async fn update_agent_risk_classification(&self, agent_id: &str, body: &models::RiskClassificationUpdate) -> Result<serde_json::Map<String, serde_json::Value>> {
        self.client
            .request_json(Request {
                method: Method::PATCH,
                path: format!("/api/v1/agents/{}/risk-classification", encode_path(agent_id)),
                query: NO_QUERY,
                body: Some(body),
                headers: Vec::new(),
                idempotent: true,
            })
            .await
    }
}