relay_knowledge/application/model_provider/
config.rs1use crate::{
2 api::ApiError,
3 model_provider::{
4 ModelCatalogResult, ModelConnectivityProbeRequest, ModelConnectivityProbeResult,
5 ModelDiscoveryRequest, ModelDiscoveryResult, ModelFallbackConfig, ModelProfileSaveRequest,
6 ModelProfilesResponse, ModelProviderError,
7 },
8};
9
10use crate::application::service::RelayKnowledgeService;
11
12impl RelayKnowledgeService {
13 pub async fn model_profiles(&self) -> Result<ModelProfilesResponse, ApiError> {
15 self.model_provider_config()
16 .profiles(&self.runtime.retrieval)
17 .await
18 .map_err(model_provider_api_error)
19 }
20
21 pub async fn save_model_profile(
23 &self,
24 name: &str,
25 request: ModelProfileSaveRequest,
26 ) -> Result<ModelProfilesResponse, ApiError> {
27 self.model_provider_config()
28 .save_profile(name, request, &self.runtime.retrieval)
29 .await
30 .map_err(model_provider_api_error)
31 }
32
33 pub async fn delete_model_profile(
35 &self,
36 name: &str,
37 ) -> Result<ModelProfilesResponse, ApiError> {
38 self.model_provider_config()
39 .delete_profile(name, &self.runtime.retrieval)
40 .await
41 .map_err(model_provider_api_error)
42 }
43
44 pub async fn model_fallback_config(&self) -> Result<ModelFallbackConfig, ApiError> {
46 self.model_provider_config()
47 .fallback_config()
48 .await
49 .map_err(model_provider_api_error)
50 }
51
52 pub async fn save_model_fallback_config(
54 &self,
55 config: ModelFallbackConfig,
56 ) -> Result<ModelFallbackConfig, ApiError> {
57 self.model_provider_config()
58 .save_fallback_config(config)
59 .await
60 .map_err(model_provider_api_error)
61 }
62
63 pub async fn model_catalog(&self, refresh: bool) -> Result<ModelCatalogResult, ApiError> {
65 let network = self.runtime.network.current();
66 self.model_provider_config()
67 .catalog(&network.http, refresh)
68 .await
69 .map_err(model_provider_api_error)
70 }
71
72 pub async fn probe_model_provider(
74 &self,
75 request: ModelConnectivityProbeRequest,
76 ) -> Result<ModelConnectivityProbeResult, ApiError> {
77 let network = self.runtime.network.current();
78 self.model_provider_config()
79 .probe(&network.http, &self.runtime.retrieval, request)
80 .await
81 .map_err(model_provider_api_error)
82 }
83
84 pub async fn discover_model_provider(
86 &self,
87 request: ModelDiscoveryRequest,
88 ) -> Result<ModelDiscoveryResult, ApiError> {
89 let network = self.runtime.network.current();
90 self.model_provider_config()
91 .discover(&network.http, &self.runtime.retrieval, request)
92 .await
93 .map_err(model_provider_api_error)
94 }
95}
96
97fn model_provider_api_error(error: ModelProviderError) -> ApiError {
98 match error {
99 ModelProviderError::InvalidInput(message) => ApiError::invalid_argument(message),
100 ModelProviderError::Io(message)
101 | ModelProviderError::Json(message)
102 | ModelProviderError::Network(message) => ApiError::storage_unavailable(message),
103 }
104}