Skip to main content

cpa_server/
registry.rs

1//! The dynamic model registry lives in `cpa_core::registry::dynamic` so translators and
2//! shared helpers can read capabilities; this module publishes the runtime's copy.
3
4use cpa_core::registry::ModelInfo;
5pub use cpa_core::registry::dynamic::*;
6
7/// Exposes the runtime's registry through `cpa_core::registry::lookup_model`.
8pub struct Overlay(pub std::sync::Weak<crate::Runtime>);
9
10impl cpa_core::registry::Overlay for Overlay {
11    fn lookup(&self, id: &str, provider: Option<&str>) -> Option<ModelInfo> {
12        self.0.upgrade()?.registry().info(id, provider).map(|s| s.to_info())
13    }
14
15    fn for_credential(&self, credential_id: &str, model: &str) -> Option<ModelInfo> {
16        self.0
17            .upgrade()?
18            .registry()
19            .client_model(credential_id, model)
20            .map(|s| s.to_info())
21    }
22
23    fn available_by_provider(&self, provider: &str) -> Vec<ModelInfo> {
24        let Some(rt) = self.0.upgrade() else {
25            return Vec::new();
26        };
27        rt.registry()
28            .available_by_provider(provider, |client, model| rt.suspension(client, model))
29            .iter()
30            .map(|s| s.to_info())
31            .collect()
32    }
33
34    fn model_providers(&self, model: &str) -> Vec<String> {
35        self.0
36            .upgrade()
37            .map(|rt| rt.registry().model_providers(model))
38            .unwrap_or_default()
39    }
40
41    fn available(&self) -> Vec<ModelInfo> {
42        let Some(rt) = self.0.upgrade() else {
43            return Vec::new();
44        };
45        let registry = rt.registry();
46        registry
47            .available_with(|c, m| rt.suspension(c, m))
48            .map(|s| s.to_info())
49            .collect()
50    }
51}
52
53#[cfg(test)]
54mod tests {
55    use super::{Registry, Spec, Suspension};
56    use cpa_core::config::Config;
57    use cpa_core::credential::Credential;
58    use serde_json::Value;
59    use std::path::Path;
60    use std::sync::Arc;
61
62    fn golden() -> Value {
63        serde_json::from_str(include_str!("../tests/fixtures/server_go.json")).unwrap()
64    }
65
66    /// Go `Auth.AuthKind` goldens (`authKinds`), recorded at v8.0.35, where a true
67    /// `use_siwc` classifies the credential as OAuth first (7b0319fb).
68    #[test]
69    fn auth_kind_matches_go() {
70        let fixture: Value = serde_json::from_str(include_str!("../tests/fixtures/server_go_v8.0.35.json")).unwrap();
71        let cases = fixture["auth_kind"].as_array().unwrap();
72        assert_eq!(cases.len(), 26);
73        for case in cases {
74            let meta = serde_json::json!({"type": "x"}).as_object().unwrap().clone();
75            let mut c = Credential::from_file(Path::new("/a"), Path::new("/a/x.json"), meta).unwrap();
76            c.metadata.clear();
77            if let Some(attrs) = case["attributes"].as_object() {
78                c.attributes = attrs
79                    .iter()
80                    .map(|(k, v)| (k.clone(), v.as_str().unwrap().to_owned()))
81                    .collect();
82            }
83            if let Some(meta) = case["metadata"].as_object() {
84                c.metadata = meta.clone();
85            }
86            let want = case["kind"].as_str().unwrap();
87            assert_eq!(super::auth_kind(&c).unwrap_or(""), want, "case {case}");
88            assert_eq!(super::is_api_key(&c), want == "apikey");
89        }
90    }
91
92    /// Go `GetAvailableModelsByProvider` and the `SupportsWebSearch` aggregation in
93    /// `GetModelInfo` (`byProvider`): only the provider's credentials count, the
94    /// listed info is the credential's own, lookups OR every registration's flag.
95    #[test]
96    fn available_by_provider_matches_go() {
97        let fixture = golden();
98        let cases = fixture["by_provider"].as_array().unwrap();
99        assert_eq!(cases.len(), 9);
100        for (i, case) in cases.iter().enumerate() {
101            let clients = case["clients"].as_array().unwrap();
102            let mut registry = Registry::default();
103            for (j, cl) in clients.iter().enumerate() {
104                let spec = Spec {
105                    id: format!("bp-model-{i}"),
106                    supports_web_search: cl["search"].as_bool().unwrap(),
107                    ..Spec::default()
108                };
109                registry.register(&format!("c{i}-{j}"), cl["provider"].as_str().unwrap(), vec![spec]);
110            }
111            let state = |client: &str, _: &str| {
112                let j: usize = client.rsplit('-').next().unwrap().parse().unwrap();
113                match clients[j]["state"].as_str().unwrap() {
114                    "none" => Suspension::None,
115                    "quota" => Suspension::Quota,
116                    "other" => Suspension::Other { quota_exceeded: false },
117                    "other_qe" => Suspension::Other { quota_exceeded: true },
118                    s => panic!("unknown state {s}"),
119                }
120            };
121            let id = format!("bp-model-{i}");
122            let listed = registry.available_by_provider(" GOLDEN-AG ", state);
123            assert_eq!(listed.len(), usize::from(case["listed"].as_bool().unwrap()), "case {i}");
124            if let (Some(spec), Some(want)) = (listed.first(), case["listed_search"].as_bool()) {
125                assert_eq!(spec.supports_web_search, want, "case {i} listed flag");
126            }
127            let info = registry.info(&id, None).unwrap();
128            assert_eq!(
129                info.supports_web_search,
130                case["info_search"].as_bool().unwrap(),
131                "case {i}"
132            );
133            let ag = registry.info(&id, Some("golden-ag")).unwrap();
134            assert_eq!(ag.supports_web_search, case["ag_search"].as_bool().unwrap(), "case {i}");
135        }
136    }
137
138    /// Go `modelRegistrationAvailability` through the real registry: goldens from
139    /// tests/reference/server/main.go (`ApplyClientModelProjections` + `GetAvailableModels`).
140    #[test]
141    fn availability_matches_go_projections() {
142        let fixture: Value = serde_json::from_str(include_str!("../tests/fixtures/server_go.json")).unwrap();
143        let cases = fixture["availability"].as_array().unwrap();
144        assert_eq!(cases.len(), 15);
145        let credentials: Vec<Arc<Credential>> = (0..3)
146            .map(|i| {
147                let metadata = serde_json::json!({"type": "claude"}).as_object().unwrap().clone();
148                let path = format!("/auth/{i}.json");
149                Arc::new(Credential::from_file(Path::new("/auth"), Path::new(&path), metadata).unwrap())
150            })
151            .collect();
152        let model = "claude-sonnet-4-6";
153        for case in cases {
154            let states: Vec<Suspension> = case["states"]
155                .as_array()
156                .unwrap()
157                .iter()
158                .map(|s| match s.as_str().unwrap() {
159                    "none" => Suspension::None,
160                    "quota" => Suspension::Quota,
161                    "other" => Suspension::Other { quota_exceeded: false },
162                    "other_qe" => Suspension::Other { quota_exceeded: true },
163                    other => panic!("unknown state {other}"),
164                })
165                .collect();
166            let registry = Registry::build(&Config::default(), &credentials[..states.len()]);
167            let ids: Vec<String> = credentials[..states.len()].iter().map(|c| c.id.clone()).collect();
168            let listed = registry
169                .available_with(|client, m| match ids.iter().position(|id| id == client) {
170                    Some(i) if m == model => states[i],
171                    _ => Suspension::None,
172                })
173                .any(|spec| spec.id == model);
174            assert_eq!(
175                listed,
176                case["available"].as_bool().unwrap(),
177                "states {}",
178                case["states"]
179            );
180        }
181    }
182}