Skip to main content

relay_knowledge/application/model_provider/
config.rs

1use 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    /// Lists redacted model provider profiles.
14    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    /// Saves a model provider profile and returns the redacted profile list.
22    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    /// Deletes a model provider profile and returns the redacted profile list.
34    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    /// Returns model fallback policy configuration.
45    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    /// Saves model fallback policy configuration.
53    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    /// Returns the cached or refreshed public model catalog.
64    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    /// Probes a configured or overridden model profile.
73    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    /// Discovers models from a configured or overridden model profile.
85    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}