use crate::auth::auth as oauth;
use crate::auth::types::{token_set_is_expired, ServerMetadata, TokenSet};
use crate::core::http::{
classify_transport, iter_sse_lines, parse_http_error_with_retry_after, parse_stream_error,
read_limited_text, CHAT_REQUEST_TIMEOUT_MS, DEFAULT_JSON_TIMEOUT_MS, MAX_ERROR_BODY_SIZE,
MODEL_CACHE_TTL_MS,
};
use crate::core::retry::{effective_policy, EffectiveRetryPolicy, RetryPolicy, RetryRequestInfo};
use crate::core::store::{FileTokenStore, InMemoryTokenStore, TokenStore};
use crate::macros::open_string_union;
use crate::models::adapters::openai::parse_openai_response_to_anthropic;
use crate::models::adapters::{get_adapter_for_model, Adapter, ProviderFormat};
use crate::models::is_sse_comment_line;
use crate::models::stream_meta::{extract_anthropic_block_meta, BlockMeta};
use crate::models::types::{
parse_settlement, parse_sources_event, zero_model_capabilities, ChatRequest, ChatResponse,
EmbeddingRequest, EmbeddingResponse, ImageGenerationRequest, ImageGenerationResponse,
InputModality, ManagedModel, ModelCapabilities, QuotaSummary, RerankRequest, RerankResponse,
SourcesEvent, StreamEvent, StreamSettlement, VideoGenerationRequest, VideoTaskResponse,
};
use crate::models::wire_anthropic::AnthropicResponse;
use crate::shared::api_response::ApiResponse;
use crate::shared::errors::{Error, Result};
use futures::Stream;
use futures::StreamExt;
use serde::de::DeserializeOwned;
use std::collections::HashMap;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, RwLock};
use tokio_util::sync::CancellationToken;
use url::Url;
pub const DEFAULT_GATEWAY_BASE_URL: &str = "https://acosmi.com";
pub const DEFAULT_API_TIMEOUT_MS: u64 = 60_000;
pub const ERR_OAUTH_CORS_BLOCKED: &str = "oauth_cors_blocked";
pub const ERR_REFRESH_PROXY_FAILED: &str = "refresh_proxy_failed";
pub const ERR_TOKEN_EXPIRED: &str = "token_expired";
open_string_union! {
FilterStatus {
OK => "ok",
ADMIN_BYPASS => "admin-bypass",
INTERNAL_BYPASS => "internal-bypass",
DISABLED_BY_FLAG => "disabled-by-flag",
FALLBACK_TKDIST_ERROR => "fallback-tkdist-error",
FALLBACK_TKDIST_SKEW => "fallback-tkdist-deployment-skew",
FALLBACK_NO_BUCKETS => "fallback-no-buckets",
FALLBACK_MISSING_USER => "fallback-missing-userid",
UNKNOWN => "",
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum BrowserRefreshMode {
#[default]
Direct,
ServerProxy,
None,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum OAuthMetadataProfile {
#[default]
Desktop,
Web,
}
#[derive(Default)]
pub struct Config {
pub server_url: Option<String>,
pub store: Option<Arc<dyn TokenStore>>,
pub http: Option<reqwest::Client>,
pub retry_policy: Option<RetryPolicy>,
pub compliance_base_url: Option<String>,
pub api_base_url: Option<String>,
pub oauth_metadata_profile: Option<OAuthMetadataProfile>,
pub browser_refresh_mode: Option<BrowserRefreshMode>,
pub refresh_proxy_url: Option<String>,
}
pub(crate) struct ClientInner {
server_url: String,
compliance_base_url: Option<String>,
api_base_url: Option<String>,
oauth_metadata_profile: OAuthMetadataProfile,
browser_refresh_mode: BrowserRefreshMode,
refresh_proxy_url: Option<String>,
http: reqwest::Client,
store: Arc<dyn TokenStore>,
retry_policy: Option<EffectiveRetryPolicy>,
tokens: RwLock<Option<TokenSet>>,
model_cache: RwLock<Vec<crate::models::ManagedModel>>,
model_cache_time: RwLock<Option<std::time::Instant>>,
meta: RwLock<Option<ServerMetadata>>,
login_in_flight: AtomicBool,
mu: tokio::sync::Mutex<()>,
token_ready: tokio::sync::Notify,
coef_cache: RwLock<Option<(Vec<crate::billing::ModelCoefficient>, std::time::Instant)>>,
ws: tokio::sync::Mutex<Option<crate::notifications::WsHandle>>,
#[cfg(feature = "sanitize")]
pub(crate) defensive_cfg: RwLock<Option<crate::sanitize::MinimalSanitizeConfig>>,
#[cfg(feature = "sanitize")]
pub(crate) auto_strip_ephemeral: AtomicBool,
}
#[derive(Clone)]
pub struct Client {
inner: Arc<ClientInner>,
}
impl Client {
pub fn new(cfg: Config) -> Result<Self> {
let server_url = match &cfg.server_url {
Some(s) => normalize_gateway_base_url(s)?,
None => DEFAULT_GATEWAY_BASE_URL.to_string(),
};
let compliance_base_url = match &cfg.compliance_base_url {
Some(s) => Some(normalize_override_base_url(s, "complianceBaseURL")?),
None => None,
};
let api_base_url = match &cfg.api_base_url {
Some(s) => Some(normalize_override_base_url(s, "apiBaseURL")?),
None => None,
};
let http = match cfg.http {
Some(c) => c,
None => reqwest::Client::builder()
.connect_timeout(std::time::Duration::from_secs(30))
.build()
.map_err(Error::from)?,
};
let store: Arc<dyn TokenStore> = match cfg.store {
Some(s) => s,
None => default_store(),
};
let retry_policy = effective_policy(cfg.retry_policy.as_ref());
Ok(Client {
inner: Arc::new(ClientInner {
server_url,
compliance_base_url,
api_base_url,
oauth_metadata_profile: cfg.oauth_metadata_profile.unwrap_or_default(),
browser_refresh_mode: cfg.browser_refresh_mode.unwrap_or_default(),
refresh_proxy_url: cfg.refresh_proxy_url,
http,
store,
retry_policy,
tokens: RwLock::new(None),
model_cache: RwLock::new(Vec::new()),
model_cache_time: RwLock::new(None),
meta: RwLock::new(None),
login_in_flight: AtomicBool::new(false),
mu: tokio::sync::Mutex::new(()),
token_ready: tokio::sync::Notify::new(),
coef_cache: RwLock::new(None),
ws: tokio::sync::Mutex::new(None),
#[cfg(feature = "sanitize")]
defensive_cfg: RwLock::new(None),
#[cfg(feature = "sanitize")]
auto_strip_ephemeral: AtomicBool::new(false),
}),
})
}
#[cfg(feature = "sanitize")]
pub(crate) fn inner(&self) -> &ClientInner {
&self.inner
}
pub async fn create(cfg: Config) -> Result<Self> {
let client = Client::new(cfg)?;
if let Ok(Some(t)) = client.inner.store.load().await {
*client.inner.tokens.write().unwrap() = Some(t);
}
Ok(client)
}
pub fn is_authorized(&self) -> bool {
self.inner.tokens.read().unwrap().is_some()
}
pub fn server_url(&self) -> &str {
&self.inner.server_url
}
pub fn base_url(&self) -> &str {
&self.inner.server_url
}
pub fn token_set(&self) -> Option<TokenSet> {
self.inner.tokens.read().unwrap().clone()
}
pub fn compliance_base_url(&self) -> Option<&str> {
self.inner.compliance_base_url.as_deref()
}
pub fn api_base_url(&self) -> Option<&str> {
self.inner.api_base_url.as_deref()
}
pub fn oauth_metadata_profile(&self) -> OAuthMetadataProfile {
self.inner.oauth_metadata_profile
}
pub fn browser_refresh_mode(&self) -> BrowserRefreshMode {
self.inner.browser_refresh_mode
}
pub fn refresh_proxy_url(&self) -> Option<&str> {
self.inner.refresh_proxy_url.as_deref()
}
pub(crate) fn http(&self) -> &reqwest::Client {
&self.inner.http
}
pub(crate) fn coef_cache(
&self,
) -> &RwLock<Option<(Vec<crate::billing::ModelCoefficient>, std::time::Instant)>> {
&self.inner.coef_cache
}
pub(crate) fn ws_slot(&self) -> &tokio::sync::Mutex<Option<crate::notifications::WsHandle>> {
&self.inner.ws
}
pub(crate) fn retry_policy(&self) -> Option<&EffectiveRetryPolicy> {
self.inner.retry_policy.as_ref()
}
pub async fn login(
&self,
app_name: &str,
scopes: &[String],
signal: Option<CancellationToken>,
) -> Result<()> {
self.login_internal(app_name, scopes, None, &Default::default(), signal)
.await
}
pub async fn login_with_handler(
&self,
app_name: &str,
scopes: &[String],
handler: Option<&(dyn Fn(oauth::LoginEvent) + Send + Sync)>,
opts: &oauth::LoginOptions,
signal: Option<CancellationToken>,
) -> Result<()> {
self.login_internal(app_name, scopes, handler, opts, signal)
.await
}
async fn login_internal(
&self,
app_name: &str,
scopes: &[String],
handler: Option<&(dyn Fn(oauth::LoginEvent) + Send + Sync)>,
opts: &oauth::LoginOptions,
signal: Option<CancellationToken>,
) -> Result<()> {
let emit = |e: oauth::LoginEvent| {
if let Some(h) = handler {
h(e);
}
};
let emit_error = |code: &str, err: &Error| {
emit(oauth::LoginEvent::error(code, err.to_string()));
};
self.inner.login_in_flight.store(true, Ordering::SeqCst);
let result = self
.login_steps(app_name, scopes, handler, opts, signal, &emit, &emit_error)
.await;
self.inner.login_in_flight.store(false, Ordering::SeqCst);
result
}
#[allow(clippy::too_many_arguments)]
async fn login_steps(
&self,
app_name: &str,
scopes: &[String],
handler: Option<&(dyn Fn(oauth::LoginEvent) + Send + Sync)>,
opts: &oauth::LoginOptions,
signal: Option<CancellationToken>,
emit: &dyn Fn(oauth::LoginEvent),
emit_error: &dyn Fn(&str, &Error),
) -> Result<()> {
let meta = match oauth::discover(self.http(), &self.inner.server_url).await {
Ok(m) => m,
Err(e) => {
emit_error(oauth::ERR_DISCOVERY, &e);
return Err(Error::other(format!("discovery failed: {e}")));
}
};
*self.inner.meta.write().unwrap() = Some(meta.clone());
let mut client_id = self.cached_client_id();
if client_id.is_empty() {
match oauth::register(self.http(), &meta, app_name).await {
Ok(reg) => client_id = reg.client_id,
Err(e) => {
emit_error(oauth::ERR_REGISTRATION, &e);
return Err(Error::other(format!("registration failed: {e}")));
}
}
}
let (result, verifier) = match self
.do_authorize(&meta, &client_id, scopes, opts, handler, signal.clone())
.await
{
Ok(r) => r,
Err(first_err) => {
match oauth::register(self.http(), &meta, app_name).await {
Ok(reg) => client_id = reg.client_id,
Err(reg_err) => {
emit_error(oauth::ERR_REGISTRATION, ®_err);
return Err(Error::other(format!(
"authorization failed (retry registration also failed): {first_err}"
)));
}
}
match self
.do_authorize(&meta, &client_id, scopes, opts, handler, signal.clone())
.await
{
Ok(r) => r,
Err(e2) => return Err(Error::other(format!("authorization failed: {e2}"))),
}
}
};
let token_resp = {
let exchange = if let Some(exp) = opts.expires_in.filter(|&e| e > 0) {
oauth::exchange_code_with_expiry(
self.http(),
&meta,
&client_id,
&result.code,
&result.redirect_uri,
&verifier,
exp,
)
.await
} else {
oauth::exchange_code(
self.http(),
&meta,
&client_id,
&result.code,
&result.redirect_uri,
&verifier,
)
.await
};
match exchange {
Ok(r) => r,
Err(e) => {
let code = if oauth::is_ssl_error(&e.to_string()) {
oauth::ERR_SSL_PROXY
} else {
oauth::ERR_TOKEN_EXCHANGE
};
emit_error(code, &e);
return Err(Error::other(format!("token exchange failed: {e}")));
}
}
};
let tokens = oauth::new_token_set(&token_resp, &client_id, &self.inner.server_url);
*self.inner.tokens.write().unwrap() = Some(tokens.clone());
self.inner.token_ready.notify_waiters();
if let Err(e) = self.inner.store.save(&tokens).await {
return Err(Error::other(format!("save tokens: {e}")));
}
emit(oauth::LoginEvent::complete());
Ok(())
}
#[allow(unused_variables)]
async fn do_authorize(
&self,
meta: &ServerMetadata,
client_id: &str,
scopes: &[String],
opts: &oauth::LoginOptions,
handler: Option<&(dyn Fn(oauth::LoginEvent) + Send + Sync)>,
signal: Option<CancellationToken>,
) -> Result<(oauth::AuthorizeResult, String)> {
#[cfg(feature = "desktop-loopback")]
{
oauth::authorize(meta, client_id, scopes, opts, handler, signal).await
}
#[cfg(not(feature = "desktop-loopback"))]
{
Err(Error::other(
"login() requires the `desktop-loopback` feature (loopback HTTP callback server); \
for browser flows use create_web_authorization_request / complete_web_authorization_request",
))
}
}
pub async fn logout(&self, signal: Option<CancellationToken>) -> Result<()> {
let _ = &signal; let tokens = self.inner.tokens.write().unwrap().take();
let mut meta = self.inner.meta.write().unwrap().take();
self.inner.login_in_flight.store(false, Ordering::SeqCst);
if let Some(tokens) = tokens {
if meta.is_none() {
match self.discover_for_lifecycle().await {
Ok(m) => meta = Some(m),
Err(e) => {
eprintln!("[acosmi-sdk] warning: discover for revocation failed: {e}");
}
}
}
if let Some(meta) = meta {
let _ = oauth::revoke_token(self.http(), &meta, &tokens.access_token).await;
let _ = oauth::revoke_token(self.http(), &meta, &tokens.refresh_token).await;
}
}
self.inner.store.clear().await
}
pub async fn ensure_token(&self, signal: Option<CancellationToken>) -> Result<String> {
let mut tokens = self.token_set();
if tokens.is_none() {
if !self.inner.login_in_flight.load(Ordering::SeqCst) {
return Err(Error::other("not authorized, call login() first"));
}
loop {
let notified = self.inner.token_ready.notified();
if let Some(t) = self.token_set() {
tokens = Some(t);
break;
}
if !self.inner.login_in_flight.load(Ordering::SeqCst) {
return Err(Error::other("not authorized, call login() first"));
}
match &signal {
Some(cancel) => {
tokio::select! {
_ = notified => {}
_ = cancel.cancelled() => {
return Err(Error::other("waiting for token: aborted"));
}
}
}
None => notified.await,
}
if let Some(t) = self.token_set() {
tokens = Some(t);
break;
}
}
}
let tokens = tokens.expect("tokens present after wait");
if !token_set_is_expired(&tokens) {
return Ok(tokens.access_token);
}
let _g = self.inner.mu.lock().await;
let _lock = self.inner.store.lock().await?;
self.sync_from_disk().await;
let cur = self
.token_set()
.ok_or_else(|| Error::other("not authorized, call login() first"))?;
if !token_set_is_expired(&cur) {
return Ok(cur.access_token);
}
self.refresh_current_token(signal).await?;
self.token_set()
.map(|t| t.access_token)
.ok_or_else(|| Error::other("not authorized, call login() first"))
}
pub async fn force_refresh(&self, signal: Option<CancellationToken>) -> Result<()> {
let _g = self.inner.mu.lock().await;
let _lock = self.inner.store.lock().await?;
self.sync_from_disk().await;
if self.token_set().is_none() {
return Err(Error::other("no tokens to refresh"));
}
self.refresh_current_token(signal).await
}
fn cached_client_id(&self) -> String {
self.inner
.tokens
.read()
.unwrap()
.as_ref()
.map(|t| t.client_id.clone())
.unwrap_or_default()
}
async fn discover_for_lifecycle(&self) -> Result<ServerMetadata> {
let profile = match self.inner.oauth_metadata_profile {
OAuthMetadataProfile::Desktop => oauth::OAuthMetadataProfile::Desktop,
OAuthMetadataProfile::Web => oauth::OAuthMetadataProfile::Web,
};
oauth::discover_with_profile(self.http(), &self.inner.server_url, profile).await
}
async fn refresh_current_token(&self, signal: Option<CancellationToken>) -> Result<()> {
if self.token_set().is_none() {
return Err(Error::other("no tokens to refresh"));
}
match self.inner.browser_refresh_mode {
BrowserRefreshMode::None => Err(Error::other(format!(
"{ERR_TOKEN_EXPIRED}: token refresh disabled"
))),
BrowserRefreshMode::ServerProxy => self.refresh_via_proxy(signal).await,
BrowserRefreshMode::Direct => self.refresh_direct().await,
}
}
async fn refresh_direct(&self) -> Result<()> {
let cur = self
.token_set()
.ok_or_else(|| Error::other("no tokens to refresh"))?;
if self.inner.meta.read().unwrap().is_none() {
match self.discover_for_lifecycle().await {
Ok(m) => *self.inner.meta.write().unwrap() = Some(m),
Err(e) => return Err(Error::other(format!("discover for refresh: {e}"))),
}
}
let meta = self
.inner
.meta
.read()
.unwrap()
.clone()
.ok_or_else(|| Error::other("discover for refresh: no metadata"))?;
let token_resp = match oauth::refresh_token(
self.http(),
&meta,
&cur.client_id,
&cur.refresh_token,
)
.await
{
Ok(r) => r,
Err(e) => {
if oauth::is_invalid_grant_error(&e) {
self.clear_invalid_refresh_token().await;
return Err(Error::other(format!(
"refresh token invalid; local tokens cleared: {e}"
)));
}
let msg = e.to_string();
if is_likely_browser_oauth_cors_error(&msg) {
return Err(Error::other(format!(
"{ERR_OAUTH_CORS_BLOCKED}: refresh token: {msg}"
)));
}
return Err(Error::other(format!("refresh token: {msg}")));
}
};
let new_set = oauth::new_token_set(&token_resp, &cur.client_id, &self.inner.server_url);
*self.inner.tokens.write().unwrap() = Some(new_set.clone());
self.save_refreshed_token(&new_set).await;
Ok(())
}
async fn refresh_via_proxy(&self, signal: Option<CancellationToken>) -> Result<()> {
let cur = self
.token_set()
.ok_or_else(|| Error::other("no tokens to refresh"))?;
let proxy_url = self.inner.refresh_proxy_url.as_deref().ok_or_else(|| {
Error::other(format!(
"{ERR_REFRESH_PROXY_FAILED}: refreshProxyURL is required"
))
})?;
let server_url = if cur.server_url.is_empty() {
self.inner.server_url.clone()
} else {
cur.server_url.clone()
};
let body = serde_json::json!({
"client_id": cur.client_id,
"refresh_token": cur.refresh_token,
"server_url": server_url,
});
let req = self.http().post(proxy_url).json(&body);
let send = req.send();
let resp = match signal {
Some(cancel) => tokio::select! {
r = send => r,
_ = cancel.cancelled() => {
return Err(Error::other(format!("{ERR_REFRESH_PROXY_FAILED}: aborted")));
}
},
None => send.await,
}
.map_err(|e| Error::other(format!("{ERR_REFRESH_PROXY_FAILED}: {e}")))?;
if !resp.status().is_success() {
let status = resp.status().as_u16();
let (mut message, oauth_error) = match resp.json::<serde_json::Value>().await {
Ok(b) => {
let err = b
.get("error")
.and_then(|v| v.as_str())
.unwrap_or_default()
.to_string();
let desc = b
.get("error_description")
.and_then(|v| v.as_str())
.unwrap_or_default()
.to_string();
(if desc.is_empty() { err.clone() } else { desc }, err)
}
Err(_) => (String::new(), String::new()),
};
if oauth_error == "invalid_grant" {
self.clear_invalid_refresh_token().await;
return Err(Error::other(format!(
"{ERR_REFRESH_PROXY_FAILED}: refresh token invalid; local tokens cleared"
)));
}
if message.is_empty() {
message = format!("HTTP {status}");
}
return Err(Error::other(format!(
"{ERR_REFRESH_PROXY_FAILED}: HTTP {status}: {message}"
)));
}
#[derive(serde::Deserialize)]
struct ProxyResp {
#[serde(default)]
#[serde(rename = "tokenSet")]
token_set: Option<TokenSet>,
}
let parsed: ProxyResp = resp
.json()
.await
.map_err(|e| Error::other(format!("{ERR_REFRESH_PROXY_FAILED}: decode: {e}")))?;
let new_set = parsed.token_set.ok_or_else(|| {
Error::other(format!(
"{ERR_REFRESH_PROXY_FAILED}: response missing tokenSet"
))
})?;
*self.inner.tokens.write().unwrap() = Some(new_set.clone());
self.save_refreshed_token(&new_set).await;
Ok(())
}
async fn save_refreshed_token(&self, tokens: &TokenSet) {
if let Err(e) = self.inner.store.save(tokens).await {
eprintln!("[acosmi-sdk] warning: save refreshed token failed: {e}");
}
}
async fn clear_invalid_refresh_token(&self) {
*self.inner.tokens.write().unwrap() = None;
*self.inner.meta.write().unwrap() = None;
self.inner.login_in_flight.store(false, Ordering::SeqCst);
if let Err(e) = self.inner.store.clear().await {
eprintln!("[acosmi-sdk] warning: clear invalid token failed: {e}");
}
}
async fn sync_from_disk(&self) {
let on_disk = match self.inner.store.load().await {
Ok(Some(t)) => t,
Ok(None) => return,
Err(_) => return,
};
let adopt = {
let cur = self.inner.tokens.read().unwrap();
match cur.as_ref() {
None => true,
Some(c) => on_disk.refresh_token != c.refresh_token,
}
};
if adopt {
*self.inner.tokens.write().unwrap() = Some(on_disk);
}
}
pub fn api_url(&self, path: &str) -> String {
let mut base = self
.inner
.api_base_url
.clone()
.unwrap_or_else(|| self.inner.server_url.clone());
if !base.ends_with("/api/v4") {
base.push_str("/api/v4");
}
base.push_str(path);
base
}
pub(crate) async fn do_json_get_full<T: DeserializeOwned>(
&self,
path: &str,
signal: Option<CancellationToken>,
) -> Result<(T, reqwest::header::HeaderMap)> {
self.do_json_get_internal(path, signal, false).await
}
pub(crate) async fn do_public_json_full<T: DeserializeOwned>(
&self,
path: &str,
signal: Option<CancellationToken>,
) -> Result<T> {
let url = self.api_url(path);
let signal = self.derive_timeout_token(DEFAULT_JSON_TIMEOUT_MS, signal);
let send = self.http().get(&url).send();
let resp = match &signal {
Some(cancel) => tokio::select! {
r = send => r,
_ = cancel.cancelled() => {
return Err(Error::other(format!("GET {path}: aborted")));
}
},
None => send.await,
}
.map_err(|e| {
Error::Network(crate::core::http::classify_transport(
&format!("GET {path}"),
&url,
&e,
))
})?;
let status = resp.status();
if !status.is_success() {
let retry_after = parse_retry_after_secs(resp.headers());
let body = read_limited_text(resp.bytes_stream(), MAX_ERROR_BODY_SIZE).await?;
return Err(Error::Http(parse_http_error_with_retry_after(
status.as_u16(),
&body,
retry_after,
)));
}
let text = resp
.text()
.await
.map_err(|e| Error::other(format!("GET {path}: read body: {e}")))?;
if text.is_empty() {
return Err(Error::other(format!("GET {path}: empty response body")));
}
serde_json::from_str(&text).map_err(|e| Error::other(format!("GET {path}: decode: {e}")))
}
async fn do_json_get_internal<T: DeserializeOwned>(
&self,
path: &str,
signal: Option<CancellationToken>,
retried: bool,
) -> Result<(T, reqwest::header::HeaderMap)> {
let req_signal = self.derive_timeout_token(DEFAULT_JSON_TIMEOUT_MS, signal.clone());
let token = self.ensure_token(req_signal.clone()).await?;
let url = self.api_url(path);
let send = self
.http()
.get(&url)
.header(reqwest::header::AUTHORIZATION, format!("Bearer {token}"))
.send();
let resp = match &req_signal {
Some(cancel) => tokio::select! {
r = send => r,
_ = cancel.cancelled() => {
return Err(Error::other(format!("GET {path}: aborted")));
}
},
None => send.await,
}
.map_err(|e| {
Error::Network(crate::core::http::classify_transport(
&format!("GET {path}"),
&url,
&e,
))
})?;
let status = resp.status();
if status.as_u16() == 401 && !retried {
self.force_refresh(signal.clone())
.await
.map_err(|e| Error::other(format!("unauthorized and refresh failed: {e}")))?;
return Box::pin(self.do_json_get_internal(path, signal, true)).await;
}
if !status.is_success() {
let retry_after = resp
.headers()
.get(reqwest::header::RETRY_AFTER)
.and_then(|v| v.to_str().ok())
.and_then(|s| s.trim().parse::<i64>().ok())
.filter(|&s| s > 0)
.unwrap_or(0);
let body = read_limited_text(resp.bytes_stream(), MAX_ERROR_BODY_SIZE).await?;
return Err(Error::Http(parse_http_error_with_retry_after(
status.as_u16(),
&body,
retry_after,
)));
}
let headers = resp.headers().clone();
let text = resp
.text()
.await
.map_err(|e| Error::other(format!("GET {path}: read body: {e}")))?;
if text.is_empty() {
return Err(Error::other(format!("GET {path}: empty response body")));
}
let result: T = serde_json::from_str(&text)
.map_err(|e| Error::other(format!("GET {path}: decode: {e}")))?;
Ok((result, headers))
}
pub async fn list_models(
&self,
signal: Option<CancellationToken>,
include_locked: bool,
) -> Result<Vec<ManagedModel>> {
Ok(self
.list_models_with_status(signal, include_locked)
.await?
.0)
}
pub async fn list_models_with_status(
&self,
signal: Option<CancellationToken>,
include_locked: bool,
) -> Result<(Vec<ManagedModel>, FilterStatus)> {
let path = if include_locked {
"/managed-models?picker=1"
} else {
"/managed-models"
};
let (result, headers): (ApiResponse<Vec<ManagedModel>>, _) =
self.do_json_get_full(path, signal).await?;
if let Some(err) = result.business_error() {
return Err(err);
}
let normalized = normalize_input_modalities(result.data);
if !include_locked {
*self.inner.model_cache.write().unwrap() = normalized.clone();
*self.inner.model_cache_time.write().unwrap() = Some(std::time::Instant::now());
}
let status: FilterStatus = headers
.get("X-Entitlement-Filter-Status")
.and_then(|v| v.to_str().ok())
.filter(|s| !s.is_empty())
.map(FilterStatus::from)
.unwrap_or_else(|| FilterStatus::UNKNOWN.into());
Ok((normalized, status))
}
pub async fn get_quota_summary(
&self,
signal: Option<CancellationToken>,
) -> Result<QuotaSummary> {
let (resp, _): (ApiResponse<QuotaSummary>, _) = self
.do_json_get_full("/entitlements/quota-summary", signal)
.await?;
if let Some(err) = resp.business_error() {
return Err(err);
}
Ok(resp.data)
}
pub async fn get_model_capabilities(
&self,
model_id: &str,
signal: Option<CancellationToken>,
) -> Result<ModelCapabilities> {
if let Some(caps) = self.cached_capabilities(model_id) {
return Ok(caps);
}
self.list_models(signal, false).await?;
if let Some(caps) = self.cached_capabilities(model_id) {
return Ok(caps);
}
Ok(zero_model_capabilities())
}
fn cached_capabilities(&self, model_id: &str) -> Option<ModelCapabilities> {
let cache = self.inner.model_cache.read().unwrap();
let time = *self.inner.model_cache_time.read().unwrap();
let expired = match time {
Some(t) => t.elapsed().as_millis() as u64 > MODEL_CACHE_TTL_MS,
None => true,
};
if cache.is_empty() || expired {
return None;
}
for m in cache.iter() {
if m.id == model_id || m.model_id == model_id {
return Some(m.capabilities.clone());
}
}
None
}
fn cached_model(&self, model_id: &str) -> Option<ManagedModel> {
let cache = self.inner.model_cache.read().unwrap();
cache
.iter()
.find(|m| m.id == model_id || m.model_id == model_id)
.cloned()
}
pub async fn ensure_model_cached(
&self,
model_id: &str,
signal: Option<CancellationToken>,
) -> Result<ManagedModel> {
if let Some(m) = self.cached_model(model_id) {
return Ok(m);
}
self.list_models(signal, false).await?;
if let Some(m) = self.cached_model(model_id) {
return Ok(m);
}
Err(Error::ModelNotFound {
model_id: model_id.to_string(),
})
}
pub(crate) async fn do_request(
&self,
method: reqwest::Method,
url: &str,
headers: &[(reqwest::header::HeaderName, String)],
body: Option<&str>,
signal: Option<&CancellationToken>,
) -> Result<reqwest::Response> {
let mut rb = self.http().request(method.clone(), url);
for (k, v) in headers {
rb = rb.header(k.clone(), v.clone());
}
if let Some(b) = body {
rb = rb.body(b.to_string());
}
let send = rb.send();
let resp = match signal {
Some(cancel) => tokio::select! {
r = send => r,
_ = cancel.cancelled() => {
return Err(Error::Network(crate::shared::errors::NetworkError::new(
format!("{method} {url}"),
url,
"request aborted",
)));
}
},
None => send.await,
};
resp.map_err(|e| {
let path = Url::parse(url)
.map(|u| u.path().to_string())
.unwrap_or_else(|_| url.to_string());
Error::Network(classify_transport(&format!("{method} {path}"), url, &e))
})
}
async fn do_request_with_retry(
&self,
method: reqwest::Method,
url: &str,
headers: &[(reqwest::header::HeaderName, String)],
body: Option<&str>,
signal: Option<&CancellationToken>,
) -> Result<reqwest::Response> {
let policy = match self.retry_policy() {
Some(p) => p.clone(),
None => return self.do_request(method, url, headers, body, signal).await,
};
let info = RetryRequestInfo {
method: method.as_str().to_string(),
url: url.to_string(),
};
if !(policy.safe_to_retry)(&info) {
return self.do_request(method, url, headers, body, signal).await;
}
let mut last_err: Option<Error> = None;
let mut attempt: u32 = 0;
while attempt < policy.max_attempts {
match self
.do_request(method.clone(), url, headers, body, signal)
.await
{
Ok(resp) => {
let status = resp.status().as_u16();
if status < 500 && status != 429 {
return Ok(resp);
}
let retry_after = parse_retry_after_secs(resp.headers());
let peek = read_limited_text(resp.bytes_stream(), MAX_ERROR_BODY_SIZE).await?;
last_err = Some(Error::Http(parse_http_error_with_retry_after(
status,
&peek,
retry_after,
)));
}
Err(e) => last_err = Some(e),
}
if attempt + 1 == policy.max_attempts {
break;
}
let err_ref = last_err.as_ref().expect("last_err set");
if !(policy.on_retryable)(err_ref) {
break;
}
let backoff = crate::core::retry::compute_backoff(&policy, attempt, err_ref);
sleep_with_cancel(backoff, signal).await;
attempt += 1;
}
Err(last_err.unwrap_or_else(|| Error::other("do_request_with_retry: no attempts ran")))
}
pub(crate) async fn do_json_full_raw(
&self,
method: reqwest::Method,
path: &str,
body: Option<&str>,
signal: Option<CancellationToken>,
timeout_ms: u64,
) -> Result<(Vec<u8>, reqwest::header::HeaderMap)> {
let ctl = self.derive_timeout_token(timeout_ms, signal);
self.do_json_full_raw_internal(method, path, body, ctl.as_ref(), false)
.await
}
async fn do_json_full_raw_internal(
&self,
method: reqwest::Method,
path: &str,
body: Option<&str>,
signal: Option<&CancellationToken>,
retried: bool,
) -> Result<(Vec<u8>, reqwest::header::HeaderMap)> {
let token = self.ensure_token(signal.cloned()).await?;
let url = self.api_url(path);
let mut headers: Vec<(reqwest::header::HeaderName, String)> =
vec![(reqwest::header::AUTHORIZATION, format!("Bearer {token}"))];
if body.is_some() {
headers.push((
reqwest::header::CONTENT_TYPE,
"application/json".to_string(),
));
}
let resp = self
.do_request_with_retry(method.clone(), &url, &headers, body, signal)
.await?;
if resp.status().as_u16() == 401 && !retried {
drop(resp); self.force_refresh(signal.cloned())
.await
.map_err(|e| Error::other(format!("unauthorized and refresh failed: {e}")))?;
return Box::pin(self.do_json_full_raw_internal(method, path, body, signal, true))
.await;
}
if !resp.status().is_success() {
let status = resp.status().as_u16();
let retry_after = parse_retry_after_secs(resp.headers());
let text = read_limited_text(resp.bytes_stream(), MAX_ERROR_BODY_SIZE).await?;
return Err(Error::Http(parse_http_error_with_retry_after(
status,
&text,
retry_after,
)));
}
let headers = resp.headers().clone();
let bytes = resp
.bytes()
.await
.map_err(|e| Error::other(format!("{method} {path}: read body: {e}")))?;
Ok((bytes.to_vec(), headers))
}
pub(crate) async fn do_json_full<T: DeserializeOwned>(
&self,
method: reqwest::Method,
path: &str,
body: Option<&str>,
signal: Option<CancellationToken>,
) -> Result<(Option<T>, reqwest::header::HeaderMap)> {
let (bytes, headers) = self
.do_json_full_raw(method, path, body, signal, DEFAULT_JSON_TIMEOUT_MS)
.await?;
if bytes.is_empty() {
return Ok((None, headers));
}
let result: T = serde_json::from_slice(&bytes)
.map_err(|e| Error::other(format!("{path}: decode: {e}")))?;
Ok((Some(result), headers))
}
pub async fn build_chat_request(
&self,
model_id: &str,
req: &ChatRequest,
signal: Option<CancellationToken>,
) -> Result<(String, Adapter)> {
#[cfg(feature = "sanitize")]
let sanitized: std::borrow::Cow<'_, ChatRequest> = {
let mut s = req.clone();
self.apply_request_sanitizers(&mut s)?;
std::borrow::Cow::Owned(s)
};
#[cfg(feature = "sanitize")]
let req: &ChatRequest = &sanitized;
let m = self.ensure_model_cached(model_id, signal).await?;
let adapter = get_adapter_for_model(&m);
let caps = self
.cached_capabilities(model_id)
.unwrap_or_else(zero_model_capabilities);
let body_map = adapter.build_request_body(&caps, req);
let body = serde_json::to_string(&body_map)
.map_err(|e| Error::other(format!("serialize chat request: {e}")))?;
Ok((body, adapter))
}
pub async fn chat(
&self,
model_id: &str,
req: &ChatRequest,
signal: Option<CancellationToken>,
) -> Result<ChatResponse> {
let mut r = req.clone();
r.stream = Some(false);
let (body, adapter) = self
.build_chat_request(model_id, &r, signal.clone())
.await?;
let endpoint = format!(
"/managed-models/{}{}",
urlencode(model_id),
adapter.endpoint_suffix()
);
let (bytes, headers) = self
.do_json_full_raw(
reqwest::Method::POST,
&endpoint,
Some(&body),
signal,
CHAT_REQUEST_TIMEOUT_MS,
)
.await?;
let mut resp = adapter.parse_response(&bytes)?;
if let Some(v) = header_i64(&headers, "X-Token-Remaining") {
resp.token_remaining = v;
}
if let Some(v) = header_i64(&headers, "X-Call-Remaining") {
resp.call_remaining = v;
}
if let Some(v) = header_i64(&headers, "X-Token-Remaining-Model") {
resp.model_token_remaining = v;
}
if let Some(v) = header_i64(&headers, "X-Token-Remaining-Model-ETU") {
resp.model_token_remaining_etu = v;
}
Ok(resp)
}
pub async fn embeddings(
&self,
model_id: &str,
req: &EmbeddingRequest,
signal: Option<CancellationToken>,
) -> Result<EmbeddingResponse> {
let endpoint = format!("/managed-models/{}/embeddings", urlencode(model_id));
let body = serde_json::to_string(req)
.map_err(|e| Error::other(format!("serialize embedding request: {e}")))?;
let (bytes, _) = self
.do_json_full_raw(
reqwest::Method::POST,
&endpoint,
Some(&body),
signal,
CHAT_REQUEST_TIMEOUT_MS,
)
.await?;
serde_json::from_slice(&bytes).map_err(|e| Error::other(format!("{endpoint}: decode: {e}")))
}
pub async fn rerank(
&self,
model_id: &str,
req: &RerankRequest,
signal: Option<CancellationToken>,
) -> Result<RerankResponse> {
let endpoint = format!("/managed-models/{}/rerank", urlencode(model_id));
let body = serde_json::to_string(req)
.map_err(|e| Error::other(format!("serialize rerank request: {e}")))?;
let (bytes, _) = self
.do_json_full_raw(
reqwest::Method::POST,
&endpoint,
Some(&body),
signal,
CHAT_REQUEST_TIMEOUT_MS,
)
.await?;
serde_json::from_slice(&bytes).map_err(|e| Error::other(format!("{endpoint}: decode: {e}")))
}
fn unwrap_api_response<T: DeserializeOwned>(path: &str, bytes: &[u8]) -> Result<T> {
let env: ApiResponse<T> = serde_json::from_slice(bytes)
.map_err(|e| Error::other(format!("{path}: decode: {e}")))?;
if let Some(err) = env.business_error() {
return Err(err);
}
Ok(env.data)
}
pub async fn generate_image(
&self,
model_id: &str,
req: &ImageGenerationRequest,
signal: Option<CancellationToken>,
) -> Result<ImageGenerationResponse> {
let endpoint = format!("/managed-models/{}/images/generations", urlencode(model_id));
let body = serde_json::to_string(req)
.map_err(|e| Error::other(format!("serialize image request: {e}")))?;
let (bytes, _) = self
.do_json_full_raw(
reqwest::Method::POST,
&endpoint,
Some(&body),
signal,
CHAT_REQUEST_TIMEOUT_MS,
)
.await?;
Self::unwrap_api_response(&endpoint, &bytes)
}
pub async fn generate_video(
&self,
model_id: &str,
req: &VideoGenerationRequest,
signal: Option<CancellationToken>,
) -> Result<VideoTaskResponse> {
let endpoint = format!("/managed-models/{}/videos/generations", urlencode(model_id));
let body = serde_json::to_string(req)
.map_err(|e| Error::other(format!("serialize video request: {e}")))?;
let (bytes, _) = self
.do_json_full_raw(
reqwest::Method::POST,
&endpoint,
Some(&body),
signal,
DEFAULT_JSON_TIMEOUT_MS,
)
.await?;
Self::unwrap_api_response(&endpoint, &bytes)
}
pub async fn poll_video_task(
&self,
model_id: &str,
task_id: &str,
duration_seconds: Option<i64>,
signal: Option<CancellationToken>,
) -> Result<VideoTaskResponse> {
let mut endpoint = format!(
"/managed-models/{}/videos/tasks/{}",
urlencode(model_id),
urlencode(task_id)
);
if let Some(d) = duration_seconds.filter(|&d| d > 0) {
endpoint.push_str(&format!("?duration={d}"));
}
let (bytes, _) = self
.do_json_full_raw(
reqwest::Method::GET,
&endpoint,
None,
signal,
DEFAULT_JSON_TIMEOUT_MS,
)
.await?;
Self::unwrap_api_response(&endpoint, &bytes)
}
pub async fn chat_messages(
&self,
model_id: &str,
req: &ChatRequest,
signal: Option<CancellationToken>,
) -> Result<AnthropicResponse> {
let m = self.ensure_model_cached(model_id, signal.clone()).await?;
let adapter = get_adapter_for_model(&m);
if adapter.format() == ProviderFormat::Anthropic {
self.chat_messages_anthropic(model_id, req, adapter, signal)
.await
} else {
self.chat_messages_openai(model_id, req, adapter, signal)
.await
}
}
async fn chat_messages_anthropic(
&self,
model_id: &str,
req: &ChatRequest,
adapter: Adapter,
signal: Option<CancellationToken>,
) -> Result<AnthropicResponse> {
let mut r = req.clone();
r.stream = Some(false);
let caps = self
.cached_capabilities(model_id)
.unwrap_or_else(zero_model_capabilities);
let body_map = adapter.build_request_body(&caps, &r);
let data = serde_json::to_string(&body_map)
.map_err(|e| Error::other(format!("serialize messages request: {e}")))?;
let endpoint = format!("/managed-models/{}/anthropic", urlencode(model_id));
let (bytes, _) = self
.do_json_full_raw(
reqwest::Method::POST,
&endpoint,
Some(&data),
signal,
CHAT_REQUEST_TIMEOUT_MS,
)
.await?;
if let Ok(wrapper) = serde_json::from_slice::<serde_json::Value>(&bytes) {
if let Some(data_val) = wrapper.get("data").filter(|v| !v.is_null()) {
let code = wrapper.get("code").and_then(|v| v.as_i64()).unwrap_or(0);
if code != 0 {
let msg = wrapper
.get("message")
.and_then(|v| v.as_str())
.unwrap_or_default();
return Err(Error::business(code, msg));
}
return serde_json::from_value(data_val.clone()).map_err(|e| {
Error::other(format!("decode anthropic response (wrapped): {e}"))
});
}
}
serde_json::from_slice(&bytes)
.map_err(|e| Error::other(format!("decode anthropic response: {e}")))
}
async fn chat_messages_openai(
&self,
model_id: &str,
req: &ChatRequest,
adapter: Adapter,
signal: Option<CancellationToken>,
) -> Result<AnthropicResponse> {
let mut r = req.clone();
r.stream = Some(false);
let caps = self
.cached_capabilities(model_id)
.unwrap_or_else(zero_model_capabilities);
let body_map = adapter.build_request_body(&caps, &r);
let data = serde_json::to_string(&body_map)
.map_err(|e| Error::other(format!("serialize messages request: {e}")))?;
let endpoint = format!(
"/managed-models/{}{}",
urlencode(model_id),
adapter.endpoint_suffix()
);
let (bytes, _) = self
.do_json_full_raw(
reqwest::Method::POST,
&endpoint,
Some(&data),
signal,
CHAT_REQUEST_TIMEOUT_MS,
)
.await?;
parse_openai_response_to_anthropic(&bytes)
}
pub fn chat_stream(
&self,
model_id: &str,
req: &ChatRequest,
signal: Option<CancellationToken>,
) -> impl Stream<Item = Result<StreamEvent>> {
let this = self.clone();
let model_id = model_id.to_string();
let req = req.clone();
async_stream::try_stream! {
let inner = this.chat_stream_gen(&model_id, &req, signal, false);
futures::pin_mut!(inner);
while let Some(ev) = inner.next().await {
yield ev?;
}
}
}
pub fn chat_stream_with_usage(
&self,
model_id: &str,
req: &ChatRequest,
signal: Option<CancellationToken>,
) -> impl Stream<Item = Result<ChatUsageEvent>> {
let this = self.clone();
let model_id = model_id.to_string();
let req = req.clone();
async_stream::try_stream! {
let inner = this.chat_stream(&model_id, &req, signal);
futures::pin_mut!(inner);
while let Some(ev) = inner.next().await {
let ev = ev?;
if let Some(s) = parse_settlement(&ev) {
yield ChatUsageEvent::Settle(s);
continue;
}
if let Some(src) = parse_sources_event(&ev) {
yield ChatUsageEvent::Sources(src);
continue;
}
if ev.event == "started" {
continue;
}
if ev.event == "failed" || ev.event == "error" {
Err(Error::Stream(parse_stream_error(&ev.data)))?;
}
yield ChatUsageEvent::Content(ev);
}
}
}
pub fn chat_messages_stream(
&self,
model_id: &str,
req: &ChatRequest,
signal: Option<CancellationToken>,
) -> impl Stream<Item = Result<StreamEvent>> {
let this = self.clone();
let model_id = model_id.to_string();
let req = req.clone();
async_stream::try_stream! {
let inner = this.chat_messages_stream_gen(&model_id, &req, signal, false);
futures::pin_mut!(inner);
while let Some(ev) = inner.next().await {
yield ev?;
}
}
}
fn chat_stream_gen<'a>(
&'a self,
model_id: &'a str,
req: &'a ChatRequest,
signal: Option<CancellationToken>,
retried: bool,
) -> std::pin::Pin<Box<dyn Stream<Item = Result<StreamEvent>> + Send + 'a>> {
Box::pin(async_stream::try_stream! {
let mut r = req.clone();
r.stream = Some(true);
let (body, adapter) = self.build_chat_request(model_id, &r, signal.clone()).await?;
let token = self.ensure_token(signal.clone()).await?;
let endpoint = format!(
"/managed-models/{}{}",
urlencode(model_id),
adapter.endpoint_suffix()
);
let url = self.api_url(&endpoint);
let headers = stream_headers(&token);
let resp = self
.do_request(reqwest::Method::POST, &url, &headers, Some(&body), signal.as_ref())
.await?;
if resp.status().as_u16() == 401 && !retried {
drop(resp);
self.force_refresh(signal.clone()).await.map_err(|e| {
Error::other(format!("stream: unauthorized and refresh failed: {e}"))
})?;
let inner = self.chat_stream_gen(model_id, req, signal, true);
futures::pin_mut!(inner);
while let Some(ev) = inner.next().await {
yield ev?;
}
return;
}
if !resp.status().is_success() {
let status = resp.status().as_u16();
let retry_after = parse_retry_after_secs(resp.headers());
let text = read_limited_text(resp.bytes_stream(), MAX_ERROR_BODY_SIZE).await?;
Err(Error::Http(parse_http_error_with_retry_after(status, &text, retry_after)))?;
return;
}
let mut block_type_map: Option<HashMap<i64, BlockMeta>> =
if adapter.format() == ProviderFormat::Anthropic {
Some(HashMap::new())
} else {
None
};
let lines = iter_sse_lines(resp.bytes_stream());
futures::pin_mut!(lines);
let mut current_event = String::new();
loop {
let next: Option<Result<String>> = match &signal {
Some(cancel) => tokio::select! {
l = lines.next() => l,
_ = cancel.cancelled() => Some(Err(Error::other("stream: aborted"))),
},
None => lines.next().await,
};
let line = match next {
Some(l) => l?,
None => break,
};
if is_sse_comment_line(&line) || line.is_empty() {
continue;
}
if let Some(rest) = line.strip_prefix("event:") {
current_event = rest.trim().to_string();
} else if let Some(rest) = line.strip_prefix("data:") {
let data = rest.trim();
let (mut ev, done) = adapter.parse_stream_line(¤t_event, data)?;
if done {
return;
}
if let Some(map) = block_type_map.as_mut() {
let (idx, bt, eph) =
extract_anthropic_block_meta(¤t_event, data, map);
if !bt.is_empty() {
ev.block_index = Some(idx);
ev.block_type = Some(bt);
ev.ephemeral = Some(eph);
}
}
yield ev;
}
}
})
}
fn chat_messages_stream_gen<'a>(
&'a self,
model_id: &'a str,
req: &'a ChatRequest,
signal: Option<CancellationToken>,
retried: bool,
) -> std::pin::Pin<Box<dyn Stream<Item = Result<StreamEvent>> + Send + 'a>> {
Box::pin(async_stream::try_stream! {
let mut r = req.clone();
r.stream = Some(true);
let (body, adapter) = self.build_chat_request(model_id, &r, signal.clone()).await?;
let token = self.ensure_token(signal.clone()).await?;
let endpoint = format!(
"/managed-models/{}{}",
urlencode(model_id),
adapter.endpoint_suffix()
);
let url = self.api_url(&endpoint);
let headers = stream_headers(&token);
let resp = self
.do_request(reqwest::Method::POST, &url, &headers, Some(&body), signal.as_ref())
.await?;
if resp.status().as_u16() == 401 && !retried {
drop(resp);
self.force_refresh(signal.clone()).await.map_err(|e| {
Error::other(format!("messages stream: unauthorized and refresh failed: {e}"))
})?;
let inner = self.chat_messages_stream_gen(model_id, req, signal, true);
futures::pin_mut!(inner);
while let Some(ev) = inner.next().await {
yield ev?;
}
return;
}
if !resp.status().is_success() {
let status = resp.status().as_u16();
let retry_after = parse_retry_after_secs(resp.headers());
let text = read_limited_text(resp.bytes_stream(), MAX_ERROR_BODY_SIZE).await?;
Err(Error::Http(parse_http_error_with_retry_after(status, &text, retry_after)))?;
return;
}
let is_openai = adapter.format() == ProviderFormat::OpenAI;
let mut converter = if is_openai {
Some(crate::models::new_openai_stream_converter())
} else {
None
};
let mut block_type_map: HashMap<i64, BlockMeta> = HashMap::new();
let lines = iter_sse_lines(resp.bytes_stream());
futures::pin_mut!(lines);
let mut current_event = String::new();
loop {
let next: Option<Result<String>> = match &signal {
Some(cancel) => tokio::select! {
l = lines.next() => l,
_ = cancel.cancelled() => Some(Err(Error::other("messages stream: aborted"))),
},
None => lines.next().await,
};
let line = match next {
Some(l) => l?,
None => break,
};
if is_sse_comment_line(&line) || line.is_empty() {
continue;
}
if let Some(rest) = line.strip_prefix("event:") {
current_event = rest.trim().to_string();
} else if let Some(rest) = line.strip_prefix("data:") {
let data = rest.trim();
if let Some(conv) = converter.as_mut() {
let (events, done) = conv.convert(data)?;
for ev in events {
yield ev;
}
if done {
return;
}
} else {
let mut ev = StreamEvent {
event: current_event.clone(),
data: data.to_string(),
..Default::default()
};
let (idx, bt, eph) =
extract_anthropic_block_meta(¤t_event, data, &mut block_type_map);
if !bt.is_empty() {
ev.block_index = Some(idx);
ev.block_type = Some(bt);
ev.ephemeral = Some(eph);
}
yield ev;
}
}
}
})
}
pub(crate) fn derive_timeout_token(
&self,
timeout_ms: u64,
parent: Option<CancellationToken>,
) -> Option<CancellationToken> {
if timeout_ms == 0 {
return parent;
}
let child = CancellationToken::new();
let trigger = child.clone();
let parent_clone = parent.clone();
tokio::spawn(async move {
let timeout = tokio::time::sleep(std::time::Duration::from_millis(timeout_ms));
match parent_clone {
Some(p) => {
tokio::select! {
_ = timeout => trigger.cancel(),
_ = p.cancelled() => trigger.cancel(),
}
}
None => {
timeout.await;
trigger.cancel();
}
}
});
Some(child)
}
#[cfg(test)]
fn prime_tokens_for_test(&self, tokens: TokenSet) {
*self.inner.tokens.write().unwrap() = Some(tokens);
}
#[cfg(test)]
fn prime_meta_for_test(&self, meta: ServerMetadata) {
*self.inner.meta.write().unwrap() = Some(meta);
}
#[cfg(test)]
fn prime_model_cache_for_test(&self, models: Vec<ManagedModel>) {
*self.inner.model_cache.write().unwrap() = models;
*self.inner.model_cache_time.write().unwrap() = Some(std::time::Instant::now());
}
}
#[derive(Debug, Clone)]
pub enum ChatUsageEvent {
Content(StreamEvent),
Sources(SourcesEvent),
Settle(StreamSettlement),
}
fn stream_headers(token: &str) -> Vec<(reqwest::header::HeaderName, String)> {
vec![
(reqwest::header::AUTHORIZATION, format!("Bearer {token}")),
(
reqwest::header::CONTENT_TYPE,
"application/json".to_string(),
),
(reqwest::header::ACCEPT, "text/event-stream".to_string()),
]
}
fn parse_retry_after_secs(headers: &reqwest::header::HeaderMap) -> i64 {
headers
.get(reqwest::header::RETRY_AFTER)
.and_then(|v| v.to_str().ok())
.and_then(|s| s.trim().parse::<i64>().ok())
.filter(|&s| s > 0)
.unwrap_or(0)
}
fn header_i64(headers: &reqwest::header::HeaderMap, name: &str) -> Option<i64> {
headers
.get(name)
.and_then(|v| v.to_str().ok())
.and_then(|s| s.trim().parse::<i64>().ok())
}
async fn sleep_with_cancel(ms: u64, signal: Option<&CancellationToken>) {
let dur = std::time::Duration::from_millis(ms);
match signal {
Some(cancel) => {
tokio::select! {
_ = tokio::time::sleep(dur) => {}
_ = cancel.cancelled() => {}
}
}
None => tokio::time::sleep(dur).await,
}
}
fn urlencode(s: &str) -> String {
let mut out = String::with_capacity(s.len());
for b in s.bytes() {
match b {
b'A'..=b'Z'
| b'a'..=b'z'
| b'0'..=b'9'
| b'-'
| b'_'
| b'.'
| b'!'
| b'~'
| b'*'
| b'\''
| b'('
| b')' => out.push(b as char),
_ => out.push_str(&format!("%{b:02X}")),
}
}
out
}
fn normalize_input_modalities(mut models: Vec<ManagedModel>) -> Vec<ManagedModel> {
for m in models.iter_mut() {
if m.input_modalities.is_some() {
m.input_modalities_snake = None;
continue;
}
if let Some(snake) = m.input_modalities_snake.take() {
let filtered: Vec<InputModality> = snake
.into_iter()
.filter_map(|v| match v.as_str() {
Some("text") => Some(InputModality::Text),
Some("image") => Some(InputModality::Image),
_ => None,
})
.collect();
m.input_modalities = Some(filtered);
}
}
models
}
fn is_likely_browser_oauth_cors_error(message: &str) -> bool {
let lower = message.to_lowercase();
lower.contains("failed to fetch")
|| lower.contains("networkerror")
|| lower.contains("cors")
|| lower.contains("http 403")
}
fn default_store() -> Arc<dyn TokenStore> {
if std::env::var_os("HOME").is_some() || std::env::var_os("USERPROFILE").is_some() {
Arc::new(FileTokenStore::new(None))
} else {
Arc::new(InMemoryTokenStore::new())
}
}
pub fn normalize_gateway_base_url(input: &str) -> Result<String> {
normalize_base(input, "serverURL")
}
pub fn normalize_override_base_url(raw: &str, label: &str) -> Result<String> {
normalize_base(raw, label)
}
fn normalize_base(input: &str, label: &str) -> Result<String> {
let trimmed = input.trim();
if trimmed.is_empty() {
return Err(Error::other(format!("{label}: must not be empty")));
}
let u = Url::parse(trimmed).map_err(|e| Error::other(format!("{label}: invalid URL: {e}")))?;
match u.scheme() {
"http" | "https" => {}
s => {
return Err(Error::other(format!(
"{label}: unsupported scheme \"{s}\" (only http/https allowed)"
)))
}
}
if u.query().is_some() || u.fragment().is_some() {
return Err(Error::other(format!(
"{label}: must not contain query or fragment"
)));
}
let host = u
.host_str()
.ok_or_else(|| Error::other(format!("{label}: missing host")))?;
let mut out = format!("{}://{}", u.scheme(), host);
if let Some(port) = u.port() {
out.push_str(&format!(":{port}"));
}
let path = u.path().trim_end_matches('/');
out.push_str(path);
Ok(out)
}
#[cfg(test)]
mod p4_tests {
use super::*;
use crate::auth::types::{ServerMetadata, TokenSet};
use crate::models::types::ManagedModel;
use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
use std::sync::Arc as StdArc;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
#[test]
fn urlencode_matches_encodeuricomponent() {
assert_eq!(urlencode("claude-opus"), "claude-opus");
assert_eq!(urlencode("a b/c"), "a%20b%2Fc");
assert_eq!(urlencode("模型"), "%E6%A8%A1%E5%9E%8B");
assert_eq!(urlencode("a-_.!~*'()"), "a-_.!~*'()");
}
#[test]
fn header_i64_parses_or_none() {
let mut h = reqwest::header::HeaderMap::new();
h.insert("X-Token-Remaining", "12345".parse().unwrap());
h.insert("X-Bad", "nan".parse().unwrap());
assert_eq!(header_i64(&h, "X-Token-Remaining"), Some(12345));
assert_eq!(header_i64(&h, "X-Bad"), None);
assert_eq!(header_i64(&h, "X-Missing"), None);
}
#[test]
fn parse_retry_after_secs_filters_nonpositive() {
let mut h = reqwest::header::HeaderMap::new();
h.insert(reqwest::header::RETRY_AFTER, "30".parse().unwrap());
assert_eq!(parse_retry_after_secs(&h), 30);
h.insert(reqwest::header::RETRY_AFTER, "0".parse().unwrap());
assert_eq!(parse_retry_after_secs(&h), 0);
}
#[test]
fn anthropic_adapter_parse_stream_line_basic() {
let adapter = Adapter::Anthropic;
let (_, done) = adapter.parse_stream_line("", "[DONE]").unwrap();
assert!(done);
let (ev, done2) = adapter
.parse_stream_line(
"content_block_delta",
r#"{"index":0,"delta":{"type":"text_delta","text":"hi"}}"#,
)
.unwrap();
assert!(!done2);
assert_eq!(ev.event, "content_block_delta");
}
#[test]
fn endpoint_suffix_routing_per_adapter() {
assert_eq!(Adapter::Anthropic.endpoint_suffix(), "/anthropic");
assert_eq!(Adapter::OpenAI.endpoint_suffix(), "/chat");
let ep = format!(
"/managed-models/{}{}",
urlencode("m id"),
Adapter::OpenAI.endpoint_suffix()
);
assert_eq!(ep, "/managed-models/m%20id/chat");
}
struct MockResponse {
status: u16,
headers: Vec<(&'static str, String)>,
body: String,
}
impl MockResponse {
fn ok(body: &str) -> Self {
Self {
status: 200,
headers: vec![],
body: body.to_string(),
}
}
fn with_header(mut self, k: &'static str, v: &str) -> Self {
self.headers.push((k, v.to_string()));
self
}
fn status(status: u16, body: &str) -> Self {
Self {
status,
headers: vec![],
body: body.to_string(),
}
}
}
async fn spawn_mock(
responses: Vec<MockResponse>,
) -> (
String,
StdArc<std::sync::Mutex<Vec<String>>>,
StdArc<AtomicUsize>,
) {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let base = format!("http://{addr}");
let log = StdArc::new(std::sync::Mutex::new(Vec::<String>::new()));
let count = StdArc::new(AtomicUsize::new(0));
let log2 = log.clone();
let count2 = count.clone();
tokio::spawn(async move {
let mut idx = 0usize;
while idx < responses.len() {
let (mut sock, _) = match listener.accept().await {
Ok(s) => s,
Err(_) => break,
};
let mut buf = vec![0u8; 8192];
let n = sock.read(&mut buf).await.unwrap_or(0);
let req = String::from_utf8_lossy(&buf[..n]).to_string();
let first = req.lines().next().unwrap_or("").to_string();
let parts: Vec<&str> = first.split_whitespace().collect();
if parts.len() >= 2 {
log2.lock()
.unwrap()
.push(format!("{} {}", parts[0], parts[1]));
}
count2.fetch_add(1, AtomicOrdering::SeqCst);
let r = &responses[idx];
idx += 1;
let reason = match r.status {
200 => "OK",
401 => "Unauthorized",
500 => "Internal Server Error",
_ => "Status",
};
let mut head = format!(
"HTTP/1.1 {} {}\r\nContent-Length: {}\r\nConnection: close\r\n",
r.status,
reason,
r.body.len()
);
for (k, v) in &r.headers {
head.push_str(&format!("{k}: {v}\r\n"));
}
head.push_str("\r\n");
let _ = sock.write_all(head.as_bytes()).await;
let _ = sock.write_all(r.body.as_bytes()).await;
let _ = sock.flush().await;
let _ = sock.shutdown().await;
}
});
(base, log, count)
}
fn unexpired_token(base: &str) -> TokenSet {
TokenSet {
access_token: "AT0".to_string(),
refresh_token: "RT0".to_string(),
expires_at: "2999-01-01T00:00:00Z".to_string(),
scope: String::new(),
client_id: "cid".to_string(),
server_url: base.to_string(),
}
}
fn primed_client(base: &str) -> Client {
let client = Client::new(Config {
server_url: Some(base.to_string()),
..Default::default()
})
.unwrap();
client.prime_tokens_for_test(unexpired_token(base));
client.prime_model_cache_for_test(vec![ManagedModel {
id: "test-model".to_string(),
provider: "anthropic".to_string(),
model_id: "test-model".to_string(),
is_enabled: true,
..Default::default()
}]);
client
}
#[tokio::test]
async fn chat_routes_to_anthropic_endpoint_and_reads_headers() {
let body = r#"{"id":"msg_1","type":"message","model":"test-model","role":"assistant","content":[],"stop_reason":"end_turn","usage":{"input_tokens":1,"output_tokens":1}}"#;
let resp = MockResponse::ok(body)
.with_header("X-Token-Remaining", "999")
.with_header("X-Call-Remaining", "42");
let (base, log, _) = spawn_mock(vec![resp]).await;
let client = primed_client(&base);
let req = ChatRequest::default();
let out = client.chat("test-model", &req, None).await.unwrap();
let recorded = log.lock().unwrap().clone();
assert_eq!(recorded.len(), 1);
assert_eq!(
recorded[0],
"POST /api/v4/managed-models/test-model/anthropic"
);
assert_eq!(out.token_remaining, 999);
assert_eq!(out.call_remaining, 42);
assert_eq!(out.id, "msg_1");
}
#[tokio::test]
async fn do_json_full_empty_body_returns_none() {
let (base, _, _) = spawn_mock(vec![MockResponse::ok("")]).await;
let client = Client::new(Config {
server_url: Some(base.clone()),
..Default::default()
})
.unwrap();
client.prime_tokens_for_test(unexpired_token(&base));
let (out, _) = client
.do_json_full::<serde_json::Value>(reqwest::Method::GET, "/whatever", None, None)
.await
.unwrap();
assert!(out.is_none());
}
#[test]
fn embedding_rerank_request_serialization() {
let single = EmbeddingRequest {
input: crate::models::types::EmbeddingInput::Single("hello".into()),
dimensions: Some(512),
encoding_format: None,
};
let v = serde_json::to_value(&single).unwrap();
assert_eq!(v["input"], serde_json::json!("hello"));
assert_eq!(v["dimensions"], serde_json::json!(512));
assert!(v.get("encoding_format").is_none());
let batch = EmbeddingRequest {
input: crate::models::types::EmbeddingInput::Batch(vec!["a".into(), "b".into()]),
dimensions: None,
encoding_format: None,
};
let vb = serde_json::to_value(&batch).unwrap();
assert_eq!(vb["input"], serde_json::json!(["a", "b"]));
assert!(vb.get("dimensions").is_none());
let rr = RerankRequest {
query: "q".into(),
documents: vec!["d0".into(), "d1".into()],
top_n: Some(2),
return_documents: Some(true),
instruct: None,
};
let vr = serde_json::to_value(&rr).unwrap();
assert_eq!(vr["query"], serde_json::json!("q"));
assert_eq!(vr["documents"], serde_json::json!(["d0", "d1"]));
assert_eq!(vr["top_n"], serde_json::json!(2));
assert_eq!(vr["return_documents"], serde_json::json!(true));
assert!(vr.get("instruct").is_none());
}
#[tokio::test]
async fn embeddings_posts_and_parses_openai_response() {
let body = r#"{"object":"list","model":"text-embedding-v4","data":[{"object":"embedding","index":0,"embedding":[0.1,0.2,0.3]}],"usage":{"prompt_tokens":5,"total_tokens":5}}"#;
let (base, log, _) = spawn_mock(vec![MockResponse::ok(body)]).await;
let client = primed_client(&base);
let req = EmbeddingRequest {
input: crate::models::types::EmbeddingInput::Single("hello".into()),
dimensions: Some(512),
encoding_format: None,
};
let resp = client.embeddings("text-embedding-v4", &req, None).await.unwrap();
let recorded = log.lock().unwrap().clone();
assert_eq!(recorded.len(), 1);
assert!(
recorded[0].contains("POST") && recorded[0].contains("/managed-models/text-embedding-v4/embeddings"),
"unexpected request line: {}",
recorded[0]
);
assert_eq!(resp.model, "text-embedding-v4");
assert_eq!(resp.data.len(), 1);
assert_eq!(resp.data[0].embedding, vec![0.1, 0.2, 0.3]);
assert_eq!(resp.usage.total_tokens, 5);
}
#[tokio::test]
async fn rerank_posts_and_parses_normalized_response() {
let body = r#"{"results":[{"index":1,"relevance_score":0.93,"document":"doc1"},{"index":0,"relevance_score":0.42,"document":"doc0"}],"usage":{"total_tokens":79},"model":"gte-rerank-v2"}"#;
let (base, log, _) = spawn_mock(vec![MockResponse::ok(body)]).await;
let client = primed_client(&base);
let req = RerankRequest {
query: "q".into(),
documents: vec!["doc0".into(), "doc1".into()],
top_n: Some(2),
return_documents: Some(true),
instruct: None,
};
let resp = client.rerank("gte-rerank-v2", &req, None).await.unwrap();
let recorded = log.lock().unwrap().clone();
assert!(
recorded[0].contains("POST") && recorded[0].contains("/managed-models/gte-rerank-v2/rerank"),
"unexpected request line: {}",
recorded[0]
);
assert_eq!(resp.results.len(), 2);
assert_eq!(resp.results[0].index, 1);
assert!((resp.results[0].relevance_score - 0.93).abs() < 1e-9);
assert_eq!(resp.results[0].document.as_deref(), Some("doc1"));
assert_eq!(resp.usage.total_tokens, 79);
assert_eq!(resp.model.as_deref(), Some("gte-rerank-v2"));
}
#[tokio::test]
async fn chat_401_single_refresh_retry_then_succeeds() {
let chat_body = r#"{"id":"msg_2","type":"message","model":"test-model","role":"assistant","content":[],"stop_reason":"end_turn","usage":{"input_tokens":1,"output_tokens":1}}"#;
let token_body = r#"{"access_token":"AT1","token_type":"Bearer","expires_in":3600,"refresh_token":"RT1"}"#;
let (base, log, count) = spawn_mock(vec![
MockResponse::status(401, "{}"),
MockResponse::ok(token_body),
MockResponse::ok(chat_body),
])
.await;
let client = primed_client(&base);
client.prime_meta_for_test(ServerMetadata {
issuer: base.clone(),
authorization_endpoint: format!("{base}/authorize"),
token_endpoint: format!("{base}/token"),
revocation_endpoint: format!("{base}/revoke"),
registration_endpoint: format!("{base}/register"),
scopes_supported: vec![],
});
let req = ChatRequest::default();
let out = client.chat("test-model", &req, None).await.unwrap();
assert_eq!(out.id, "msg_2");
let recorded = log.lock().unwrap().clone();
assert_eq!(count.load(AtomicOrdering::SeqCst), 3, "exactly one retry");
assert_eq!(
recorded[0],
"POST /api/v4/managed-models/test-model/anthropic"
);
assert!(
recorded[1].starts_with("POST /token"),
"refresh hits token_endpoint: {}",
recorded[1]
);
assert_eq!(
recorded[2],
"POST /api/v4/managed-models/test-model/anthropic"
);
assert_eq!(client.token_set().unwrap().access_token, "AT1");
}
#[tokio::test]
async fn chat_401_twice_does_not_recurse() {
let token_body = r#"{"access_token":"AT1","token_type":"Bearer","expires_in":3600,"refresh_token":"RT1"}"#;
let (base, _log, count) = spawn_mock(vec![
MockResponse::status(401, "{}"),
MockResponse::ok(token_body),
MockResponse::status(401, "{}"),
])
.await;
let client = primed_client(&base);
client.prime_meta_for_test(ServerMetadata {
issuer: base.clone(),
authorization_endpoint: format!("{base}/authorize"),
token_endpoint: format!("{base}/token"),
revocation_endpoint: format!("{base}/revoke"),
registration_endpoint: format!("{base}/register"),
scopes_supported: vec![],
});
let req = ChatRequest::default();
let err = client.chat("test-model", &req, None).await.unwrap_err();
match err {
Error::Http(h) => assert_eq!(h.status_code, 401),
other => panic!("expected HttpError(401), got {other:?}"),
}
assert_eq!(
count.load(AtomicOrdering::SeqCst),
3,
"guard prevents recursion"
);
}
async fn spawn_sse_mock_realtime(gap: std::time::Duration, n_events: usize) -> String {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let base = format!("http://{addr}");
tokio::spawn(async move {
let (mut sock, _) = match listener.accept().await {
Ok(s) => s,
Err(_) => return,
};
let mut buf = vec![0u8; 8192];
let _ = sock.read(&mut buf).await;
let head = "HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\n\
Transfer-Encoding: chunked\r\n\r\n";
if sock.write_all(head.as_bytes()).await.is_err() {
return;
}
let _ = sock.flush().await;
for i in 0..n_events {
if i > 0 {
tokio::time::sleep(gap).await;
}
let payload = format!(
"event: content_block_delta\n\
data: {{\"type\":\"content_block_delta\",\"index\":0,\
\"delta\":{{\"type\":\"text_delta\",\"text\":\"chunk{i}\"}}}}\n\n"
);
let chunk = format!("{:x}\r\n{}\r\n", payload.len(), payload);
if sock.write_all(chunk.as_bytes()).await.is_err() {
return;
}
if sock.flush().await.is_err() {
return;
}
}
let _ = sock.write_all(b"0\r\n\r\n").await;
let _ = sock.flush().await;
let _ = sock.shutdown().await;
});
base
}
fn primed_client_with_http(base: &str, http: reqwest::Client) -> Client {
let client = Client::new(Config {
server_url: Some(base.to_string()),
http: Some(http),
..Default::default()
})
.unwrap();
client.prime_tokens_for_test(unexpired_token(base));
client.prime_model_cache_for_test(vec![ManagedModel {
id: "test-model".to_string(),
provider: "anthropic".to_string(),
model_id: "test-model".to_string(),
is_enabled: true,
..Default::default()
}]);
client
}
#[tokio::test]
async fn stream_aborted_by_explicit_global_timeout_control() {
let base = spawn_sse_mock_realtime(std::time::Duration::from_millis(200), 3).await;
let http = reqwest::Client::builder()
.timeout(std::time::Duration::from_millis(250))
.build()
.unwrap();
let client = primed_client_with_http(&base, http);
let req = ChatRequest::default();
let stream = client.chat_stream("test-model", &req, None);
futures::pin_mut!(stream);
let mut err_seen = false;
let mut count = 0usize;
while let Some(ev) = stream.next().await {
match ev {
Ok(_) => count += 1,
Err(_) => {
err_seen = true;
break;
}
}
}
assert!(
err_seen && count < 3,
"带全局 .timeout() 的 client 必在流式响应体中途被 abort(got {count} chunks, err={err_seen})"
);
}
#[tokio::test]
async fn stream_survives_long_body_no_global_timeout() {
let base = spawn_sse_mock_realtime(std::time::Duration::from_millis(200), 3).await;
let client = primed_client(&base);
let req = ChatRequest::default();
let stream = client.chat_stream("test-model", &req, None);
futures::pin_mut!(stream);
let mut events: Vec<StreamEvent> = Vec::new();
while let Some(ev) = stream.next().await {
let ev = ev.expect("默认 client 无全局总超时,流式响应体不应被 abort");
events.push(ev);
}
assert_eq!(
events.len(),
3,
"默认 client 必收齐 3 个 chunk(无全局总超时砍响应体)"
);
for (i, ev) in events.iter().enumerate() {
assert_eq!(ev.event, "content_block_delta");
assert!(ev.data.contains(&format!("chunk{i}")));
}
}
#[tokio::test]
async fn nonstream_chat_survives_slow_response_no_global_timeout() {
async fn spawn_slow_json(delay: std::time::Duration) -> String {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let base = format!("http://{addr}");
tokio::spawn(async move {
if let Ok((mut sock, _)) = listener.accept().await {
let mut buf = vec![0u8; 8192];
let _ = sock.read(&mut buf).await;
tokio::time::sleep(delay).await;
let body = r#"{"id":"msg_slow","type":"message","model":"test-model","role":"assistant","content":[],"stop_reason":"end_turn","usage":{"input_tokens":1,"output_tokens":1}}"#;
let resp = format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
let _ = sock.write_all(resp.as_bytes()).await;
let _ = sock.flush().await;
let _ = sock.shutdown().await;
}
});
base
}
let ctrl_base = spawn_slow_json(std::time::Duration::from_millis(400)).await;
let http = reqwest::Client::builder()
.timeout(std::time::Duration::from_millis(250))
.build()
.unwrap();
let ctrl = primed_client_with_http(&ctrl_base, http);
let err = ctrl
.chat("test-model", &ChatRequest::default(), None)
.await
.expect_err("控制组 250ms 全局 timeout 必砍 400ms 慢响应");
match err {
Error::Network(n) => assert!(n.timeout, "控制组应为 reqwest 超时错误,got: {n:?}"),
other => panic!("expected Network timeout, got {other:?}"),
}
let base = spawn_slow_json(std::time::Duration::from_millis(400)).await;
let client = primed_client(&base);
let out = client
.chat("test-model", &ChatRequest::default(), None)
.await
.expect("默认 client 无全局总超时,400ms 慢响应不应被砍");
assert_eq!(out.id, "msg_slow");
}
}