relay-knowledge 1.1.14

Graph-database-based knowledge graph project.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use crate::{
    api::ApiError,
    model_provider::{
        ModelCatalogResult, ModelConnectivityProbeRequest, ModelConnectivityProbeResult,
        ModelDiscoveryRequest, ModelDiscoveryResult, ModelFallbackConfig, ModelProfileSaveRequest,
        ModelProfilesResponse, ModelProviderError,
    },
};

use crate::application::service::RelayKnowledgeService;

impl RelayKnowledgeService {
    /// Lists redacted model provider profiles.
    pub async fn model_profiles(&self) -> Result<ModelProfilesResponse, ApiError> {
        self.model_provider_config()
            .profiles(&self.runtime.retrieval)
            .await
            .map_err(model_provider_api_error)
    }

    /// Saves a model provider profile and returns the redacted profile list.
    pub async fn save_model_profile(
        &self,
        name: &str,
        request: ModelProfileSaveRequest,
    ) -> Result<ModelProfilesResponse, ApiError> {
        self.model_provider_config()
            .save_profile(name, request, &self.runtime.retrieval)
            .await
            .map_err(model_provider_api_error)
    }

    /// Deletes a model provider profile and returns the redacted profile list.
    pub async fn delete_model_profile(
        &self,
        name: &str,
    ) -> Result<ModelProfilesResponse, ApiError> {
        self.model_provider_config()
            .delete_profile(name, &self.runtime.retrieval)
            .await
            .map_err(model_provider_api_error)
    }

    /// Returns model fallback policy configuration.
    pub async fn model_fallback_config(&self) -> Result<ModelFallbackConfig, ApiError> {
        self.model_provider_config()
            .fallback_config()
            .await
            .map_err(model_provider_api_error)
    }

    /// Saves model fallback policy configuration.
    pub async fn save_model_fallback_config(
        &self,
        config: ModelFallbackConfig,
    ) -> Result<ModelFallbackConfig, ApiError> {
        self.model_provider_config()
            .save_fallback_config(config)
            .await
            .map_err(model_provider_api_error)
    }

    /// Returns the cached or refreshed public model catalog.
    pub async fn model_catalog(&self, refresh: bool) -> Result<ModelCatalogResult, ApiError> {
        let network = self.runtime.network.current();
        let qos = self.runtime.network.qos_runtime();
        self.model_provider_config()
            .catalog_with_qos(&network.http, &qos, &network.qos, refresh)
            .await
            .map_err(model_provider_api_error)
    }

    /// Probes a configured or overridden model profile.
    pub async fn probe_model_provider(
        &self,
        request: ModelConnectivityProbeRequest,
    ) -> Result<ModelConnectivityProbeResult, ApiError> {
        let network = self.runtime.network.current();
        let qos = self.runtime.network.qos_runtime();
        self.model_provider_config()
            .probe_with_qos(
                &network.http,
                &qos,
                &network.qos,
                &self.runtime.retrieval,
                request,
            )
            .await
            .map_err(model_provider_api_error)
    }

    /// Discovers models from a configured or overridden model profile.
    pub async fn discover_model_provider(
        &self,
        request: ModelDiscoveryRequest,
    ) -> Result<ModelDiscoveryResult, ApiError> {
        let network = self.runtime.network.current();
        let qos = self.runtime.network.qos_runtime();
        self.model_provider_config()
            .discover_with_qos(
                &network.http,
                &qos,
                &network.qos,
                &self.runtime.retrieval,
                request,
            )
            .await
            .map_err(model_provider_api_error)
    }
}

fn model_provider_api_error(error: ModelProviderError) -> ApiError {
    match error {
        ModelProviderError::InvalidInput(message) => ApiError::invalid_argument(message),
        ModelProviderError::Io(message)
        | ModelProviderError::Json(message)
        | ModelProviderError::Network(message) => ApiError::storage_unavailable(message),
    }
}