1use std::collections::{HashMap, HashSet};
6use std::sync::{Arc, RwLock, Weak};
7
8use axum::body::{Body, Bytes};
9use axum::extract::Request;
10use axum::http::HeaderMap;
11use cpa_common::gostr::GoStr;
12use cpa_core::config::Config;
13use cpa_core::exec::Caller;
14use tokio::sync::watch;
15
16use crate::Runtime;
17
18pub(crate) mod execution;
19pub(crate) mod interceptors;
20pub(crate) mod model_callbacks;
21pub(crate) mod refresh;
22
23pub struct PluginRuntime {
25 host: cpa_plugin::Host,
26 latest: watch::Sender<Option<(u64, Arc<Config>)>>,
28 applied: watch::Sender<u64>,
30 access: RwLock<Arc<AccessRegistry>>,
31 executors: RwLock<HashMap<String, cpa_plugin::executor::Adapter>>,
33}
34
35impl Default for PluginRuntime {
36 fn default() -> Self {
37 Self::with_host(cpa_plugin::Host::new())
38 }
39}
40
41impl PluginRuntime {
42 pub(crate) fn with_host(host: cpa_plugin::Host) -> Self {
45 Self {
46 host,
47 latest: watch::Sender::new(None),
48 applied: watch::Sender::new(0),
49 access: RwLock::default(),
50 executors: RwLock::default(),
51 }
52 }
53
54 pub fn host(&self) -> &cpa_plugin::Host {
55 &self.host
56 }
57
58 pub(crate) fn executor(
64 &self,
65 credential: &cpa_core::credential::Credential,
66 cfg: &Config,
67 ) -> Option<cpa_plugin::executor::Adapter> {
68 let adapter = {
69 let executors = self.executors.read().unwrap_or_else(std::sync::PoisonError::into_inner);
70 executors.get(&credential.provider.trim().go_lower()).cloned()?
71 };
72 let compat_names = cpa_core::config::credentials::openai_compat_names(cfg);
73 (!binds_native(credential, &compat_names)).then_some(adapter)
74 }
75
76 pub(crate) fn has_executor(&self, provider: &str) -> bool {
78 let executors = self.executors.read().unwrap_or_else(std::sync::PoisonError::into_inner);
79 executors.contains_key(&provider.trim().go_lower())
80 }
81
82 pub(crate) fn config_published(&self, cfg: Arc<Config>) {
84 self.latest.send_modify(|latest| {
85 let seq = latest.as_ref().map_or(1, |(seq, _)| seq + 1);
86 *latest = Some((seq, cfg));
87 });
88 }
89
90 fn published_seq(&self) -> u64 {
91 self.latest.borrow().as_ref().map_or(0, |(seq, _)| *seq)
92 }
93}
94
95pub async fn applied(rt: &Runtime) {
98 let seq = rt.plugin_runtime().published_seq();
99 let _ = rt
100 .plugin_runtime()
101 .applied
102 .subscribe()
103 .wait_for(|applied| *applied >= seq)
104 .await;
105}
106
107pub async fn sync(rt: &Runtime, cfg: Arc<Config>) {
114 let host = rt.plugins();
115 host.apply_config(cfg.clone()).await;
116 let (providers, exclusive) = host.frontend_auth_providers().await;
119 rt.plugin_runtime()
120 .register_access(!cfg.api_keys.is_empty(), providers, exclusive);
121 host.register_management_routes(&reserved_management_routes()).await;
122 cpa_translate::hooks::set_plugin_hooks(Some(host.translator_hooks()));
125 cpa_core::config::credentials::set_plugin_auth_parser(Some(host.auth_parser()));
128 sync_models(rt).await;
129}
130
131pub async fn reload_plugin_auth_files(rt: &Arc<Runtime>) {
144 use cpa_core::config::credentials;
145 struct EndBootstrap(Arc<Runtime>);
149 impl Drop for EndBootstrap {
150 fn drop(&mut self) {
151 self.0.store().end_bootstrap();
152 }
153 }
154 let end = EndBootstrap(rt.clone());
155 if !credentials::plugin_auth_parser_active() {
156 return;
157 }
158 let rt = rt.clone();
159 let reload = tokio::task::spawn_blocking(move || {
160 let _end = end;
161 let cfg = rt.config();
162 credentials::preparse_auth_dir(&cfg);
163 let scan = credentials::scan_auth_dir(&cfg);
164 let mut all = scan.credentials;
165 for existing in rt.store().snapshot() {
166 if let cpa_core::credential::Source::File(path) = &existing.source
167 && scan.incomplete.contains(path)
168 && !all.iter().any(|c| c.id == existing.id)
169 {
170 all.push(cpa_core::credential::Credential::clone(&existing));
171 }
172 }
173 all.extend(credentials::from_config(&cfg));
174 rt.store().reconcile_scanned_with(all, &scan.read, |current, all| {
175 keep_deferred(current, all, &scan.deferred)
176 });
177 });
178 if let Err(e) = reload.await {
179 tracing::error!(error = %e, "reloading auth files for plugin auth providers failed");
180 }
181}
182
183pub(crate) fn keep_deferred(
190 current: &[Arc<cpa_core::credential::Credential>],
191 all: &mut Vec<cpa_core::credential::Credential>,
192 deferred: &std::collections::HashSet<std::path::PathBuf>,
193) {
194 use cpa_core::credential::{Credential, Source};
195 if deferred.is_empty() {
196 return;
197 }
198 let absolute = |p: &std::path::Path| std::path::absolute(p).unwrap_or_else(|_| p.to_owned());
200 let deferred: std::collections::HashSet<_> = deferred.iter().map(|p| absolute(p)).collect();
201 for existing in current {
202 if let Source::File(p) = &existing.source
203 && deferred.contains(&absolute(p))
204 && !all.iter().any(|c| c.id == existing.id)
205 {
206 all.push(Credential::clone(existing));
207 }
208 }
209}
210
211async fn sync_models(rt: &Runtime) {
215 let host = rt.plugins();
216 host.register_models().await;
217 let native = native_executor_providers(rt).await;
218 for _ in 0..3 {
223 let registry = rt.registry();
224 let Some(changes) = host
225 .register_executors(&|p| native.contains(p), &|m| registry.model_providers(m))
226 .await
227 else {
228 return;
230 };
231 *rt.plugin_runtime()
232 .executors
233 .write()
234 .unwrap_or_else(std::sync::PoisonError::into_inner) = changes
235 .register
236 .into_iter()
237 .map(|adapter| (adapter.provider.clone(), adapter))
238 .collect();
239 let specs = |models: &[cpa_plugin::api::ModelInfo]| models.iter().map(model_spec).collect::<Vec<_>>();
240 let changed = cpa_core::registry::dynamic::set_plugin_catalog(cpa_core::registry::dynamic::PluginCatalog {
241 providers: host
242 .provider_models()
243 .iter()
244 .map(|(provider, models)| (provider.clone(), specs(models)))
245 .collect(),
246 clients: changes
247 .clients
248 .register
249 .iter()
250 .map(|(client, provider, models)| (client.clone(), provider.clone(), specs(models)))
251 .collect(),
252 });
253 if !changed {
254 return;
255 }
256 }
257}
258
259const BUILTIN: [&str; 14] = [
261 "codex",
262 "claude",
263 "gemini",
264 "gemini-interactions",
265 "vertex",
266 "aistudio",
267 "antigravity",
268 "kimi",
269 "kimi-ai",
270 "kimi.ai",
271 "kimi.com",
272 "xai",
273 "devin",
274 "meta",
275];
276
277fn binds_native(c: &cpa_core::credential::Credential, compat_names: &[String]) -> bool {
287 let attr = |k: &str| c.attributes.get(k).map(|v| v.trim()).unwrap_or_default();
288 let provider = c.provider.trim().go_lower();
289 if !attr("compat_name").is_empty() || provider == "openai-compatibility" || BUILTIN.contains(&provider.as_str()) {
290 return true;
291 }
292 let key = if provider.is_empty() {
293 "openai-compatibility"
294 } else {
295 provider.as_str()
296 };
297 !attr("base_url").is_empty()
298 || [key, &attr("provider_key").go_lower(), &provider]
299 .iter()
300 .any(|candidate| !candidate.is_empty() && compat_names.iter().any(|n| n == candidate))
301}
302
303async fn native_executor_providers(rt: &Runtime) -> HashSet<String> {
311 let cfg = rt.config();
312 let compat_names = cpa_core::config::credentials::openai_compat_names(&cfg);
313 let host = rt.plugins();
314 let mut native = HashSet::new();
315 for c in rt.store().snapshot().iter().filter(|c| !c.disabled) {
316 let provider = c.provider.trim().go_lower();
317 let key = if !c.attributes.get("compat_name").is_none_or(|v| v.trim().is_empty())
318 || provider == "openai-compatibility"
319 {
320 cpa_core::registry::dynamic::provider_key(c)
321 } else if provider.is_empty() {
322 "openai-compatibility".to_owned()
323 } else {
324 provider
325 };
326 if !binds_native(c, &compat_names) && host.has_executor_candidate_provider(&key).await {
327 continue;
328 }
329 native.insert(key);
330 }
331 if rt.remote_dispatch().is_some() {
332 native.extend(
335 BUILTIN
336 .iter()
337 .filter(|p| **p != "kimi.com")
338 .chain(&["openai-compatibility"])
339 .map(|p| (*p).to_owned()),
340 );
341 }
342 native
343}
344
345#[derive(Debug, Default)]
348pub struct SchedulerContext {
349 pub stream: bool,
350 pub options: cpa_plugin::api::SchedulerOptions,
351}
352
353pub(crate) fn provider_scheduler_context(
360 rt: &Runtime,
361 provider: &str,
362 headers: &HeaderMap,
363 affinity_model: &str,
364 metadata: &[(&str, &str)],
365) -> Option<Arc<SchedulerContext>> {
366 if !rt.plugins().has_scheduler() {
367 return None;
368 }
369 let string = |s: &str| serde_json::Value::String(s.to_owned());
370 let mut out: cpa_plugin::gojson::Metadata = metadata.iter().map(|(k, v)| ((*k).to_owned(), string(v))).collect();
371 out.insert("session_affinity_provider".into(), string(provider));
372 out.insert("session_affinity_model".into(), string(affinity_model));
373 Some(Arc::new(SchedulerContext {
374 stream: false,
375 options: cpa_plugin::api::SchedulerOptions {
376 headers: go_request_header(headers),
377 metadata: out,
378 },
379 }))
380}
381
382pub(crate) fn scheduler_request(
386 rt: &Runtime,
387 selection: &crate::runtime::Selection,
388 policy: &crate::scheduler::Policy,
389 admit: &crate::runtime::Admit<'_>,
390) -> Result<Option<cpa_plugin::api::SchedulerPickRequest>, crate::runtime::AcquireError> {
391 let host = rt.plugins();
392 if rt.remote_dispatch().is_some() || !host.has_scheduler() {
393 return Ok(None);
394 }
395 let across = host.scheduler_wants_across_priorities();
396 let candidates = rt.store().scheduler_candidates(selection, policy, admit, across)?;
397 let mut providers: Vec<String> = Vec::new();
398 for p in selection.provider_keys() {
399 let p = p.trim().go_lower();
400 if !p.is_empty() && p != "mixed" && !providers.contains(&p) {
401 providers.push(p);
402 }
403 }
404 let context = selection.scheduler.as_deref();
405 Ok(Some(cpa_plugin::api::SchedulerPickRequest {
406 provider: if selection.providers.is_empty() {
410 selection.provider.trim().go_lower()
411 } else {
412 String::new()
413 },
414 providers,
415 model: selection.model.clone(),
416 stream: context.is_some_and(|c| c.stream),
417 options: context.map(|c| c.options.clone()).unwrap_or_default(),
418 candidates: candidates
419 .iter()
420 .map(|c| cpa_plugin::api::SchedulerAuthCandidate {
421 id: c.id.clone(),
422 provider: c.provider.trim().go_lower(),
423 priority: crate::scheduler::priority(c),
424 status: "active".into(),
428 attributes: c
429 .attributes
430 .iter()
431 .filter(|(k, _)| !scheduler_attribute_sensitive(k))
432 .map(|(k, v)| (k.clone(), v.clone()))
433 .collect(),
434 ..Default::default()
435 })
436 .collect(),
437 ..Default::default()
438 }))
439}
440
441pub(crate) async fn scheduler_pick(
446 rt: &Runtime,
447 request: Option<cpa_plugin::api::SchedulerPickRequest>,
448) -> Result<crate::runtime::Pick, crate::runtime::AcquireError> {
449 use crate::runtime::{AcquireError, Pick};
450 let Some(request) = request else {
451 return Ok(Pick::Configured);
452 };
453 let resp = match rt.plugins().pick_auth(request).await {
454 Ok(Some(resp)) => resp,
455 Ok(None) => return Ok(Pick::Configured),
456 Err(e) => {
458 return Err(AcquireError::Scheduler(cpa_core::exec::ExecError::local(
459 e.status(),
460 cpa_core::exec::FailureScope::Model,
461 e.to_string(),
462 )));
463 }
464 };
465 if resp.reject {
466 return Err(AcquireError::Rejected {
467 code: resp.reject_code,
468 message: resp.reject_reason,
469 });
470 }
471 if !resp.auth_id.is_empty() {
472 return Ok(Pick::Auth(resp.auth_id));
473 }
474 Ok(match resp.delegate_builtin.as_str() {
475 cpa_plugin::api::SCHEDULER_BUILTIN_ROUND_ROBIN => Pick::Builtin(crate::scheduler::Strategy::RoundRobin),
476 cpa_plugin::api::SCHEDULER_BUILTIN_FILL_FIRST => Pick::Builtin(crate::scheduler::Strategy::FillFirst),
477 _ => Pick::Configured,
478 })
479}
480
481fn scheduler_attribute_sensitive(key: &str) -> bool {
483 let key = key.trim().go_lower();
484 let normalized: String = key
485 .chars()
486 .map(|c| if matches!(c, '-' | '.' | ' ') { '_' } else { c })
487 .collect();
488 let compact: String = key.chars().filter(|c| !matches!(c, '_' | '-' | '.' | ' ')).collect();
489 [
490 "api_key",
491 "apikey",
492 "token",
493 "secret",
494 "cookie",
495 "credential",
496 "password",
497 "storage",
498 "authorization",
499 "auth_header",
500 "proxy_url",
501 ]
502 .iter()
503 .any(|fragment| key.contains(fragment) || normalized.contains(fragment) || compact.contains(fragment))
504}
505
506fn model_spec(m: &cpa_plugin::api::ModelInfo) -> cpa_core::registry::dynamic::Spec {
508 cpa_core::registry::dynamic::Spec {
509 id: m.id.trim().to_owned(),
510 object: m.object.clone(),
511 created: m.created,
512 owned_by: m.owned_by.clone(),
513 kind: m.model_type.clone(),
514 display_name: m.display_name.clone(),
515 name: m.name.clone(),
516 version: m.version.clone(),
517 description: m.description.clone(),
518 input_token_limit: m.input_token_limit,
519 output_token_limit: m.output_token_limit,
520 supported_generation_methods: m.supported_generation_methods.clone(),
521 context_length: m.context_length,
522 max_completion_tokens: m.max_completion_tokens,
523 supported_parameters: m.supported_parameters.clone(),
524 supported_input_modalities: m.supported_input_modalities.clone(),
525 supported_output_modalities: m.supported_output_modalities.clone(),
526 thinking: m.thinking.as_ref().map(|t| cpa_core::registry::ThinkingSupport {
527 min: t.min,
528 max: t.max,
529 zero_allowed: t.zero_allowed,
530 dynamic_allowed: t.dynamic_allowed,
531 disable_type: t.disable_type.clone(),
532 levels: t.levels.clone(),
533 }),
534 user_defined: m.user_defined,
535 ..Default::default()
536 }
537}
538
539const CONFIG_PROVIDER_KEY: &str = "config-api-key";
543pub(crate) const CONFIG_PROVIDER: &str = "config-inline";
545
546#[derive(Default)]
550struct AccessRegistry {
551 order: Vec<String>,
552 plugins: HashMap<String, String>,
553 exclusive: Option<String>,
554}
555
556enum Provider<'a> {
557 ClientKeys,
558 Plugin(&'a str),
559}
560
561impl AccessRegistry {
562 fn providers(&self, client_keys: bool) -> Vec<Provider<'_>> {
566 if let Some(id) = self.exclusive.as_ref().and_then(|key| self.plugins.get(key)) {
567 return vec![Provider::Plugin(id)];
568 }
569 let mut out = Vec::with_capacity(self.order.len() + 1);
570 if client_keys && !self.order.iter().any(|k| k == CONFIG_PROVIDER_KEY) {
571 out.push(Provider::ClientKeys);
572 }
573 for key in &self.order {
574 if key == CONFIG_PROVIDER_KEY {
575 if client_keys {
576 out.push(Provider::ClientKeys);
577 }
578 } else if let Some(id) = self.plugins.get(key) {
579 out.push(Provider::Plugin(id));
580 }
581 }
582 out
583 }
584}
585
586impl PluginRuntime {
587 fn access(&self) -> Arc<AccessRegistry> {
588 self.access.read().unwrap_or_else(|e| e.into_inner()).clone()
589 }
590
591 pub(crate) fn register_access(
595 &self,
596 client_keys: bool,
597 providers: Vec<(String, String)>,
598 exclusive: Option<String>,
599 ) {
600 let mut slot = self.access.write().unwrap_or_else(|e| e.into_inner());
601 let mut next = AccessRegistry {
602 order: slot.order.clone(),
603 plugins: HashMap::new(),
604 exclusive,
605 };
606 let register = |order: &mut Vec<String>, key: &str| {
607 if !order.iter().any(|k| k == key) {
608 order.push(key.to_owned());
609 }
610 };
611 if client_keys {
612 register(&mut next.order, CONFIG_PROVIDER_KEY);
613 } else {
614 next.order.retain(|k| k != CONFIG_PROVIDER_KEY);
615 }
616 for (key, id) in providers {
617 register(&mut next.order, &key);
618 next.plugins.insert(key, id);
619 }
620 next.order
621 .retain(|k| k == CONFIG_PROVIDER_KEY || next.plugins.contains_key(k));
622 *slot = Arc::new(next);
623 }
624}
625
626pub(crate) enum Access {
628 Open,
630 Granted(Caller),
634}
635
636pub(crate) struct Denied {
638 pub status: u16,
639 pub message: &'static str,
640}
641
642const MISSING_API_KEY: &str = "Missing API key";
643
644pub(crate) async fn authenticate(rt: &Runtime, req: Request) -> (Request, Result<Access, Denied>) {
649 let config = rt.config();
650 let registry = rt.plugin_runtime().access();
651 let providers = registry.providers(!config.api_keys.is_empty());
652 if providers.is_empty() {
653 return (req, Ok(Access::Open));
654 }
655 let (parts, mut body) = req.into_parts();
656 let mut read: Option<Bytes> = None;
657 let mut invalid = false;
658 let mut outcome = None;
659 for provider in providers {
660 match provider {
661 Provider::ClientKeys => {
662 match crate::access::authenticate(
663 &config.api_keys,
664 &parts.headers,
665 parts.uri.query().unwrap_or_default(),
666 ) {
667 Ok(caller) => {
668 outcome = Some(Ok(Access::Granted(Caller {
669 provider: CONFIG_PROVIDER.to_owned(),
670 ..caller
671 })));
672 break;
673 }
674 Err(message) => invalid |= message != MISSING_API_KEY,
675 }
676 }
677 Provider::Plugin(id) => {
678 let bytes = match &read {
681 Some(bytes) => bytes.clone(),
682 None => match read_limited(std::mem::take(&mut body)).await {
683 Ok(Some(bytes)) => read.insert(bytes).clone(),
684 Ok(None) => {
685 outcome = Some(Err(Denied {
686 status: 413,
687 message: "request body too large",
688 }));
689 break;
690 }
691 Err(error) if crate::body_limit::is_too_large(&error) => {
693 outcome = Some(Err(Denied {
694 status: 413,
695 message: crate::body_limit::MESSAGE,
696 }));
697 break;
698 }
699 Err(error) => {
700 tracing::error!(
701 "authentication middleware error: failed to read plugin auth request body: {error}"
702 );
703 outcome = Some(Err(Denied {
704 status: 500,
705 message: "failed to read plugin auth request body",
706 }));
707 break;
708 }
709 },
710 };
711 let request = cpa_plugin::api::FrontendAuthRequest {
712 method: parts.method.as_str().to_owned(),
713 path: crate::management::percent_decode(parts.uri.path()),
714 headers: go_request_header(&parts.headers),
715 query: go_values(parts.uri.query().unwrap_or_default()),
716 body: cpa_plugin::gojson::NonNilBytes(bytes),
717 };
718 if let Some(accepted) = rt.plugins().frontend_authenticate(id, &request).await {
719 outcome = Some(Ok(Access::Granted(Caller {
720 principal: accepted.principal,
721 source: "",
722 provider: accepted.provider,
723 })));
724 break;
725 }
726 }
727 }
728 }
729 let body = match read {
730 Some(bytes) => Body::from(bytes),
731 None => body,
732 };
733 let outcome = outcome.unwrap_or(Err(Denied {
734 status: 401,
735 message: if invalid { "Invalid API key" } else { MISSING_API_KEY },
736 }));
737 (Request::from_parts(parts, body), outcome)
738}
739
740async fn read_limited(body: Body) -> Result<Option<Bytes>, axum::Error> {
742 use futures_util::StreamExt as _;
743 let mut stream = body.into_data_stream();
744 let mut out = bytes::BytesMut::new();
745 while let Some(chunk) = stream.next().await {
746 let chunk = chunk?;
747 if out.len() + chunk.len() > crate::MAX_REQUEST_BYTES {
748 return Ok(None);
749 }
750 out.extend_from_slice(&chunk);
751 }
752 Ok(Some(out.freeze()))
753}
754
755pub(crate) fn go_request_header(headers: &HeaderMap) -> cpa_plugin::gojson::Header {
759 let chunked = headers.contains_key(axum::http::header::TRANSFER_ENCODING);
760 let mut out = cpa_plugin::gojson::Header::new();
761 for (name, value) in headers {
762 let dropped = name == axum::http::header::HOST
763 || (chunked
764 && (name == axum::http::header::TRANSFER_ENCODING
765 || name == axum::http::header::CONTENT_LENGTH
766 || name == axum::http::header::TRAILER));
767 if dropped {
768 continue;
769 }
770 out.entry(cpa_exec::proxy::canonical_header(name.as_str()))
771 .or_default()
772 .push(String::from_utf8_lossy(value.as_bytes()).into_owned());
773 }
774 out
775}
776
777pub(crate) fn go_values(raw_query: &str) -> cpa_plugin::gojson::Header {
779 let mut out = cpa_plugin::gojson::Header::new();
780 for (k, v) in crate::management::go_query(raw_query) {
781 out.entry(k).or_default().push(v);
782 }
783 out
784}
785
786pub async fn start(rt: &Arc<Runtime>) {
789 model_callbacks::attach(rt);
790 let mut rx = rt.plugin_runtime().latest.subscribe();
791 rx.mark_unchanged();
792 let seq = rt.plugin_runtime().published_seq();
794 sync(rt, rt.config()).await;
795 rt.plugin_runtime().applied.send_replace(seq);
796 let weak: Weak<Runtime> = Arc::downgrade(rt);
797 tokio::spawn(async move {
798 while rx.changed().await.is_ok() {
799 let Some((seq, cfg)) = rx.borrow_and_update().clone() else {
800 continue;
801 };
802 let Some(rt) = weak.upgrade() else {
803 return;
804 };
805 sync(&rt, cfg).await;
806 rt.plugin_runtime().applied.send_replace(seq);
807 }
808 });
809}
810
811pub fn reserved_management_routes() -> HashSet<String> {
817 GO_V0_MANAGEMENT_ROUTES.iter().map(|r| (*r).to_owned()).collect()
818}
819
820const GO_V0_MANAGEMENT_ROUTES: [&str; 144] = [
822 "DELETE /v0/management/api-keys",
823 "DELETE /v0/management/auth-files",
824 "DELETE /v0/management/claude-api-key",
825 "DELETE /v0/management/codex-api-key",
826 "DELETE /v0/management/gemini-api-key",
827 "DELETE /v0/management/interactions-api-key",
828 "DELETE /v0/management/logs",
829 "DELETE /v0/management/meta-api-key",
830 "DELETE /v0/management/oauth-excluded-models",
831 "DELETE /v0/management/oauth-model-alias",
832 "DELETE /v0/management/oauth-request-scoped-errors",
833 "DELETE /v0/management/oauth-session",
834 "DELETE /v0/management/openai-compatibility",
835 "DELETE /v0/management/plugins/:id",
836 "DELETE /v0/management/plugins/:id/quota",
837 "DELETE /v0/management/proxy-url",
838 "DELETE /v0/management/vertex-api-key",
839 "DELETE /v0/management/xai-api-key",
840 "GET /v0/management/anthropic-auth-url",
841 "GET /v0/management/antigravity-auth-url",
842 "GET /v0/management/api-key-usage",
843 "GET /v0/management/api-keys",
844 "GET /v0/management/auth-files",
845 "GET /v0/management/auth-files/download",
846 "GET /v0/management/auth-files/models",
847 "GET /v0/management/claude-api-key",
848 "GET /v0/management/codex-api-key",
849 "GET /v0/management/codex-auth-url",
850 "GET /v0/management/config",
851 "GET /v0/management/config.yaml",
852 "GET /v0/management/debug",
853 "GET /v0/management/devin-auth-url",
854 "GET /v0/management/error-logs-max-files",
855 "GET /v0/management/force-model-prefix",
856 "GET /v0/management/gemini-api-key",
857 "GET /v0/management/get-auth-status",
858 "GET /v0/management/interactions-api-key",
859 "GET /v0/management/kimi-ai-auth-url",
860 "GET /v0/management/kimi-auth-url",
861 "GET /v0/management/latest-version",
862 "GET /v0/management/logging-to-file",
863 "GET /v0/management/logs",
864 "GET /v0/management/logs-max-total-size-mb",
865 "GET /v0/management/max-retry-credentials",
866 "GET /v0/management/max-retry-interval",
867 "GET /v0/management/meta-api-key",
868 "GET /v0/management/meta-auth-url",
869 "GET /v0/management/model-definitions/:channel",
870 "GET /v0/management/oauth-callback",
871 "GET /v0/management/oauth-excluded-models",
872 "GET /v0/management/oauth-model-alias",
873 "GET /v0/management/oauth-request-scoped-errors",
874 "GET /v0/management/openai-compatibility",
875 "GET /v0/management/plugin-store",
876 "GET /v0/management/plugins",
877 "GET /v0/management/plugins/:id/config",
878 "GET /v0/management/plugins/:id/quota",
879 "GET /v0/management/proxy-url",
880 "GET /v0/management/quota-exceeded/switch-preview-model",
881 "GET /v0/management/quota-exceeded/switch-project",
882 "GET /v0/management/quota/providers",
883 "GET /v0/management/request-error-logs",
884 "GET /v0/management/request-error-logs/:name",
885 "GET /v0/management/request-log",
886 "GET /v0/management/request-log-by-id/:id",
887 "GET /v0/management/request-retry",
888 "GET /v0/management/routing/strategy",
889 "GET /v0/management/usage-queue",
890 "GET /v0/management/usage-statistics-enabled",
891 "GET /v0/management/vertex-api-key",
892 "GET /v0/management/ws-auth",
893 "GET /v0/management/xai-api-key",
894 "GET /v0/management/xai-auth-url",
895 "PATCH /v0/management/api-keys",
896 "PATCH /v0/management/auth-files/fields",
897 "PATCH /v0/management/auth-files/status",
898 "PATCH /v0/management/claude-api-key",
899 "PATCH /v0/management/codex-api-key",
900 "PATCH /v0/management/debug",
901 "PATCH /v0/management/error-logs-max-files",
902 "PATCH /v0/management/force-model-prefix",
903 "PATCH /v0/management/gemini-api-key",
904 "PATCH /v0/management/interactions-api-key",
905 "PATCH /v0/management/logging-to-file",
906 "PATCH /v0/management/logs-max-total-size-mb",
907 "PATCH /v0/management/max-retry-credentials",
908 "PATCH /v0/management/max-retry-interval",
909 "PATCH /v0/management/meta-api-key",
910 "PATCH /v0/management/oauth-excluded-models",
911 "PATCH /v0/management/oauth-model-alias",
912 "PATCH /v0/management/oauth-request-scoped-errors",
913 "PATCH /v0/management/openai-compatibility",
914 "PATCH /v0/management/plugins/:id/config",
915 "PATCH /v0/management/plugins/:id/enabled",
916 "PATCH /v0/management/proxy-url",
917 "PATCH /v0/management/quota-exceeded/switch-preview-model",
918 "PATCH /v0/management/quota-exceeded/switch-project",
919 "PATCH /v0/management/request-log",
920 "PATCH /v0/management/request-retry",
921 "PATCH /v0/management/routing/strategy",
922 "PATCH /v0/management/usage-statistics-enabled",
923 "PATCH /v0/management/vertex-api-key",
924 "PATCH /v0/management/ws-auth",
925 "PATCH /v0/management/xai-api-key",
926 "POST /v0/management/api-call",
927 "POST /v0/management/auth-files",
928 "POST /v0/management/auth-files/refresh",
929 "POST /v0/management/oauth-callback",
930 "POST /v0/management/plugin-store/:id/install",
931 "POST /v0/management/plugins/:id/quota",
932 "POST /v0/management/plugins/:id/quota/reset",
933 "POST /v0/management/quota/fetch",
934 "POST /v0/management/quota/reset",
935 "POST /v0/management/reset-quota",
936 "POST /v0/management/vertex/import",
937 "PUT /v0/management/api-keys",
938 "PUT /v0/management/claude-api-key",
939 "PUT /v0/management/codex-api-key",
940 "PUT /v0/management/config.yaml",
941 "PUT /v0/management/debug",
942 "PUT /v0/management/error-logs-max-files",
943 "PUT /v0/management/force-model-prefix",
944 "PUT /v0/management/gemini-api-key",
945 "PUT /v0/management/interactions-api-key",
946 "PUT /v0/management/logging-to-file",
947 "PUT /v0/management/logs-max-total-size-mb",
948 "PUT /v0/management/max-retry-credentials",
949 "PUT /v0/management/max-retry-interval",
950 "PUT /v0/management/meta-api-key",
951 "PUT /v0/management/oauth-excluded-models",
952 "PUT /v0/management/oauth-model-alias",
953 "PUT /v0/management/oauth-request-scoped-errors",
954 "PUT /v0/management/openai-compatibility",
955 "PUT /v0/management/plugins/:id/config",
956 "PUT /v0/management/proxy-url",
957 "PUT /v0/management/quota-exceeded/switch-preview-model",
958 "PUT /v0/management/quota-exceeded/switch-project",
959 "PUT /v0/management/request-log",
960 "PUT /v0/management/request-retry",
961 "PUT /v0/management/routing/strategy",
962 "PUT /v0/management/usage-statistics-enabled",
963 "PUT /v0/management/vertex-api-key",
964 "PUT /v0/management/ws-auth",
965 "PUT /v0/management/xai-api-key",
966];
967
968#[cfg(test)]
969mod tests {
970 use super::*;
971
972 fn outcome(result: &Result<Access, Denied>) -> (u16, &'static str) {
973 match result {
974 Ok(_) => (200, ""),
975 Err(denied) => (denied.status, denied.message),
976 }
977 }
978
979 #[tokio::test]
982 async fn plugin_auth_reads_a_bounded_body() {
983 let dir = cpa_plugin::testing::scratch(&std::env::temp_dir(), "plugin-auth-body");
984 let cfg = Config::parse(&format!(
985 "config-version: 8\nauth-dir: {}\naccess:\n api-keys: [client-key]\n",
986 dir.display()
987 ))
988 .unwrap();
989 let rt = crate::testing::runtime(
990 cfg,
991 Vec::new(),
992 cpa_exec::Executors {
993 claude: cpa_exec::claude::ClaudeExecutor::new("http://127.0.0.1:1").unwrap(),
994 codex: Default::default(),
995 devices: Default::default(),
996 openai: Default::default(),
997 google: Default::default(),
998 },
999 );
1000 rt.plugin_runtime()
1002 .register_access(true, vec![("plugin-auth".into(), "p".into())], None);
1003 let request = |key: Option<&str>, body: Body| {
1004 let mut builder = Request::builder().method("POST").uri("/v1/chat/completions");
1005 if let Some(key) = key {
1006 builder = builder.header("authorization", format!("Bearer {key}"));
1007 }
1008 builder.body(body).unwrap()
1009 };
1010 for key in [None, Some("wrong")] {
1011 let big = Body::from(vec![b'x'; crate::MAX_REQUEST_BYTES + 1]);
1012 let (_, result) = authenticate(&rt, request(key, big)).await;
1013 assert_eq!(outcome(&result), (413, "request body too large"), "{key:?}");
1014 }
1015 let (req, result) = authenticate(
1017 &rt,
1018 request(Some("wrong"), Body::from(vec![b'y'; crate::MAX_REQUEST_BYTES])),
1019 )
1020 .await;
1021 assert_eq!(outcome(&result), (401, "Invalid API key"));
1022 let body = axum::body::to_bytes(req.into_body(), usize::MAX).await.unwrap();
1023 assert_eq!(body.len(), crate::MAX_REQUEST_BYTES);
1024 let (_, result) = authenticate(&rt, request(None, Body::from("{}"))).await;
1025 assert_eq!(outcome(&result), (401, MISSING_API_KEY));
1026 let (_, result) = authenticate(&rt, request(Some("client-key"), Body::from("{}"))).await;
1027 assert_eq!(outcome(&result), (200, ""));
1028 let _ = std::fs::remove_dir_all(&dir);
1029 }
1030
1031 #[test]
1036 fn plugin_registered_sonnet_5_5_turns_thinking_off_with_between_tools() {
1037 let thinking_off = |model: &str, thinking: &[u8]| {
1038 let info = model_spec(&cpa_plugin::api::ModelInfo {
1039 id: model.into(),
1040 model_type: "claude".into(),
1041 thinking: Some(cpa_plugin::gojson::from_slice(thinking).unwrap()),
1042 ..Default::default()
1043 })
1044 .to_info();
1045 let body = format!(
1046 r#"{{"model":"{model}","messages":[{{"role":"user","content":"hi"}}],"thinking":{{"type":"disabled"}}}}"#
1047 );
1048 let caps = cpa_common::thinking::ModelCaps::from(&info);
1049 let out = cpa_common::thinking::apply_thinking_with_model_info(
1050 body.as_bytes(),
1051 &[],
1052 model,
1053 "claude",
1054 "claude",
1055 "claude",
1056 Some(&caps),
1057 )
1058 .unwrap();
1059 serde_json::from_slice::<serde_json::Value>(&out).unwrap()["thinking"].clone()
1060 };
1061 let current = br#"{"ZeroAllowed":true,"Levels":["low","medium","high"],"DisableType":"between_tools"}"#;
1062 assert_eq!(
1063 thinking_off("claude-sonnet-5-5", current),
1064 serde_json::json!({"type": "between_tools"})
1065 );
1066 let older = br#"{"ZeroAllowed":true,"Levels":["low","medium","high"]}"#;
1067 assert_eq!(
1068 thinking_off("claude-opus-5-5", older),
1069 serde_json::json!({"type": "disabled"})
1070 );
1071 }
1072}