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 let qos = self.runtime.network.qos_runtime();
67 self.model_provider_config()
68 .catalog_with_qos(&network.http, &qos, &network.qos, refresh)
69 .await
70 .map_err(model_provider_api_error)
71 }
72
73 pub async fn probe_model_provider(
75 &self,
76 request: ModelConnectivityProbeRequest,
77 ) -> Result<ModelConnectivityProbeResult, ApiError> {
78 let network = self.runtime.network.current();
79 let qos = self.runtime.network.qos_runtime();
80 self.model_provider_config()
81 .probe_with_qos(
82 &network.http,
83 &qos,
84 &network.qos,
85 &self.runtime.retrieval,
86 request,
87 )
88 .await
89 .map_err(model_provider_api_error)
90 }
91
92 pub async fn discover_model_provider(
94 &self,
95 request: ModelDiscoveryRequest,
96 ) -> Result<ModelDiscoveryResult, ApiError> {
97 let network = self.runtime.network.current();
98 let qos = self.runtime.network.qos_runtime();
99 self.model_provider_config()
100 .discover_with_qos(
101 &network.http,
102 &qos,
103 &network.qos,
104 &self.runtime.retrieval,
105 request,
106 )
107 .await
108 .map_err(model_provider_api_error)
109 }
110}
111
112fn model_provider_api_error(error: ModelProviderError) -> ApiError {
113 match error {
114 ModelProviderError::InvalidInput(message) => ApiError::invalid_argument(message),
115 ModelProviderError::Io(message)
116 | ModelProviderError::Json(message)
117 | ModelProviderError::Network(message) => ApiError::storage_unavailable(message),
118 }
119}