1use cpa_core::registry::ModelInfo;
5pub use cpa_core::registry::dynamic::*;
6
7pub 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 #[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 #[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 #[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}