use std::collections::{HashMap, HashSet};
use std::sync::{Arc, RwLock, Weak};
use axum::body::{Body, Bytes};
use axum::extract::Request;
use axum::http::HeaderMap;
use cpa_common::gostr::GoStr;
use cpa_core::config::Config;
use cpa_core::exec::Caller;
use tokio::sync::watch;
use crate::Runtime;
pub(crate) mod execution;
pub(crate) mod interceptors;
pub(crate) mod model_callbacks;
pub(crate) mod refresh;
pub struct PluginRuntime {
host: cpa_plugin::Host,
latest: watch::Sender<Option<(u64, Arc<Config>)>>,
applied: watch::Sender<u64>,
access: RwLock<Arc<AccessRegistry>>,
executors: RwLock<HashMap<String, cpa_plugin::executor::Adapter>>,
}
impl Default for PluginRuntime {
fn default() -> Self {
Self::with_host(cpa_plugin::Host::new())
}
}
impl PluginRuntime {
pub(crate) fn with_host(host: cpa_plugin::Host) -> Self {
Self {
host,
latest: watch::Sender::new(None),
applied: watch::Sender::new(0),
access: RwLock::default(),
executors: RwLock::default(),
}
}
pub fn host(&self) -> &cpa_plugin::Host {
&self.host
}
pub(crate) fn executor(
&self,
credential: &cpa_core::credential::Credential,
cfg: &Config,
) -> Option<cpa_plugin::executor::Adapter> {
let adapter = {
let executors = self.executors.read().unwrap_or_else(std::sync::PoisonError::into_inner);
executors.get(&credential.provider.trim().go_lower()).cloned()?
};
let compat_names = cpa_core::config::credentials::openai_compat_names(cfg);
(!binds_native(credential, &compat_names)).then_some(adapter)
}
pub(crate) fn has_executor(&self, provider: &str) -> bool {
let executors = self.executors.read().unwrap_or_else(std::sync::PoisonError::into_inner);
executors.contains_key(&provider.trim().go_lower())
}
pub(crate) fn config_published(&self, cfg: Arc<Config>) {
self.latest.send_modify(|latest| {
let seq = latest.as_ref().map_or(1, |(seq, _)| seq + 1);
*latest = Some((seq, cfg));
});
}
fn published_seq(&self) -> u64 {
self.latest.borrow().as_ref().map_or(0, |(seq, _)| *seq)
}
}
pub async fn applied(rt: &Runtime) {
let seq = rt.plugin_runtime().published_seq();
let _ = rt
.plugin_runtime()
.applied
.subscribe()
.wait_for(|applied| *applied >= seq)
.await;
}
pub async fn sync(rt: &Runtime, cfg: Arc<Config>) {
let host = rt.plugins();
host.apply_config(cfg.clone()).await;
let (providers, exclusive) = host.frontend_auth_providers().await;
rt.plugin_runtime()
.register_access(!cfg.api_keys.is_empty(), providers, exclusive);
host.register_management_routes(&reserved_management_routes()).await;
cpa_translate::hooks::set_plugin_hooks(Some(host.translator_hooks()));
cpa_core::config::credentials::set_plugin_auth_parser(Some(host.auth_parser()));
sync_models(rt).await;
}
pub async fn reload_plugin_auth_files(rt: &Arc<Runtime>) {
use cpa_core::config::credentials;
struct EndBootstrap(Arc<Runtime>);
impl Drop for EndBootstrap {
fn drop(&mut self) {
self.0.store().end_bootstrap();
}
}
let end = EndBootstrap(rt.clone());
if !credentials::plugin_auth_parser_active() {
return;
}
let rt = rt.clone();
let reload = tokio::task::spawn_blocking(move || {
let _end = end;
let cfg = rt.config();
credentials::preparse_auth_dir(&cfg);
let scan = credentials::scan_auth_dir(&cfg);
let mut all = scan.credentials;
for existing in rt.store().snapshot() {
if let cpa_core::credential::Source::File(path) = &existing.source
&& scan.incomplete.contains(path)
&& !all.iter().any(|c| c.id == existing.id)
{
all.push(cpa_core::credential::Credential::clone(&existing));
}
}
all.extend(credentials::from_config(&cfg));
rt.store().reconcile_scanned_with(all, &scan.read, |current, all| {
keep_deferred(current, all, &scan.deferred)
});
});
if let Err(e) = reload.await {
tracing::error!(error = %e, "reloading auth files for plugin auth providers failed");
}
}
pub(crate) fn keep_deferred(
current: &[Arc<cpa_core::credential::Credential>],
all: &mut Vec<cpa_core::credential::Credential>,
deferred: &std::collections::HashSet<std::path::PathBuf>,
) {
use cpa_core::credential::{Credential, Source};
if deferred.is_empty() {
return;
}
let absolute = |p: &std::path::Path| std::path::absolute(p).unwrap_or_else(|_| p.to_owned());
let deferred: std::collections::HashSet<_> = deferred.iter().map(|p| absolute(p)).collect();
for existing in current {
if let Source::File(p) = &existing.source
&& deferred.contains(&absolute(p))
&& !all.iter().any(|c| c.id == existing.id)
{
all.push(Credential::clone(existing));
}
}
}
async fn sync_models(rt: &Runtime) {
let host = rt.plugins();
host.register_models().await;
let native = native_executor_providers(rt).await;
for _ in 0..3 {
let registry = rt.registry();
let Some(changes) = host
.register_executors(&|p| native.contains(p), &|m| registry.model_providers(m))
.await
else {
return;
};
*rt.plugin_runtime()
.executors
.write()
.unwrap_or_else(std::sync::PoisonError::into_inner) = changes
.register
.into_iter()
.map(|adapter| (adapter.provider.clone(), adapter))
.collect();
let specs = |models: &[cpa_plugin::api::ModelInfo]| models.iter().map(model_spec).collect::<Vec<_>>();
let changed = cpa_core::registry::dynamic::set_plugin_catalog(cpa_core::registry::dynamic::PluginCatalog {
providers: host
.provider_models()
.iter()
.map(|(provider, models)| (provider.clone(), specs(models)))
.collect(),
clients: changes
.clients
.register
.iter()
.map(|(client, provider, models)| (client.clone(), provider.clone(), specs(models)))
.collect(),
});
if !changed {
return;
}
}
}
const BUILTIN: [&str; 14] = [
"codex",
"claude",
"gemini",
"gemini-interactions",
"vertex",
"aistudio",
"antigravity",
"kimi",
"kimi-ai",
"kimi.ai",
"kimi.com",
"xai",
"devin",
"meta",
];
fn binds_native(c: &cpa_core::credential::Credential, compat_names: &[String]) -> bool {
let attr = |k: &str| c.attributes.get(k).map(|v| v.trim()).unwrap_or_default();
let provider = c.provider.trim().go_lower();
if !attr("compat_name").is_empty() || provider == "openai-compatibility" || BUILTIN.contains(&provider.as_str()) {
return true;
}
let key = if provider.is_empty() {
"openai-compatibility"
} else {
provider.as_str()
};
!attr("base_url").is_empty()
|| [key, &attr("provider_key").go_lower(), &provider]
.iter()
.any(|candidate| !candidate.is_empty() && compat_names.iter().any(|n| n == candidate))
}
async fn native_executor_providers(rt: &Runtime) -> HashSet<String> {
let cfg = rt.config();
let compat_names = cpa_core::config::credentials::openai_compat_names(&cfg);
let host = rt.plugins();
let mut native = HashSet::new();
for c in rt.store().snapshot().iter().filter(|c| !c.disabled) {
let provider = c.provider.trim().go_lower();
let key = if !c.attributes.get("compat_name").is_none_or(|v| v.trim().is_empty())
|| provider == "openai-compatibility"
{
cpa_core::registry::dynamic::provider_key(c)
} else if provider.is_empty() {
"openai-compatibility".to_owned()
} else {
provider
};
if !binds_native(c, &compat_names) && host.has_executor_candidate_provider(&key).await {
continue;
}
native.insert(key);
}
if rt.remote_dispatch().is_some() {
native.extend(
BUILTIN
.iter()
.filter(|p| **p != "kimi.com")
.chain(&["openai-compatibility"])
.map(|p| (*p).to_owned()),
);
}
native
}
#[derive(Debug, Default)]
pub struct SchedulerContext {
pub stream: bool,
pub options: cpa_plugin::api::SchedulerOptions,
}
pub(crate) fn provider_scheduler_context(
rt: &Runtime,
provider: &str,
headers: &HeaderMap,
affinity_model: &str,
metadata: &[(&str, &str)],
) -> Option<Arc<SchedulerContext>> {
if !rt.plugins().has_scheduler() {
return None;
}
let string = |s: &str| serde_json::Value::String(s.to_owned());
let mut out: cpa_plugin::gojson::Metadata = metadata.iter().map(|(k, v)| ((*k).to_owned(), string(v))).collect();
out.insert("session_affinity_provider".into(), string(provider));
out.insert("session_affinity_model".into(), string(affinity_model));
Some(Arc::new(SchedulerContext {
stream: false,
options: cpa_plugin::api::SchedulerOptions {
headers: go_request_header(headers),
metadata: out,
},
}))
}
pub(crate) fn scheduler_request(
rt: &Runtime,
selection: &crate::runtime::Selection,
policy: &crate::scheduler::Policy,
admit: &crate::runtime::Admit<'_>,
) -> Result<Option<cpa_plugin::api::SchedulerPickRequest>, crate::runtime::AcquireError> {
let host = rt.plugins();
if rt.remote_dispatch().is_some() || !host.has_scheduler() {
return Ok(None);
}
let across = host.scheduler_wants_across_priorities();
let candidates = rt.store().scheduler_candidates(selection, policy, admit, across)?;
let mut providers: Vec<String> = Vec::new();
for p in selection.provider_keys() {
let p = p.trim().go_lower();
if !p.is_empty() && p != "mixed" && !providers.contains(&p) {
providers.push(p);
}
}
let context = selection.scheduler.as_deref();
Ok(Some(cpa_plugin::api::SchedulerPickRequest {
provider: if selection.providers.is_empty() {
selection.provider.trim().go_lower()
} else {
String::new()
},
providers,
model: selection.model.clone(),
stream: context.is_some_and(|c| c.stream),
options: context.map(|c| c.options.clone()).unwrap_or_default(),
candidates: candidates
.iter()
.map(|c| cpa_plugin::api::SchedulerAuthCandidate {
id: c.id.clone(),
provider: c.provider.trim().go_lower(),
priority: crate::scheduler::priority(c),
status: "active".into(),
attributes: c
.attributes
.iter()
.filter(|(k, _)| !scheduler_attribute_sensitive(k))
.map(|(k, v)| (k.clone(), v.clone()))
.collect(),
..Default::default()
})
.collect(),
..Default::default()
}))
}
pub(crate) async fn scheduler_pick(
rt: &Runtime,
request: Option<cpa_plugin::api::SchedulerPickRequest>,
) -> Result<crate::runtime::Pick, crate::runtime::AcquireError> {
use crate::runtime::{AcquireError, Pick};
let Some(request) = request else {
return Ok(Pick::Configured);
};
let resp = match rt.plugins().pick_auth(request).await {
Ok(Some(resp)) => resp,
Ok(None) => return Ok(Pick::Configured),
Err(e) => {
return Err(AcquireError::Scheduler(cpa_core::exec::ExecError::local(
e.status(),
cpa_core::exec::FailureScope::Model,
e.to_string(),
)));
}
};
if resp.reject {
return Err(AcquireError::Rejected {
code: resp.reject_code,
message: resp.reject_reason,
});
}
if !resp.auth_id.is_empty() {
return Ok(Pick::Auth(resp.auth_id));
}
Ok(match resp.delegate_builtin.as_str() {
cpa_plugin::api::SCHEDULER_BUILTIN_ROUND_ROBIN => Pick::Builtin(crate::scheduler::Strategy::RoundRobin),
cpa_plugin::api::SCHEDULER_BUILTIN_FILL_FIRST => Pick::Builtin(crate::scheduler::Strategy::FillFirst),
_ => Pick::Configured,
})
}
fn scheduler_attribute_sensitive(key: &str) -> bool {
let key = key.trim().go_lower();
let normalized: String = key
.chars()
.map(|c| if matches!(c, '-' | '.' | ' ') { '_' } else { c })
.collect();
let compact: String = key.chars().filter(|c| !matches!(c, '_' | '-' | '.' | ' ')).collect();
[
"api_key",
"apikey",
"token",
"secret",
"cookie",
"credential",
"password",
"storage",
"authorization",
"auth_header",
"proxy_url",
]
.iter()
.any(|fragment| key.contains(fragment) || normalized.contains(fragment) || compact.contains(fragment))
}
fn model_spec(m: &cpa_plugin::api::ModelInfo) -> cpa_core::registry::dynamic::Spec {
cpa_core::registry::dynamic::Spec {
id: m.id.trim().to_owned(),
object: m.object.clone(),
created: m.created,
owned_by: m.owned_by.clone(),
kind: m.model_type.clone(),
display_name: m.display_name.clone(),
name: m.name.clone(),
version: m.version.clone(),
description: m.description.clone(),
input_token_limit: m.input_token_limit,
output_token_limit: m.output_token_limit,
supported_generation_methods: m.supported_generation_methods.clone(),
context_length: m.context_length,
max_completion_tokens: m.max_completion_tokens,
supported_parameters: m.supported_parameters.clone(),
supported_input_modalities: m.supported_input_modalities.clone(),
supported_output_modalities: m.supported_output_modalities.clone(),
thinking: m.thinking.as_ref().map(|t| cpa_core::registry::ThinkingSupport {
min: t.min,
max: t.max,
zero_allowed: t.zero_allowed,
dynamic_allowed: t.dynamic_allowed,
disable_type: t.disable_type.clone(),
levels: t.levels.clone(),
}),
user_defined: m.user_defined,
..Default::default()
}
}
const CONFIG_PROVIDER_KEY: &str = "config-api-key";
pub(crate) const CONFIG_PROVIDER: &str = "config-inline";
#[derive(Default)]
struct AccessRegistry {
order: Vec<String>,
plugins: HashMap<String, String>,
exclusive: Option<String>,
}
enum Provider<'a> {
ClientKeys,
Plugin(&'a str),
}
impl AccessRegistry {
fn providers(&self, client_keys: bool) -> Vec<Provider<'_>> {
if let Some(id) = self.exclusive.as_ref().and_then(|key| self.plugins.get(key)) {
return vec![Provider::Plugin(id)];
}
let mut out = Vec::with_capacity(self.order.len() + 1);
if client_keys && !self.order.iter().any(|k| k == CONFIG_PROVIDER_KEY) {
out.push(Provider::ClientKeys);
}
for key in &self.order {
if key == CONFIG_PROVIDER_KEY {
if client_keys {
out.push(Provider::ClientKeys);
}
} else if let Some(id) = self.plugins.get(key) {
out.push(Provider::Plugin(id));
}
}
out
}
}
impl PluginRuntime {
fn access(&self) -> Arc<AccessRegistry> {
self.access.read().unwrap_or_else(|e| e.into_inner()).clone()
}
pub(crate) fn register_access(
&self,
client_keys: bool,
providers: Vec<(String, String)>,
exclusive: Option<String>,
) {
let mut slot = self.access.write().unwrap_or_else(|e| e.into_inner());
let mut next = AccessRegistry {
order: slot.order.clone(),
plugins: HashMap::new(),
exclusive,
};
let register = |order: &mut Vec<String>, key: &str| {
if !order.iter().any(|k| k == key) {
order.push(key.to_owned());
}
};
if client_keys {
register(&mut next.order, CONFIG_PROVIDER_KEY);
} else {
next.order.retain(|k| k != CONFIG_PROVIDER_KEY);
}
for (key, id) in providers {
register(&mut next.order, &key);
next.plugins.insert(key, id);
}
next.order
.retain(|k| k == CONFIG_PROVIDER_KEY || next.plugins.contains_key(k));
*slot = Arc::new(next);
}
}
pub(crate) enum Access {
Open,
Granted(Caller),
}
pub(crate) struct Denied {
pub status: u16,
pub message: &'static str,
}
const MISSING_API_KEY: &str = "Missing API key";
pub(crate) async fn authenticate(rt: &Runtime, req: Request) -> (Request, Result<Access, Denied>) {
let config = rt.config();
let registry = rt.plugin_runtime().access();
let providers = registry.providers(!config.api_keys.is_empty());
if providers.is_empty() {
return (req, Ok(Access::Open));
}
let (parts, mut body) = req.into_parts();
let mut read: Option<Bytes> = None;
let mut invalid = false;
let mut outcome = None;
for provider in providers {
match provider {
Provider::ClientKeys => {
match crate::access::authenticate(
&config.api_keys,
&parts.headers,
parts.uri.query().unwrap_or_default(),
) {
Ok(caller) => {
outcome = Some(Ok(Access::Granted(Caller {
provider: CONFIG_PROVIDER.to_owned(),
..caller
})));
break;
}
Err(message) => invalid |= message != MISSING_API_KEY,
}
}
Provider::Plugin(id) => {
let bytes = match &read {
Some(bytes) => bytes.clone(),
None => match read_limited(std::mem::take(&mut body)).await {
Ok(Some(bytes)) => read.insert(bytes).clone(),
Ok(None) => {
outcome = Some(Err(Denied {
status: 413,
message: "request body too large",
}));
break;
}
Err(error) if crate::body_limit::is_too_large(&error) => {
outcome = Some(Err(Denied {
status: 413,
message: crate::body_limit::MESSAGE,
}));
break;
}
Err(error) => {
tracing::error!(
"authentication middleware error: failed to read plugin auth request body: {error}"
);
outcome = Some(Err(Denied {
status: 500,
message: "failed to read plugin auth request body",
}));
break;
}
},
};
let request = cpa_plugin::api::FrontendAuthRequest {
method: parts.method.as_str().to_owned(),
path: crate::management::percent_decode(parts.uri.path()),
headers: go_request_header(&parts.headers),
query: go_values(parts.uri.query().unwrap_or_default()),
body: cpa_plugin::gojson::NonNilBytes(bytes),
};
if let Some(accepted) = rt.plugins().frontend_authenticate(id, &request).await {
outcome = Some(Ok(Access::Granted(Caller {
principal: accepted.principal,
source: "",
provider: accepted.provider,
})));
break;
}
}
}
}
let body = match read {
Some(bytes) => Body::from(bytes),
None => body,
};
let outcome = outcome.unwrap_or(Err(Denied {
status: 401,
message: if invalid { "Invalid API key" } else { MISSING_API_KEY },
}));
(Request::from_parts(parts, body), outcome)
}
async fn read_limited(body: Body) -> Result<Option<Bytes>, axum::Error> {
use futures_util::StreamExt as _;
let mut stream = body.into_data_stream();
let mut out = bytes::BytesMut::new();
while let Some(chunk) = stream.next().await {
let chunk = chunk?;
if out.len() + chunk.len() > crate::MAX_REQUEST_BYTES {
return Ok(None);
}
out.extend_from_slice(&chunk);
}
Ok(Some(out.freeze()))
}
pub(crate) fn go_request_header(headers: &HeaderMap) -> cpa_plugin::gojson::Header {
let chunked = headers.contains_key(axum::http::header::TRANSFER_ENCODING);
let mut out = cpa_plugin::gojson::Header::new();
for (name, value) in headers {
let dropped = name == axum::http::header::HOST
|| (chunked
&& (name == axum::http::header::TRANSFER_ENCODING
|| name == axum::http::header::CONTENT_LENGTH
|| name == axum::http::header::TRAILER));
if dropped {
continue;
}
out.entry(cpa_exec::proxy::canonical_header(name.as_str()))
.or_default()
.push(String::from_utf8_lossy(value.as_bytes()).into_owned());
}
out
}
pub(crate) fn go_values(raw_query: &str) -> cpa_plugin::gojson::Header {
let mut out = cpa_plugin::gojson::Header::new();
for (k, v) in crate::management::go_query(raw_query) {
out.entry(k).or_default().push(v);
}
out
}
pub async fn start(rt: &Arc<Runtime>) {
model_callbacks::attach(rt);
let mut rx = rt.plugin_runtime().latest.subscribe();
rx.mark_unchanged();
let seq = rt.plugin_runtime().published_seq();
sync(rt, rt.config()).await;
rt.plugin_runtime().applied.send_replace(seq);
let weak: Weak<Runtime> = Arc::downgrade(rt);
tokio::spawn(async move {
while rx.changed().await.is_ok() {
let Some((seq, cfg)) = rx.borrow_and_update().clone() else {
continue;
};
let Some(rt) = weak.upgrade() else {
return;
};
sync(&rt, cfg).await;
rt.plugin_runtime().applied.send_replace(seq);
}
});
}
pub fn reserved_management_routes() -> HashSet<String> {
GO_V0_MANAGEMENT_ROUTES.iter().map(|r| (*r).to_owned()).collect()
}
const GO_V0_MANAGEMENT_ROUTES: [&str; 144] = [
"DELETE /v0/management/api-keys",
"DELETE /v0/management/auth-files",
"DELETE /v0/management/claude-api-key",
"DELETE /v0/management/codex-api-key",
"DELETE /v0/management/gemini-api-key",
"DELETE /v0/management/interactions-api-key",
"DELETE /v0/management/logs",
"DELETE /v0/management/meta-api-key",
"DELETE /v0/management/oauth-excluded-models",
"DELETE /v0/management/oauth-model-alias",
"DELETE /v0/management/oauth-request-scoped-errors",
"DELETE /v0/management/oauth-session",
"DELETE /v0/management/openai-compatibility",
"DELETE /v0/management/plugins/:id",
"DELETE /v0/management/plugins/:id/quota",
"DELETE /v0/management/proxy-url",
"DELETE /v0/management/vertex-api-key",
"DELETE /v0/management/xai-api-key",
"GET /v0/management/anthropic-auth-url",
"GET /v0/management/antigravity-auth-url",
"GET /v0/management/api-key-usage",
"GET /v0/management/api-keys",
"GET /v0/management/auth-files",
"GET /v0/management/auth-files/download",
"GET /v0/management/auth-files/models",
"GET /v0/management/claude-api-key",
"GET /v0/management/codex-api-key",
"GET /v0/management/codex-auth-url",
"GET /v0/management/config",
"GET /v0/management/config.yaml",
"GET /v0/management/debug",
"GET /v0/management/devin-auth-url",
"GET /v0/management/error-logs-max-files",
"GET /v0/management/force-model-prefix",
"GET /v0/management/gemini-api-key",
"GET /v0/management/get-auth-status",
"GET /v0/management/interactions-api-key",
"GET /v0/management/kimi-ai-auth-url",
"GET /v0/management/kimi-auth-url",
"GET /v0/management/latest-version",
"GET /v0/management/logging-to-file",
"GET /v0/management/logs",
"GET /v0/management/logs-max-total-size-mb",
"GET /v0/management/max-retry-credentials",
"GET /v0/management/max-retry-interval",
"GET /v0/management/meta-api-key",
"GET /v0/management/meta-auth-url",
"GET /v0/management/model-definitions/:channel",
"GET /v0/management/oauth-callback",
"GET /v0/management/oauth-excluded-models",
"GET /v0/management/oauth-model-alias",
"GET /v0/management/oauth-request-scoped-errors",
"GET /v0/management/openai-compatibility",
"GET /v0/management/plugin-store",
"GET /v0/management/plugins",
"GET /v0/management/plugins/:id/config",
"GET /v0/management/plugins/:id/quota",
"GET /v0/management/proxy-url",
"GET /v0/management/quota-exceeded/switch-preview-model",
"GET /v0/management/quota-exceeded/switch-project",
"GET /v0/management/quota/providers",
"GET /v0/management/request-error-logs",
"GET /v0/management/request-error-logs/:name",
"GET /v0/management/request-log",
"GET /v0/management/request-log-by-id/:id",
"GET /v0/management/request-retry",
"GET /v0/management/routing/strategy",
"GET /v0/management/usage-queue",
"GET /v0/management/usage-statistics-enabled",
"GET /v0/management/vertex-api-key",
"GET /v0/management/ws-auth",
"GET /v0/management/xai-api-key",
"GET /v0/management/xai-auth-url",
"PATCH /v0/management/api-keys",
"PATCH /v0/management/auth-files/fields",
"PATCH /v0/management/auth-files/status",
"PATCH /v0/management/claude-api-key",
"PATCH /v0/management/codex-api-key",
"PATCH /v0/management/debug",
"PATCH /v0/management/error-logs-max-files",
"PATCH /v0/management/force-model-prefix",
"PATCH /v0/management/gemini-api-key",
"PATCH /v0/management/interactions-api-key",
"PATCH /v0/management/logging-to-file",
"PATCH /v0/management/logs-max-total-size-mb",
"PATCH /v0/management/max-retry-credentials",
"PATCH /v0/management/max-retry-interval",
"PATCH /v0/management/meta-api-key",
"PATCH /v0/management/oauth-excluded-models",
"PATCH /v0/management/oauth-model-alias",
"PATCH /v0/management/oauth-request-scoped-errors",
"PATCH /v0/management/openai-compatibility",
"PATCH /v0/management/plugins/:id/config",
"PATCH /v0/management/plugins/:id/enabled",
"PATCH /v0/management/proxy-url",
"PATCH /v0/management/quota-exceeded/switch-preview-model",
"PATCH /v0/management/quota-exceeded/switch-project",
"PATCH /v0/management/request-log",
"PATCH /v0/management/request-retry",
"PATCH /v0/management/routing/strategy",
"PATCH /v0/management/usage-statistics-enabled",
"PATCH /v0/management/vertex-api-key",
"PATCH /v0/management/ws-auth",
"PATCH /v0/management/xai-api-key",
"POST /v0/management/api-call",
"POST /v0/management/auth-files",
"POST /v0/management/auth-files/refresh",
"POST /v0/management/oauth-callback",
"POST /v0/management/plugin-store/:id/install",
"POST /v0/management/plugins/:id/quota",
"POST /v0/management/plugins/:id/quota/reset",
"POST /v0/management/quota/fetch",
"POST /v0/management/quota/reset",
"POST /v0/management/reset-quota",
"POST /v0/management/vertex/import",
"PUT /v0/management/api-keys",
"PUT /v0/management/claude-api-key",
"PUT /v0/management/codex-api-key",
"PUT /v0/management/config.yaml",
"PUT /v0/management/debug",
"PUT /v0/management/error-logs-max-files",
"PUT /v0/management/force-model-prefix",
"PUT /v0/management/gemini-api-key",
"PUT /v0/management/interactions-api-key",
"PUT /v0/management/logging-to-file",
"PUT /v0/management/logs-max-total-size-mb",
"PUT /v0/management/max-retry-credentials",
"PUT /v0/management/max-retry-interval",
"PUT /v0/management/meta-api-key",
"PUT /v0/management/oauth-excluded-models",
"PUT /v0/management/oauth-model-alias",
"PUT /v0/management/oauth-request-scoped-errors",
"PUT /v0/management/openai-compatibility",
"PUT /v0/management/plugins/:id/config",
"PUT /v0/management/proxy-url",
"PUT /v0/management/quota-exceeded/switch-preview-model",
"PUT /v0/management/quota-exceeded/switch-project",
"PUT /v0/management/request-log",
"PUT /v0/management/request-retry",
"PUT /v0/management/routing/strategy",
"PUT /v0/management/usage-statistics-enabled",
"PUT /v0/management/vertex-api-key",
"PUT /v0/management/ws-auth",
"PUT /v0/management/xai-api-key",
];
#[cfg(test)]
mod tests {
use super::*;
fn outcome(result: &Result<Access, Denied>) -> (u16, &'static str) {
match result {
Ok(_) => (200, ""),
Err(denied) => (denied.status, denied.message),
}
}
#[tokio::test]
async fn plugin_auth_reads_a_bounded_body() {
let dir = cpa_plugin::testing::scratch(&std::env::temp_dir(), "plugin-auth-body");
let cfg = Config::parse(&format!(
"config-version: 8\nauth-dir: {}\naccess:\n api-keys: [client-key]\n",
dir.display()
))
.unwrap();
let rt = crate::testing::runtime(
cfg,
Vec::new(),
cpa_exec::Executors {
claude: cpa_exec::claude::ClaudeExecutor::new("http://127.0.0.1:1").unwrap(),
codex: Default::default(),
devices: Default::default(),
openai: Default::default(),
google: Default::default(),
},
);
rt.plugin_runtime()
.register_access(true, vec![("plugin-auth".into(), "p".into())], None);
let request = |key: Option<&str>, body: Body| {
let mut builder = Request::builder().method("POST").uri("/v1/chat/completions");
if let Some(key) = key {
builder = builder.header("authorization", format!("Bearer {key}"));
}
builder.body(body).unwrap()
};
for key in [None, Some("wrong")] {
let big = Body::from(vec![b'x'; crate::MAX_REQUEST_BYTES + 1]);
let (_, result) = authenticate(&rt, request(key, big)).await;
assert_eq!(outcome(&result), (413, "request body too large"), "{key:?}");
}
let (req, result) = authenticate(
&rt,
request(Some("wrong"), Body::from(vec![b'y'; crate::MAX_REQUEST_BYTES])),
)
.await;
assert_eq!(outcome(&result), (401, "Invalid API key"));
let body = axum::body::to_bytes(req.into_body(), usize::MAX).await.unwrap();
assert_eq!(body.len(), crate::MAX_REQUEST_BYTES);
let (_, result) = authenticate(&rt, request(None, Body::from("{}"))).await;
assert_eq!(outcome(&result), (401, MISSING_API_KEY));
let (_, result) = authenticate(&rt, request(Some("client-key"), Body::from("{}"))).await;
assert_eq!(outcome(&result), (200, ""));
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn plugin_registered_sonnet_5_5_turns_thinking_off_with_between_tools() {
let thinking_off = |model: &str, thinking: &[u8]| {
let info = model_spec(&cpa_plugin::api::ModelInfo {
id: model.into(),
model_type: "claude".into(),
thinking: Some(cpa_plugin::gojson::from_slice(thinking).unwrap()),
..Default::default()
})
.to_info();
let body = format!(
r#"{{"model":"{model}","messages":[{{"role":"user","content":"hi"}}],"thinking":{{"type":"disabled"}}}}"#
);
let caps = cpa_common::thinking::ModelCaps::from(&info);
let out = cpa_common::thinking::apply_thinking_with_model_info(
body.as_bytes(),
&[],
model,
"claude",
"claude",
"claude",
Some(&caps),
)
.unwrap();
serde_json::from_slice::<serde_json::Value>(&out).unwrap()["thinking"].clone()
};
let current = br#"{"ZeroAllowed":true,"Levels":["low","medium","high"],"DisableType":"between_tools"}"#;
assert_eq!(
thinking_off("claude-sonnet-5-5", current),
serde_json::json!({"type": "between_tools"})
);
let older = br#"{"ZeroAllowed":true,"Levels":["low","medium","high"]}"#;
assert_eq!(
thinking_off("claude-opus-5-5", older),
serde_json::json!({"type": "disabled"})
);
}
}