Skip to main content

async_openai/skills/
skills_.rs

1use bytes::Bytes;
2
3use crate::{
4    config::Config,
5    error::OpenAIError,
6    types::skills::{
7        CreateSkillRequest, DeletedSkillResource, SetDefaultSkillVersionRequest, SkillListResource,
8        SkillResource,
9    },
10    Client, RequestOptions, SkillVersions,
11};
12
13pub struct Skills<'c, C: Config> {
14    client: &'c Client<C>,
15    pub(crate) request_options: RequestOptions,
16}
17
18impl<'c, C: Config> Skills<'c, C> {
19    pub fn new(client: &'c Client<C>) -> Self {
20        Self {
21            client,
22            request_options: RequestOptions::new(),
23        }
24    }
25
26    /// [SkillVersions] API group
27    pub fn versions(&self, skill_id: &str) -> SkillVersions<'_, C> {
28        SkillVersions::new(self.client, skill_id)
29    }
30
31    /// Create a new skill by uploading files.
32    #[crate::byot(
33        T0 = Clone,
34        R = serde::de::DeserializeOwned,
35        where_clause = "reqwest::multipart::Form: crate::traits::AsyncTryFrom<T0, Error = OpenAIError>",
36    )]
37    pub async fn create(&self, request: CreateSkillRequest) -> Result<SkillResource, OpenAIError> {
38        self.client
39            .post_form("/skills", request, &self.request_options)
40            .await
41    }
42
43    /// List all skills.
44    #[crate::byot(R = serde::de::DeserializeOwned)]
45    pub async fn list(&self) -> Result<SkillListResource, OpenAIError> {
46        self.client.get("/skills", &self.request_options).await
47    }
48
49    /// Retrieve a skill by its ID.
50    #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
51    pub async fn retrieve(&self, skill_id: &str) -> Result<SkillResource, OpenAIError> {
52        self.client
53            .get(
54                format!("/skills/{skill_id}").as_str(),
55                &self.request_options,
56            )
57            .await
58    }
59
60    /// Update the default version pointer for a skill.
61    #[crate::byot(T0 = std::fmt::Display, T1 = serde::Serialize, R = serde::de::DeserializeOwned)]
62    pub async fn update(
63        &self,
64        skill_id: &str,
65        request: SetDefaultSkillVersionRequest,
66    ) -> Result<SkillResource, OpenAIError> {
67        self.client
68            .post(
69                format!("/skills/{skill_id}").as_str(),
70                request,
71                &self.request_options,
72            )
73            .await
74    }
75
76    /// Delete a skill by its ID.
77    #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
78    pub async fn delete(&self, skill_id: &str) -> Result<DeletedSkillResource, OpenAIError> {
79        self.client
80            .delete(
81                format!("/skills/{skill_id}").as_str(),
82                &self.request_options,
83            )
84            .await
85    }
86
87    /// Download a skill zip bundle by its ID.
88    pub async fn content(&self, skill_id: &str) -> Result<Bytes, OpenAIError> {
89        let (bytes, _headers) = self
90            .client
91            .get_raw(
92                format!("/skills/{skill_id}/content").as_str(),
93                &self.request_options,
94            )
95            .await?;
96        Ok(bytes)
97    }
98}