Skip to main content

unitycatalog_client/codegen/agent_skills/
client.rs

1// @generated — do not edit by hand.
2#![allow(unused_imports)]
3use crate::Result;
4#[cfg(not(target_arch = "wasm32"))]
5use ::olai_http::CloudClient as Transport;
6#[cfg(target_arch = "wasm32")]
7use ::olai_http_wasm::WasmClient as Transport;
8use unitycatalog_common::models::agent_skills::v0alpha1::*;
9use url::Url;
10/// HTTP client for service operations
11#[derive(Clone)]
12pub struct AgentSkillServiceClient {
13    pub(crate) client: Transport,
14    pub(crate) base_url: Url,
15}
16impl AgentSkillServiceClient {
17    /// Create a new client instance
18    pub fn new(client: Transport, mut base_url: Url) -> Self {
19        if !base_url.path().ends_with('/') {
20            base_url.set_path(&format!("{}/", base_url.path()));
21        }
22        Self { client, base_url }
23    }
24    /// Lists agent skills.
25    pub async fn list_agent_skills(
26        &self,
27        request: &ListAgentSkillsRequest,
28    ) -> Result<ListAgentSkillsResponse> {
29        let mut url = self.base_url.join("agent-skills")?;
30        url.query_pairs_mut()
31            .append_pair("catalog_name", &request.catalog_name);
32        url.query_pairs_mut()
33            .append_pair("schema_name", &request.schema_name);
34        if let Some(ref value) = request.max_results {
35            url.query_pairs_mut()
36                .append_pair("max_results", &value.to_string());
37        }
38        if let Some(ref value) = request.page_token {
39            url.query_pairs_mut()
40                .append_pair("page_token", &value.to_string());
41        }
42        if let Some(ref value) = request.include_browse {
43            url.query_pairs_mut()
44                .append_pair("include_browse", &value.to_string());
45        }
46        let response = self.client.get(url).send().await?;
47        if !response.status().is_success() {
48            return Err(crate::error::parse_error_response(response).await);
49        }
50        let result = response.bytes().await?;
51        Ok(serde_json::from_slice(&result)?)
52    }
53    pub async fn create_agent_skill(
54        &self,
55        request: &CreateAgentSkillRequest,
56    ) -> Result<AgentSkill> {
57        let url = self.base_url.join("agent-skills")?;
58        let response = self.client.post(url).json(request).send().await?;
59        if !response.status().is_success() {
60            return Err(crate::error::parse_error_response(response).await);
61        }
62        let result = response.bytes().await?;
63        Ok(serde_json::from_slice(&result)?)
64    }
65    pub async fn get_agent_skill(&self, request: &GetAgentSkillRequest) -> Result<AgentSkill> {
66        let formatted_path = format!("agent-skills/{}", request.name);
67        let mut url = self.base_url.join(&formatted_path)?;
68        if let Some(ref value) = request.include_browse {
69            url.query_pairs_mut()
70                .append_pair("include_browse", &value.to_string());
71        }
72        let response = self.client.get(url).send().await?;
73        if !response.status().is_success() {
74            return Err(crate::error::parse_error_response(response).await);
75        }
76        let result = response.bytes().await?;
77        Ok(serde_json::from_slice(&result)?)
78    }
79    pub async fn update_agent_skill(
80        &self,
81        request: &UpdateAgentSkillRequest,
82    ) -> Result<AgentSkill> {
83        let formatted_path = format!("agent-skills/{}", request.name);
84        let url = self.base_url.join(&formatted_path)?;
85        let response = self.client.patch(url).json(request).send().await?;
86        if !response.status().is_success() {
87            return Err(crate::error::parse_error_response(response).await);
88        }
89        let result = response.bytes().await?;
90        Ok(serde_json::from_slice(&result)?)
91    }
92    pub async fn delete_agent_skill(&self, request: &DeleteAgentSkillRequest) -> Result<()> {
93        let formatted_path = format!("agent-skills/{}", request.name);
94        let url = self.base_url.join(&formatted_path)?;
95        let response = self.client.delete(url).send().await?;
96        if !response.status().is_success() {
97            return Err(crate::error::parse_error_response(response).await);
98        }
99        Ok(())
100    }
101}