use std::collections::VecDeque;
use axum::body::Bytes;
use axum::http::{HeaderMap, HeaderName, HeaderValue};
use cpa_core::exec::{ExecError, ExecStream, FailureScope, Operation};
use cpa_core::format::Format;
use cpa_plugin::api::{ExecutorRequest, ModelRouteRequest};
use cpa_plugin::callbacks::RequestScope;
use cpa_plugin::executor::Negotiated;
use cpa_plugin::gojson::{Header, Metadata};
use cpa_plugin::rpc::CallError;
use cpa_plugin::streams::Chunk;
use futures_util::StreamExt;
use futures_util::stream::BoxStream;
use serde_json::Value;
use crate::Runtime;
use crate::dispatch::{Call, Done, Failure, Trace};
pub(crate) enum Route {
Executor(String),
Provider { provider: String, model: Option<String> },
}
tokio::task_local! {
static QUERY: String;
}
pub(crate) async fn with_query<F: std::future::Future>(query: &str, f: F) -> F::Output {
QUERY.scope(query.to_owned(), f).await
}
pub(crate) fn query() -> String {
QUERY.try_with(Clone::clone).unwrap_or_default()
}
struct Scope(RequestScope);
impl Scope {
fn new(trace: &Trace, call: &Call) -> Self {
let inherited = super::model_callbacks::context().map(|c| c.scope).unwrap_or_default();
let (api_key, access_provider) = super::model_callbacks::usage_identity(Some(&call.caller), &inherited);
Self(RequestScope {
request_id: trace.request_id(),
capture: trace.capture(),
cancel: inherited.cancel.child_token(),
headers: super::go_request_header(&call.headers),
query: super::go_values(&query()),
pinned_auth_id: call.pinned(),
execution_session: call.execution_session.clone(),
request_path: call.request_path.clone(),
api_key,
access_provider,
})
}
}
impl Drop for Scope {
fn drop(&mut self) {
self.0.cancel.cancel();
}
}
pub(crate) fn handler_type(call: &Call) -> &'static str {
match call.media.as_ref().map(|m| m.kind) {
Some(crate::dispatch::MediaKind::Images) => "openai-image",
Some(crate::dispatch::MediaKind::Videos) => "openai-video",
Some(crate::dispatch::MediaKind::Speech) => "openai-speech",
None => call.entry.as_str(),
}
}
pub(crate) fn response_type(call: &Call) -> &'static str {
if call.media.is_some() {
handler_type(call)
} else {
call.response.as_str()
}
}
fn request_metadata(call: &Call) -> Metadata {
let mut meta = Metadata::new();
let idempotency = call
.headers
.get("idempotency-key")
.map(|v| String::from_utf8_lossy(v.as_bytes()).trim().to_owned())
.unwrap_or_default();
if !idempotency.is_empty() {
meta.insert("idempotency_key".into(), Value::String(idempotency));
}
let path = call.request_path.trim();
if !path.is_empty() {
meta.insert("request_path".into(), Value::String(path.to_owned()));
}
if let Some(pinned) = call.pinned().filter(|p| !p.is_empty()) {
meta.insert("pinned_auth_id".into(), Value::String(pinned.to_owned()));
}
if let Some(session) = call.execution_session.as_deref().filter(|s| !s.is_empty()) {
meta.insert("execution_session_id".into(), Value::String(session.to_owned()));
}
let scope = cpa_common::session::caller_scope(&call.caller.principal);
if !scope.is_empty() {
meta.insert("caller_scope".into(), Value::String(scope));
}
meta
}
fn available_providers(rt: &Runtime) -> Vec<String> {
let mut out: Vec<String> = rt
.store()
.snapshot()
.iter()
.filter(|c| !c.disabled)
.map(|c| crate::registry::provider_key(c))
.filter(|p| !p.is_empty())
.collect();
out.sort();
out.dedup();
out
}
pub(crate) async fn route(rt: &Runtime, call: &Call, query: &str, trace: &Trace) -> Option<Route> {
let host = rt.plugins();
let skip = super::model_callbacks::skip_plugin();
if !host.has_model_routers(&skip) {
return None;
}
let mut metadata = request_metadata(call);
metadata.insert("requested_model".into(), Value::String(call.model.clone()));
let request = ModelRouteRequest {
source_format: handler_type(call).to_owned(),
requested_model: call.model.clone(),
stream: call.stream,
headers: super::go_request_header(&call.headers),
query: super::go_values(query),
body: call.body.clone(),
metadata,
..Default::default()
};
let scope = Scope::new(trace, call);
let resp = host
.route_model(request, &skip, &available_providers(rt), &scope.0)
.await?;
Some(match resp.target_kind.as_str() {
"provider" => Route::Provider {
provider: resp.target,
model: Some(resp.target_model.trim().to_owned()).filter(|m| !m.is_empty()),
},
_ => Route::Executor(resp.target),
})
}
fn local(status: u16, message: impl Into<String>) -> Failure {
Failure::Exec(ExecError::local(status, FailureScope::Request, message))
}
fn call_failure(e: CallError) -> Failure {
local(e.status(), e.to_string())
}
pub(crate) async fn execute(
rt: &Runtime,
call: &Call,
plugin_id: &str,
query: &str,
trace: &Trace,
) -> Result<Done, Failure> {
if rt.remote_dispatch().is_some() {
return Err(local(
503,
"plugin executor routing is unavailable while Home is enabled",
));
}
let mut call = call.clone();
let model = call.model.clone();
let hooks = super::interceptors::start(rt, trace, &mut call, &model).await?;
let result = run_executor(rt, &mut call, plugin_id, query, trace, hooks.as_deref()).await;
let result = match hooks {
Some(hooks) => {
let result = hooks.prime(result, trace).await;
hooks.finish(result, trace).await
}
None => result,
};
match result {
Ok(Done::Stream { headers, first, rest })
if call.response == Format::OpenAI
&& call.media.is_none()
&& super::model_callbacks::context().is_none() =>
{
Ok(Done::Stream {
headers,
first: first.and_then(|f| openai_frame(&f)),
rest: rest
.filter_map(|item| async move {
match item {
Ok(chunk) => openai_frame(&chunk).map(Ok),
Err(e) => Some(Err(e)),
}
})
.boxed(),
})
}
other => other,
}
}
fn openai_frame(chunk: &Bytes) -> Option<Bytes> {
cpa_translate::stream::frame(Format::OpenAI, chunk).map(Bytes::from)
}
async fn run_executor(
rt: &Runtime,
call: &mut Call,
plugin_id: &str,
query: &str,
trace: &Trace,
hooks: Option<&super::interceptors::Hooks>,
) -> Result<Done, Failure> {
let host = rt.plugins();
let count = call.operation == Operation::CountTokens;
let stream = call.stream && !count;
let tool_search = cpa_exec::claude::tool_search_enabled(&rt.config());
let response = if count { handler_type(call) } else { response_type(call) };
let adapter = host.executor_adapter(plugin_id).await.map_err(|e| local(0, e))?;
let negotiated = adapter
.negotiate(handler_type(call), response, host.has_response_translator())
.map_err(|e| local(0, e))?;
if let Some(hooks) = hooks {
hooks.after_plugin_route(&negotiated.input, call).await?;
}
let payload = if negotiated.input_requested == negotiated.input {
call.body.clone()
} else {
translate_request(
&negotiated.input_requested,
&negotiated.input,
&call.model,
&call.body,
stream,
tool_search,
)
.map_err(Failure::Exec)?
};
let request = ExecutorRequest {
model: call.model.clone(),
format: negotiated.output.clone(),
stream,
alt: call.alt.clone().unwrap_or_default(),
headers: super::go_request_header(&call.headers),
query: super::go_values(query),
original_request: call.body.clone(),
source_format: negotiated.input.clone(),
payload,
metadata: execution_metadata(call, &call.model),
..Default::default()
};
let scope = Scope::new(trace, call);
if !stream {
let resp = if count {
host.executor_count_tokens(&adapter, &request, &scope.0).await
} else {
host.executor_execute(&adapter, &request, &scope.0).await
}
.map_err(call_failure)?;
return Ok(Done::Buffered {
headers: header_map(&resp.headers),
body: translate_response(&negotiated, &request, resp.payload, tool_search),
});
}
let opened = host
.executor_execute_stream(&adapter, &request, &scope.0)
.await
.map_err(call_failure)?;
let mut rest = translate_stream(
negotiated,
request,
opened.chunks,
scope,
|error| ExecError::local(0, FailureScope::Request, error),
None,
tool_search,
);
let first = match rest.next().await {
Some(Ok(event)) => Some(event),
Some(Err(error)) => return Err(Failure::Exec(error)),
None => None,
};
Ok(Done::Stream {
headers: header_map(&opened.headers),
first,
rest,
})
}
pub(crate) async fn execute_credential(
rt: &Runtime,
call: &Call,
adapter: &cpa_plugin::executor::Adapter,
credential: &cpa_core::credential::Credential,
private: &[String],
req: cpa_core::exec::ExecRequest,
) -> Result<cpa_core::exec::ExecResponse, ExecError> {
let host = rt.plugins();
let count = req.operation == Operation::CountTokens;
let stream = req.stream && !count;
let tool_search = cpa_exec::claude::tool_search_enabled(&rt.config());
let source = handler_type(call);
let response = if count { source } else { response_type(call) };
if !count {
req.usage.plugin_executor(&adapter.provider);
}
let negotiated = adapter
.negotiate(source, response, host.has_response_translator())
.map_err(|e| attempt_error(0, e))?;
let payload = if negotiated.input_requested == negotiated.input {
req.body.clone()
} else {
translate_request(
&negotiated.input_requested,
&negotiated.input,
&req.model,
&req.body,
stream,
tool_search,
)?
};
let auth_metadata: Metadata = credential.metadata.clone().into_iter().collect();
let mut metadata = execution_metadata(call, &req.model);
if !req.request_path.trim().is_empty() {
metadata.insert("request_path".into(), Value::String(req.request_path.trim().to_owned()));
}
let request = ExecutorRequest {
auth_id: credential.id.clone(),
auth_provider: credential.provider.clone(),
model: req.model.clone(),
format: negotiated.output.clone(),
stream,
alt: req.alt.clone().unwrap_or_default(),
headers: super::go_request_header(&req.headers),
query: super::go_values(&query()),
original_request: req.original_body.clone(),
source_format: negotiated.input.clone(),
payload,
metadata,
storage_json: Bytes::from(cpa_plugin::gojson::to_vec(&auth_metadata)),
auth_metadata,
auth_attributes: plugin_attributes(credential, private),
};
let inherited = super::model_callbacks::context().map(|c| c.scope).unwrap_or_default();
let (api_key, access_provider) = super::model_callbacks::usage_identity(Some(&call.caller), &inherited);
let scope = Scope(RequestScope {
request_id: crate::observability::current_request_id().unwrap_or_default(),
capture: req.capture().clone(),
cancel: inherited.cancel.child_token(),
headers: super::go_request_header(&req.headers),
query: super::go_values(&query()),
pinned_auth_id: call.pinned(),
execution_session: call.execution_session.clone(),
request_path: req.request_path.clone(),
api_key,
access_provider,
});
if !count {
req.usage.request_for(&negotiated.input, &request.payload);
req.usage.round_trip_started();
}
if !stream {
let resp = if count {
host.executor_count_tokens(adapter, &request, &scope.0).await
} else {
host.executor_execute(adapter, &request, &scope.0).await
}
.map_err(|e| attempt_error(e.status(), e.to_string()))?;
if !count {
req.usage.token_event(false);
req.usage.plugin_response_body(&negotiated.output, &resp.payload);
req.usage.publish();
}
return Ok(cpa_core::exec::ExecResponse {
status: 200,
headers: header_map(&resp.headers),
body: cpa_core::exec::ResponseBody::Buffered(translate_response(
&negotiated,
&request,
resp.payload,
tool_search,
)),
});
}
let opened = host
.executor_execute_stream(adapter, &request, &scope.0)
.await
.map_err(|e| attempt_error(e.status(), e.to_string()))?;
let headers = header_map(&opened.headers);
Ok(cpa_core::exec::ExecResponse {
status: 200,
headers,
body: cpa_core::exec::ResponseBody::Stream(translate_stream(
negotiated,
request,
opened.chunks,
scope,
|error| attempt_error(0, error),
Some(req.usage.clone()),
tool_search,
)),
})
}
fn attempt_error(status: u16, message: impl Into<String>) -> ExecError {
ExecError::local(status, FailureScope::Model, message)
}
pub(crate) fn scheduler_context(
call: &Call,
model: &str,
session_affinity: bool,
derived: Option<&str>,
) -> super::SchedulerContext {
let mut metadata = execution_metadata(call, model);
let bound = |s: &str| Value::String(cpa_common::session::bound_session_identity(s));
let execution = call
.execution_session
.as_deref()
.map(cpa_common::session::normalize_explicit_id)
.unwrap_or_default();
if cpa_common::session::has_explicit_session(&call.headers, &call.body) {
let execution = (!execution.is_empty()).then_some(execution.as_str());
if let Some(info) = cpa_common::session::extract_session_info(&call.headers, &call.body, execution)
.filter(|info| !info.session_id.is_empty())
{
metadata.insert("canonical_session_id".into(), bound(&info.session_id));
if !info.parent_session_id.is_empty() && info.parent_session_id != info.session_id {
metadata.insert("parent_session_id".into(), bound(&info.parent_session_id));
}
}
} else if !execution.is_empty() {
metadata.insert("canonical_session_id".into(), bound(&format!("execution:{execution}")));
} else if let Some(derived) = derived.filter(|d| !d.is_empty()) {
metadata.insert("derived_session_id".into(), Value::String(derived.to_owned()));
}
metadata.insert("session_affinity_provider".into(), Value::String("mixed".into()));
let affinity_model = if session_affinity {
model.to_owned()
} else {
String::new()
};
metadata.insert("session_affinity_model".into(), Value::String(affinity_model));
super::SchedulerContext {
stream: call.stream,
options: cpa_plugin::api::SchedulerOptions {
headers: super::go_request_header(&call.headers),
metadata,
},
}
}
pub(crate) fn execution_metadata(call: &Call, model: &str) -> Metadata {
let mut meta = request_metadata(call);
if super::model_callbacks::context().is_some() {
meta.insert("source".into(), Value::String("plugin_host_model_callback".into()));
}
meta.insert("requested_model".into(), Value::String(call.model.clone()));
if let Some(model) = call.selection_model.as_deref().map(str::trim).filter(|m| !m.is_empty()) {
meta.insert("auth_selection_model".into(), Value::String(model.to_owned()));
}
let effort = cpa_common::thinking::extract_reasoning_effort(&call.body, handler_type(call), model);
if !effort.is_empty() {
meta.insert("reasoning_effort".into(), Value::String(effort));
}
let tier = cpa_common::json::get(&call.body, "service_tier");
let tier = if tier.exists() {
tier.str().trim().to_owned()
} else {
String::new()
};
let tier = if tier.is_empty() { "auto".to_owned() } else { tier };
meta.insert("service_tier".into(), Value::String(tier));
let generate = cpa_common::json::get(&call.body, "generate");
let generate = !(generate.exists() && generate.is_bool() && generate.bytes().as_ref() == b"false");
meta.insert("generate".into(), Value::Bool(generate));
meta
}
fn translate_request(
from: &str,
to: &str,
model: &str,
body: &Bytes,
stream: bool,
tool_search: bool,
) -> Result<Bytes, ExecError> {
let ctx = cpa_translate::RequestCtx {
model,
stream,
tool_search,
};
cpa_translate::translate_request_named(from, to, &ctx, body)
.map(Bytes::from)
.map_err(|e| ExecError::local(400, FailureScope::Request, e.to_string()))
}
fn header_map(headers: &Header) -> HeaderMap {
let mut out = HeaderMap::new();
for (name, values) in headers {
let Ok(name) = HeaderName::try_from(name.as_str()) else {
continue;
};
for value in values {
if let Ok(value) = HeaderValue::from_str(value) {
out.append(name.clone(), value);
}
}
}
out
}
fn ensure_usage(responses: bool, payload: Bytes) -> Bytes {
if responses {
Bytes::from(cpa_exec::ensure_responses_usage_details(&payload))
} else {
payload
}
}
fn translate_response(n: &Negotiated, req: &ExecutorRequest, payload: Bytes, tool_search: bool) -> Bytes {
let responses = n.requested == Format::OpenAIResponse.as_str();
if n.requested.is_empty() || n.output == n.requested {
return ensure_usage(responses, payload);
}
let pair = Format::parse(&n.requested)
.zip(Format::parse(&n.output))
.and_then(|(to, from)| cpa_translate::pair(to, from));
let original = if req.original_request.is_empty() {
&req.payload
} else {
&req.original_request
};
let ctx = cpa_translate::ResponseCtx {
model: &req.model,
original_request: original,
translated_request: &req.payload,
tool_search,
};
let out = match pair {
Some(pair) => (pair.non_stream)(&ctx, &payload).map(Bytes::from).unwrap_or(payload),
None => cpa_translate::hooks::unregistered_non_stream(&n.output, &n.requested, &ctx, &payload)
.map_or(payload, Bytes::from),
};
ensure_usage(responses, out)
}
fn translate_stream(
n: Negotiated,
req: ExecutorRequest,
chunks: BoxStream<'static, Chunk>,
scope: Scope,
chunk_error: fn(String) -> ExecError,
usage: Option<cpa_core::exec::UsageSink>,
tool_search: bool,
) -> ExecStream {
let translating = !n.requested.is_empty() && n.output != n.requested;
let native = translating
&& Format::parse(&n.requested)
.zip(Format::parse(&n.output))
.is_some_and(|(to, from)| cpa_translate::go_stream(to, from).is_some());
let translator = translating
.then(|| {
let original = if req.original_request.is_empty() {
&req.payload
} else {
&req.original_request
};
let ctx = cpa_translate::ResponseCtx {
model: &req.model,
original_request: original,
translated_request: &req.payload,
tool_search,
};
cpa_translate::hooked_go_stream(&n.requested, &n.output, &ctx)
})
.flatten();
let usage = usage.map(|sink| StreamUsage {
sink,
protocol: n.output.clone(),
buffer: Vec::new(),
scan: JsonScan::default(),
ended: false,
});
let state = StreamState {
usage,
native,
translator,
passthrough: n.requested.is_empty()
|| (n.output == n.requested && n.requested != Format::OpenAIResponse.as_str()),
responses: n.requested == Format::OpenAIResponse.as_str(),
openai_tail: translating && n.output == Format::OpenAI.as_str(),
chunks,
ready: VecDeque::new(),
done: false,
chunk_error,
_scope: scope,
};
Box::pin(futures_util::stream::unfold(state, |mut s| async move {
loop {
if let Some(item) = s.ready.pop_front() {
return Some((item, s));
}
if s.done {
return None;
}
match s.chunks.next().await {
Some(chunk) => {
if let Some(usage) = &mut s.usage {
match &chunk.error {
Some(error) => usage.end(Some(error)),
None => usage.chunk(&chunk.payload),
}
}
if !chunk.payload.is_empty() {
for frame in s.frames(&chunk.payload) {
s.push(frame);
}
}
if let Some(error) = chunk.error {
s.ready.push_back(Err((s.chunk_error)(error)));
s.done = true;
}
}
None => {
if let Some(usage) = &mut s.usage {
usage.end(None);
}
if s.openai_tail {
for frame in s.frames(b"data: [DONE]") {
s.push(frame);
}
}
s.done = true;
}
}
}
}))
}
struct StreamUsage {
sink: cpa_core::exec::UsageSink,
protocol: String,
buffer: Vec<u8>,
scan: JsonScan,
ended: bool,
}
#[derive(Default)]
struct JsonScan {
offset: usize,
depth: usize,
in_string: bool,
escaped: bool,
opened: bool,
last: u8,
broken: bool,
}
impl JsonScan {
fn advance(&mut self, buffer: &[u8]) -> bool {
for &b in &buffer[self.offset..] {
if !b.is_ascii_whitespace() {
self.last = b;
}
if self.in_string {
match b {
_ if self.escaped => self.escaped = false,
b'\\' => self.escaped = true,
b'"' => self.in_string = false,
_ => {}
}
continue;
}
match b {
b'"' => self.in_string = true,
b'{' | b'[' => {
self.depth += 1;
self.opened = true;
}
b'}' | b']' => match self.depth.checked_sub(1) {
Some(depth) => self.depth = depth,
None => self.broken = true,
},
_ => {}
}
}
self.offset = buffer.len();
!self.broken && self.opened && self.depth == 0 && !self.in_string && matches!(self.last, b'}' | b']')
}
}
impl StreamUsage {
fn chunk(&mut self, payload: &[u8]) {
if payload.is_empty() || self.ended {
return;
}
self.sink.token_event(false);
let start = self.buffer.len();
self.buffer.extend_from_slice(payload);
if let Some(end) = payload.iter().rposition(|b| *b == b'\n') {
let rest = self.buffer.split_off(start + end + 1);
let lines = std::mem::replace(&mut self.buffer, rest);
self.lines(&lines);
self.scan = JsonScan::default();
}
if self.scan.advance(&self.buffer) {
if extract_stream_json(&self.buffer).is_some_and(cpa_common::json::std_valid) {
let rest = std::mem::take(&mut self.buffer);
self.scan = JsonScan::default();
self.lines(&rest);
} else {
self.scan.broken = true;
}
}
}
fn lines(&self, payload: &[u8]) {
for line in payload.split(|b| *b == b'\n') {
let line = line.trim_ascii();
if !line.is_empty() {
self.sink.plugin_response_line(&self.protocol, line);
}
}
}
fn end(&mut self, error: Option<&str>) {
if std::mem::replace(&mut self.ended, true) {
return;
}
let rest = std::mem::take(&mut self.buffer);
self.lines(&rest);
match error {
Some(error) => self.sink.publish_failure_with_usage(0, error),
None => self.sink.publish(),
}
}
}
impl Drop for StreamUsage {
fn drop(&mut self) {
if !self.ended {
self.ended = true;
let rest = std::mem::take(&mut self.buffer);
self.lines(&rest);
self.sink.publish_failure_with_usage(499, "context canceled");
}
}
}
fn extract_stream_json(line: &[u8]) -> Option<&[u8]> {
let mut trimmed = line.trim_ascii();
if trimmed.is_empty() || trimmed == b"[DONE]" || trimmed.starts_with(b"event:") {
return None;
}
if let Some(rest) = trimmed.strip_prefix(b"data:") {
trimmed = rest.trim_ascii();
}
(!trimmed.is_empty() && trimmed != b"[DONE]").then_some(trimmed)
}
struct StreamState {
usage: Option<StreamUsage>,
translator: Option<Box<dyn cpa_translate::stream::GoStream>>,
native: bool,
passthrough: bool,
responses: bool,
openai_tail: bool,
chunks: BoxStream<'static, Chunk>,
ready: VecDeque<Result<Bytes, ExecError>>,
done: bool,
chunk_error: fn(String) -> ExecError,
_scope: Scope,
}
impl StreamState {
fn frames(&mut self, payload: &[u8]) -> Vec<Vec<u8>> {
if self.passthrough {
return vec![payload.to_vec()];
}
let frames = match &mut self.translator {
Some(t) => t.line(payload).unwrap_or_default(),
None => vec![payload.to_vec()],
};
if self.native && frames.len() == 1 && frames[0] == payload {
return Vec::new();
}
if !self.responses {
return frames;
}
frames
.into_iter()
.map(|f| cpa_exec::ensure_responses_usage_details(&f))
.collect()
}
fn push(&mut self, frame: Vec<u8>) {
if !frame.is_empty() {
self.ready.push_back(Ok(Bytes::from(frame)));
}
}
}
fn plugin_attributes(
credential: &cpa_core::credential::Credential,
private: &[String],
) -> std::collections::BTreeMap<String, String> {
let mut attributes = crate::management::quota::go_attributes(credential);
for key in private {
attributes.remove(key);
}
attributes
}
#[cfg(test)]
mod tests {
use cpa_core::credential::Credential;
use super::*;
#[test]
fn a_partial_stream_line_is_whole_only_when_its_outer_value_closes() {
let mut scan = JsonScan::default();
let mut line = Vec::new();
let pieces: [&[u8]; 4] = [br#"data: {"usage":[{"t":"}\"]"}"#, br#",{"n":1}"#, b"]", b"} "];
let whole: Vec<bool> = pieces
.iter()
.map(|piece| {
line.extend_from_slice(piece);
scan.advance(&line)
})
.collect();
assert_eq!(whole, [false, false, false, true]);
let mut stray = JsonScan::default();
assert!(!stray.advance(b"data: }{}"), "a close before any open never balances");
}
#[test]
fn plugin_attributes_keep_home_sent_ones_and_drop_dispatcher_ones() {
let mut c = Credential::relay_session("home-a");
for (key, value) in [
("base_url", "http://127.0.0.1:9"),
(crate::remote::SESSION, "plugin-owned"),
(crate::remote::MODEL_INFO, r#"{"id":"gpt-up"}"#),
(crate::remote::PROVIDER, "openai-compatible-probe"),
] {
c.attributes.insert(key.into(), value.into());
}
let private = [crate::remote::MODEL_INFO.to_owned(), crate::remote::PROVIDER.to_owned()];
let attributes = plugin_attributes(&c, &private);
assert_eq!(
attributes.keys().map(String::as_str).collect::<Vec<_>>(),
["base_url", crate::remote::SESSION, "runtime_only"]
);
assert_eq!(attributes[crate::remote::SESSION], "plugin-owned");
}
#[test]
fn routers_are_offered_selectable_providers() {
let dir = cpa_plugin::testing::scratch(&std::env::temp_dir(), "plugin-available-providers");
let cred = |name: &str, provider: &str| {
let mut meta = serde_json::Map::new();
meta.insert("type".into(), provider.into());
Credential::from_file(&dir, &dir.join(name), meta).unwrap()
};
let creds = vec![
cred("a.json", "kimi.com"),
cred("b.json", "kimi.ai"),
cred("c.json", "claude"),
];
let cfg = cpa_core::config::Config::parse(&format!("auth-dir: {}\n", dir.display())).unwrap();
let rt = std::sync::Arc::new(crate::testing::runtime(
cfg,
creds,
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(),
},
));
let providers = available_providers(&rt);
assert_eq!(providers, ["claude", "kimi.ai", "kimi.com"]);
for (provider, id) in providers.iter().zip(["c.json", "b.json", "a.json"]) {
let lease = rt
.store()
.select(crate::runtime::Selection::new(provider, "some-model"))
.unwrap_or_else(|| panic!("{provider} selects a credential"));
assert_eq!(lease.credential.id, id);
}
let _ = std::fs::remove_dir_all(&dir);
}
}