Skip to main content

context69_sdk/client/
settings.rs

1use context69_contracts::{
2    DoclingSettingsResponse, ProviderAccountResponse, RuntimeSettingsResponse,
3    SearchSettingsResponse, UpdateDoclingSettingsRequest, UpdateRuntimeSettingsRequest,
4    UpdateSearchSettingsRequest, UpsertProviderAccountRequest,
5};
6use reqwest::Method;
7
8use crate::{Context69Client, Error};
9
10pub struct SettingsApi<'a> {
11    client: &'a Context69Client,
12}
13
14impl<'a> SettingsApi<'a> {
15    pub(crate) fn new(client: &'a Context69Client) -> Self {
16        Self { client }
17    }
18
19    pub async fn get_runtime_settings(&self) -> Result<RuntimeSettingsResponse, Error> {
20        self.client
21            .execute_json(
22                self.client
23                    .authorized_request(Method::GET, "/v1/settings/runtime")
24                    .await?,
25            )
26            .await
27    }
28
29    pub async fn update_runtime_settings(
30        &self,
31        request: &UpdateRuntimeSettingsRequest,
32    ) -> Result<RuntimeSettingsResponse, Error> {
33        self.client
34            .execute_json(
35                self.client
36                    .authorized_request(Method::PUT, "/v1/settings/runtime")
37                    .await?
38                    .json(request),
39            )
40            .await
41    }
42
43    pub async fn list_provider_accounts(&self) -> Result<Vec<ProviderAccountResponse>, Error> {
44        self.client
45            .execute_json(
46                self.client
47                    .authorized_request(Method::GET, "/v1/settings/provider-accounts")
48                    .await?,
49            )
50            .await
51    }
52
53    pub async fn create_provider_account(
54        &self,
55        request: &UpsertProviderAccountRequest,
56    ) -> Result<ProviderAccountResponse, Error> {
57        self.client
58            .execute_json(
59                self.client
60                    .authorized_request(Method::POST, "/v1/settings/provider-accounts")
61                    .await?
62                    .json(request),
63            )
64            .await
65    }
66
67    pub async fn update_provider_account(
68        &self,
69        request: &UpsertProviderAccountRequest,
70    ) -> Result<ProviderAccountResponse, Error> {
71        self.client
72            .execute_json(
73                self.client
74                    .authorized_request(Method::PUT, "/v1/settings/provider-accounts")
75                    .await?
76                    .json(request),
77            )
78            .await
79    }
80
81    pub async fn delete_provider_account(&self, account_key: &str) -> Result<(), Error> {
82        let path = format!("/v1/settings/provider-accounts/{account_key}");
83        self.client
84            .execute_empty(
85                self.client
86                    .authorized_request(Method::DELETE, &path)
87                    .await?,
88            )
89            .await
90    }
91
92    pub async fn get_docling_settings(&self) -> Result<DoclingSettingsResponse, Error> {
93        self.client
94            .execute_json(
95                self.client
96                    .authorized_request(Method::GET, "/v1/settings/docling")
97                    .await?,
98            )
99            .await
100    }
101
102    pub async fn update_docling_settings(
103        &self,
104        request: &UpdateDoclingSettingsRequest,
105    ) -> Result<DoclingSettingsResponse, Error> {
106        self.client
107            .execute_json(
108                self.client
109                    .authorized_request(Method::PUT, "/v1/settings/docling")
110                    .await?
111                    .json(request),
112            )
113            .await
114    }
115
116    pub async fn get_search_settings(&self) -> Result<SearchSettingsResponse, Error> {
117        self.client
118            .execute_json(
119                self.client
120                    .authorized_request(Method::GET, "/v1/settings/search")
121                    .await?,
122            )
123            .await
124    }
125
126    pub async fn update_search_settings(
127        &self,
128        request: &UpdateSearchSettingsRequest,
129    ) -> Result<SearchSettingsResponse, Error> {
130        self.client
131            .execute_json(
132                self.client
133                    .authorized_request(Method::PUT, "/v1/settings/search")
134                    .await?
135                    .json(request),
136            )
137            .await
138    }
139}