use bytes::Bytes;
use cpa_common::gostr::GoStr;
use crate::abi::method;
use crate::api::{
ModelInfo, PayloadResponse, RequestTransformRequest, ResponseTransformRequest, ThinkingApplyRequest,
ThinkingConfig, UsageRecord,
};
use crate::callbacks::RequestScope;
use crate::host::{Host, Inner, Record};
use crate::rpc::Empty;
use std::sync::{Arc, Weak};
pub const NATIVE_THINKING_PROVIDERS: [&str; 11] = [
"gemini",
"claude",
"openai",
"codex",
"antigravity",
"kimi",
"kimi-ai",
"kimi.ai",
"kimi.com",
"xai",
"interactions",
];
#[derive(Debug, Clone, Default)]
pub struct ResponseTransform<'a> {
pub from: &'a str,
pub to: &'a str,
pub model: &'a str,
pub original_request: &'a [u8],
pub translated_request: &'a [u8],
pub stream: bool,
}
impl Host {
fn hook_records(&self, has: impl Fn(&Record) -> bool) -> Vec<Record> {
self.active_records()
.into_iter()
.filter(|r| has(r) && !self.is_fused(&r.id))
.collect()
}
fn transform<R: crate::gojson::GoStruct>(&self, record: &Record, method: &str, req: &R) -> Option<Bytes> {
if !self.live(record) {
return None;
}
match self.call_blocking::<PayloadResponse, _>(record, method, req) {
Ok(resp) if !resp.body.is_empty() => Some(resp.body),
_ => None,
}
}
pub fn normalize_request(&self, from: &str, to: &str, model: &str, body: Bytes, stream: bool) -> Bytes {
let mut current = body;
for record in self.hook_records(|r| r.plugin.caps.request_normalizer) {
let req = RequestTransformRequest {
from_format: from.into(),
to_format: to.into(),
model: model.into(),
stream,
body: current.clone(),
};
if let Some(out) = self.transform(&record, method::REQUEST_NORMALIZE, &req) {
current = out;
}
}
current
}
pub fn translate_request(&self, from: &str, to: &str, model: &str, body: &Bytes, stream: bool) -> Option<Bytes> {
for record in self.hook_records(|r| r.plugin.caps.request_translator) {
let req = RequestTransformRequest {
from_format: from.into(),
to_format: to.into(),
model: model.into(),
stream,
body: body.clone(),
};
if let Some(out) = self.transform(&record, method::REQUEST_TRANSLATE, &req) {
return Some(out);
}
}
None
}
fn response_request(t: &ResponseTransform<'_>, body: Bytes) -> ResponseTransformRequest {
ResponseTransformRequest {
from_format: t.from.into(),
to_format: t.to.into(),
model: t.model.into(),
stream: t.stream,
original_request: Bytes::copy_from_slice(t.original_request),
translated_request: Bytes::copy_from_slice(t.translated_request),
body,
}
}
pub fn normalize_response_before(&self, t: &ResponseTransform<'_>, body: Bytes) -> Bytes {
let mut current = body;
for record in self.hook_records(|r| r.plugin.caps.response_before_translator) {
let req = Self::response_request(t, current.clone());
if let Some(out) = self.transform(&record, method::RESPONSE_NORMALIZE_BEFORE, &req) {
current = out;
}
}
current
}
pub fn translate_response(&self, t: &ResponseTransform<'_>, body: &Bytes) -> Option<Bytes> {
for record in self.hook_records(|r| r.plugin.caps.response_translator) {
let req = Self::response_request(t, body.clone());
if let Some(out) = self.transform(&record, method::RESPONSE_TRANSLATE, &req) {
return Some(out);
}
}
None
}
pub fn normalize_response_after(&self, t: &ResponseTransform<'_>, body: Bytes) -> Bytes {
let mut current = body;
for record in self.hook_records(|r| r.plugin.caps.response_after_translator) {
let req = Self::response_request(t, current.clone());
if let Some(out) = self.transform(&record, method::RESPONSE_NORMALIZE_AFTER, &req) {
current = out;
}
}
current
}
pub fn has_response_translator(&self) -> bool {
!self.hook_records(|r| r.plugin.caps.response_translator).is_empty()
}
pub(crate) async fn refresh_thinking_providers(&self) {
let mut providers: std::collections::BTreeMap<String, (String, i64)> = Default::default();
for record in self.hook_records(|r| r.plugin.caps.thinking_applier) {
let identifier = crate::rpc::identifier(&record.client, method::THINKING_IDENTIFIER)
.await
.go_lower();
if identifier.is_empty() || NATIVE_THINKING_PROVIDERS.contains(&identifier.as_str()) {
continue;
}
let replace = match providers.get(&identifier) {
None => true,
Some((owner, priority)) => {
record.priority > *priority || (record.priority == *priority && record.id < *owner)
}
};
if replace {
providers.insert(identifier, (record.id.clone(), record.priority));
}
}
cpa_common::thinking::clear_plugin_providers();
for (provider, (owner, priority)) in &providers {
let applier = Arc::new(ThinkingAdapter {
host: Arc::downgrade(&self.inner),
provider: provider.clone(),
});
cpa_common::thinking::register_plugin_provider(owner, provider, *priority, applier);
}
self.state().thinking_providers = providers.into_iter().map(|(k, (owner, _))| (k, owner)).collect();
}
pub fn thinking_provider(&self, provider: &str) -> Option<String> {
self.state()
.thinking_providers
.get(&provider.trim().go_lower())
.cloned()
}
pub fn apply_thinking(
&self,
provider: &str,
model: ModelInfo,
config: ThinkingConfig,
body: Bytes,
scope: &RequestScope,
) -> Bytes {
let Some(owner) = self.thinking_provider(provider) else {
return body;
};
let Some(record) = self.record(&owner) else {
return body;
};
let req = ThinkingApplyRequest {
provider: provider.trim().go_lower(),
model,
config,
body: body.clone(),
};
match self.call_with_callback_blocking::<PayloadResponse, _>(&record, method::THINKING_APPLY, &req, scope) {
Ok(resp) if !resp.body.is_empty() => resp.body,
_ => body,
}
}
pub fn publish_usage(&self, record: UsageRecord) {
for plugin in self.hook_records(|r| r.plugin.caps.usage_plugin) {
let host = self.clone();
let record = record.clone();
tokio::spawn(async move {
let Some(plugin) = host.record(&plugin.id).filter(|r| r.plugin.caps.usage_plugin) else {
return;
};
if let Err(e) = host.call::<Empty, _>(&plugin, method::USAGE_HANDLE, &record).await {
tracing::debug!("pluginhost: usage.handle to {} failed: {e}", plugin.id);
}
});
}
}
pub fn has_usage_plugins(&self) -> bool {
!self.hook_records(|r| r.plugin.caps.usage_plugin).is_empty()
}
}
pub fn usage_session_ids(
record_session: &str,
record_parent: &str,
client_session: &str,
client_parent: &str,
) -> (String, String) {
let mut session = record_session.trim().to_owned();
let mut parent = record_parent.trim().to_owned();
if session.is_empty() {
session = client_session.trim().to_owned();
parent = client_parent.trim().to_owned();
} else if parent.is_empty() && session == client_session.trim() {
parent = client_parent.trim().to_owned();
}
if session.is_empty() || session == parent {
parent.clear();
}
(session, parent)
}
fn translator_hook(r: &Record) -> bool {
let c = &r.plugin.caps;
c.request_normalizer
|| c.request_translator
|| c.response_before_translator
|| c.response_translator
|| c.response_after_translator
}
impl Host {
pub fn translator_hooks(&self) -> Arc<dyn cpa_translate::hooks::Hooks> {
self.inner
.hooks_installed
.store(true, std::sync::atomic::Ordering::Release);
let state = self.state();
self.publish_hook_activity(&state, &self.snapshot().records);
drop(state);
Arc::new(TranslatorHooks(Arc::downgrade(&self.inner)))
}
pub(crate) fn publish_hook_activity(&self, state: &crate::host::State, records: &[Record]) {
use std::sync::atomic::Ordering;
let offers = |has: fn(&Record) -> bool| records.iter().any(|r| has(r) && !state.fused.contains_key(&r.id));
if self.inner.hooks_installed.load(Ordering::Acquire) {
cpa_translate::hooks::set_plugin_hooks_active(offers(translator_hook));
}
if self.inner.auth_parser_installed.load(Ordering::Acquire) {
use std::hash::{Hash, Hasher};
let mut providers = records
.iter()
.filter(|r| r.plugin.caps.auth_provider && !state.fused.contains_key(&r.id))
.peekable();
let signature = providers.peek().is_some().then(|| {
let mut hasher = std::collections::hash_map::DefaultHasher::new();
for r in providers {
r.id.hash(&mut hasher);
(Arc::as_ptr(&r.client) as usize).hash(&mut hasher);
state.loaded.get(&r.id).map(|lp| &lp.config_yaml).hash(&mut hasher);
crate::host::normalize_provider(&r.plugin.auth_identifier).hash(&mut hasher);
}
let summary = state.config.as_deref().map(crate::auth::host_config_summary_of);
summary.map(|s| crate::gojson::to_vec(&s)).hash(&mut hasher);
hasher.finish()
});
cpa_core::config::credentials::set_plugin_auth_providers(signature);
}
}
fn offers(&self, has: impl Fn(&Record) -> bool) -> bool {
self.snapshot().records.iter().any(|r| has(r) && !self.is_fused(&r.id))
}
}
struct TranslatorHooks(Weak<Inner>);
impl TranslatorHooks {
fn host(&self, has: impl Fn(&Record) -> bool) -> Option<Host> {
let host = Host {
inner: self.0.upgrade()?,
};
host.offers(has).then_some(host)
}
}
fn response_transform<'a>(t: &'a cpa_translate::hooks::Response<'a>) -> ResponseTransform<'a> {
ResponseTransform {
from: t.from,
to: t.to,
model: t.model,
original_request: t.original_request,
translated_request: t.translated_request,
stream: t.stream,
}
}
impl cpa_translate::hooks::Hooks for TranslatorHooks {
fn normalize_request(&self, from: &str, to: &str, model: &str, body: &[u8], stream: bool) -> Option<Vec<u8>> {
let host = self.host(|r| r.plugin.caps.request_normalizer)?;
Some(
host.normalize_request(from, to, model, Bytes::copy_from_slice(body), stream)
.to_vec(),
)
}
fn translate_request(&self, from: &str, to: &str, model: &str, body: &[u8], stream: bool) -> Option<Vec<u8>> {
let host = self.host(|r| r.plugin.caps.request_translator)?;
host.translate_request(from, to, model, &Bytes::copy_from_slice(body), stream)
.map(|b| b.to_vec())
}
fn normalize_response_before(&self, t: &cpa_translate::hooks::Response<'_>, body: &[u8]) -> Option<Vec<u8>> {
let host = self.host(|r| r.plugin.caps.response_before_translator)?;
Some(
host.normalize_response_before(&response_transform(t), Bytes::copy_from_slice(body))
.to_vec(),
)
}
fn translate_response(&self, t: &cpa_translate::hooks::Response<'_>, body: &[u8]) -> Option<Vec<u8>> {
let host = self.host(|r| r.plugin.caps.response_translator)?;
host.translate_response(&response_transform(t), &Bytes::copy_from_slice(body))
.map(|b| b.to_vec())
}
fn normalize_response_after(&self, t: &cpa_translate::hooks::Response<'_>, body: &[u8]) -> Option<Vec<u8>> {
let host = self.host(|r| r.plugin.caps.response_after_translator)?;
Some(
host.normalize_response_after(&response_transform(t), Bytes::copy_from_slice(body))
.to_vec(),
)
}
}
struct ThinkingAdapter {
host: Weak<Inner>,
provider: String,
}
impl cpa_common::thinking::PluginApplier for ThinkingAdapter {
fn apply(
&self,
body: &[u8],
config: &cpa_common::thinking::Config,
info: Option<&cpa_common::thinking::ModelCaps>,
) -> Result<Vec<u8>, cpa_common::thinking::Error> {
let Some(inner) = self.host.upgrade() else {
return Ok(body.to_vec());
};
let config = ThinkingConfig {
mode: config.mode.as_str().to_owned(),
budget: config.budget,
level: config.level.clone(),
};
let out = Host { inner }.apply_thinking(
&self.provider,
plugin_model_info(info),
config,
Bytes::copy_from_slice(body),
&RequestScope::default(),
);
Ok(out.to_vec())
}
}
fn plugin_model_info(info: Option<&cpa_common::thinking::ModelCaps>) -> ModelInfo {
let Some(info) = info else {
return ModelInfo::default();
};
ModelInfo {
id: info.id.clone(),
model_type: info.kind.clone(),
max_completion_tokens: info.max_completion_tokens,
thinking: info.thinking.as_ref().map(|t| crate::api::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: info.user_defined,
..Default::default()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn plugin_model_info_keeps_the_disable_type() {
let caps = cpa_common::thinking::ModelCaps {
id: "m".into(),
thinking: Some(cpa_core::registry::ThinkingSupport {
levels: vec!["low".into()],
disable_type: "between_tools".into(),
..Default::default()
}),
..Default::default()
};
let got = plugin_model_info(Some(&caps)).thinking.unwrap();
assert_eq!(got.disable_type, "between_tools");
}
#[test]
fn usage_sessions_follow_the_go_adapter() {
assert_eq!(usage_session_ids("", "", " c ", "p"), ("c".into(), "p".into()));
assert_eq!(usage_session_ids("s", "", "s", "p"), ("s".into(), "p".into()));
assert_eq!(usage_session_ids("s", "", "other", "p"), ("s".into(), "".into()));
assert_eq!(usage_session_ids("s", "s", "", ""), ("s".into(), "".into()));
assert_eq!(usage_session_ids("", "x", "", ""), ("".into(), "".into()));
}
}