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