use super::{Config, ERROR_DIAGNOSTIC, catalog};
use crate::http::Transport;
use crate::options::SimpleStreamOptions;
use crate::types::{
AssistantMessage, AssistantMessageDiagnostic, AssistantMessageEvent, EventSink, Model, StopReason,
TranscriptContext,
};
use serde_json::{Map, Value};
use std::path::PathBuf;
use std::sync::{Arc, LazyLock, Mutex};
pub const ROUTE_DIAGNOSTIC: &str = "claude_subscription_route";
pub const DEFAULT_HOLD_MS: i64 = 60 * 60 * 1000;
pub const KEY_HINT: &str = "To continue on API credits until the limit resets, set ANTHROPIC_API_KEY (or store an `anthropic` api_key credential in auth.json) to a key from the Console organization that receives your plan's monthly API credits; Claude Code itself never sees that key.";
pub const BOTH_EXHAUSTED: &str = "Claude subscription usage limit reached and the Anthropic API credits are exhausted";
pub type Clock = Arc<dyn Fn() -> i64 + Send + Sync>;
pub type Lookup = Arc<dyn Fn(&str) -> Option<String> + Send + Sync>;
#[derive(Clone)]
pub struct RouterOptions {
pub clock: Clock,
pub env: Lookup,
pub agent_dir: Option<PathBuf>,
pub subscription: Option<Config>,
pub api_base_url: Option<String>,
}
impl Default for RouterOptions {
fn default() -> Self {
RouterOptions {
clock: Arc::new(jsrt::date::now_ms),
env: Arc::new(|name| std::env::var(name).ok().filter(|v| !v.is_empty())),
agent_dir: None,
subscription: None,
api_base_url: None,
}
}
}
pub struct Router {
options: RouterOptions,
hold: Mutex<Option<i64>>,
}
static GLOBAL: LazyLock<Arc<Router>> = LazyLock::new(|| Arc::new(Router::new(RouterOptions::default())));
pub fn global() -> Arc<Router> {
GLOBAL.clone()
}
struct Gate<'s, 'e> {
sink: &'s mut EventSink<'e>,
start: Option<AssistantMessageEvent>,
committed: bool,
}
impl<'s, 'e> Gate<'s, 'e> {
fn new(sink: &'s mut EventSink<'e>) -> Self {
Gate {
sink,
start: None,
committed: false,
}
}
fn event(&mut self, event: &AssistantMessageEvent) {
match event {
AssistantMessageEvent::Start { .. } if !self.committed => self.start = Some(event.clone()),
AssistantMessageEvent::Done { .. } | AssistantMessageEvent::Error { .. } => {}
_ => {
self.commit();
(self.sink)(event);
}
}
}
fn commit(&mut self) {
self.committed = true;
if let Some(start) = self.start.take() {
(self.sink)(&start);
}
}
fn finish(mut self, message: &AssistantMessage) {
self.commit();
let reason = message.stop_reason;
let event = if matches!(reason, StopReason::Error | StopReason::Aborted) {
AssistantMessageEvent::Error {
reason,
error: message.clone(),
}
} else {
AssistantMessageEvent::Done {
reason,
message: message.clone(),
}
};
(self.sink)(&event);
}
}
pub fn usage_limit_of(message: &AssistantMessage) -> Option<Option<i64>> {
let details = message
.diagnostics
.iter()
.flatten()
.find(|d| d.kind == ERROR_DIAGNOSTIC)?
.details
.as_ref()?;
(details.get("usage_limit") == Some(&Value::Bool(true))).then(|| details.get("resets_at").and_then(Value::as_i64))
}
fn billing_exhausted(text: &str) -> bool {
let text = text.to_lowercase();
text.contains("credit balance") || text.contains("billing")
}
fn adaptive_family(id: &str) -> bool {
[
"opus-4-6",
"opus-4.6",
"opus-4-7",
"opus-4.7",
"opus-4-8",
"opus-4.8",
"opus-5",
"opus.5",
"sonnet-4-6",
"sonnet-4.6",
"sonnet-5",
"sonnet.5",
"fable-5",
"mythos-5",
"haiku-5",
"haiku.5",
]
.iter()
.any(|family| id.contains(family))
}
fn family_template(id: &str) -> Option<&'static Model> {
let mut stem = id;
while let Some((head, version)) = stem.rsplit_once('-') {
if version.is_empty() || !version.chars().all(|c| c.is_ascii_digit()) {
return None;
}
if let Some(model) = crate::models::builtin_model("anthropic", head) {
return Some(model);
}
stem = head;
}
None
}
pub fn api_model(model: &Model) -> Model {
let id = catalog::canonical(&model.id);
if let Some(known) = crate::models::builtin_model("anthropic", id) {
return known.clone();
}
let mut api = family_template(id).cloned().unwrap_or_else(|| {
let mut api = model.clone();
api.api = "anthropic-messages".into();
api.provider = "anthropic".into();
api
});
api.id = id.to_string();
api.name = model.name.clone();
api.base_url = catalog::UPSTREAM.into();
if adaptive_family(id) {
api.reasoning = true;
api.compat
.get_or_insert_default()
.insert("forceAdaptiveThinking".into(), Value::Bool(true));
}
if catalog::MANDATORY_THINKING.iter().any(|family| id.starts_with(family)) {
let levels = api.thinking_level_map.get_or_insert_default();
levels.insert("off".into(), None);
levels.insert("minimal".into(), None);
}
api
}
fn route(route: &str, notice: String, extra: Map<String, Value>) -> AssistantMessageDiagnostic {
let mut details = Map::new();
details.insert("route".into(), route.into());
details.insert("notice".into(), notice.into());
details.extend(extra);
AssistantMessageDiagnostic {
kind: ROUTE_DIAGNOSTIC.into(),
timestamp: jsrt::date::now_ms(),
error: None,
details: Some(details),
}
}
pub fn api_notice(until: i64) -> String {
format!(
"Claude subscription limit reached; using API credits until {}",
jsrt::date::iso_string(until)
)
}
pub const SUBSCRIPTION_NOTICE: &str = "Claude subscription available again; back on the subscription";
impl Router {
pub fn new(options: RouterOptions) -> Self {
Router {
options,
hold: Mutex::new(None),
}
}
pub fn held_until(&self) -> Option<i64> {
*jsrt::sync::lock(&self.hold)
}
fn start_hold(&self, until: i64) {
let mut hold = jsrt::sync::lock(&self.hold);
*hold = Some(hold.map_or(until, |held| held.max(until)));
}
fn end_hold(&self, until: i64) {
let mut hold = jsrt::sync::lock(&self.hold);
if *hold == Some(until) {
*hold = None;
}
}
#[allow(clippy::too_many_arguments)]
async fn api_held(
&self,
until: i64,
model: &Model,
context: &TranscriptContext,
options: &SimpleStreamOptions,
transport: &dyn Transport,
sink: &mut EventSink<'_>,
key: &str,
switched: Option<Switch>,
) -> AssistantMessage {
let message = self.api(model, context, options, transport, sink, key, switched).await;
if message.stop_reason == StopReason::Error {
self.end_hold(until);
}
message
}
fn agent_dir(&self) -> PathBuf {
self.options.agent_dir.clone().unwrap_or_else(|| {
let env = &self.options.env;
let home = env("HOME").map(PathBuf::from).unwrap_or_default();
config::paths::agent_dir(|name| env(name), &home)
})
}
fn configured_base_url(&self) -> Option<String> {
let path = config::paths::AgentPaths::new(self.agent_dir()).models();
crate::model_config::ModelConfig::load(Some(&path.to_string_lossy()))
.provider("anthropic")?
.get("baseUrl")?
.as_str()
.filter(|url| !url.trim().is_empty())
.map(str::to_string)
}
fn enabled(&self, agent_dir: &std::path::Path) -> bool {
config::settings::SettingsManager::create(agent_dir, agent_dir, false).claude_api_fallback()
}
fn api_key(&self, options: &SimpleStreamOptions, agent_dir: &std::path::Path) -> Option<String> {
let usable = |key: &String| !key.trim().is_empty() && !crate::anthropic::is_oauth_token(key);
let name = crate::env::ANTHROPIC_API_KEY_ENV;
let request = options.base.env.as_ref().and_then(|env| env.get(name)).cloned();
if let Some(key) = request.or_else(|| (self.options.env)(name)).filter(usable) {
return Some(key);
}
let path = config::paths::AgentPaths::new(agent_dir).auth();
let stored = config::auth::read_stored_credential(&path, "anthropic")?;
if stored.get("type").and_then(Value::as_str) != Some("api_key") {
return None;
}
let resolved = config::auth::AuthStorage::create(path).read("anthropic").ok()??;
resolved
.get("key")
.and_then(Value::as_str)
.map(str::to_string)
.filter(usable)
}
async fn subscription(
&self,
model: &Model,
context: &TranscriptContext,
options: &SimpleStreamOptions,
sink: &mut EventSink<'_>,
) -> AssistantMessage {
match &self.options.subscription {
Some(config) => super::stream_with(model, context, options, config.clone(), sink).await,
None => super::stream_simple(model, context, options, sink).await,
}
}
pub async fn stream_claude_code(
&self,
model: &Model,
context: &TranscriptContext,
options: &SimpleStreamOptions,
sink: &mut EventSink<'_>,
) -> Option<AssistantMessage> {
use super::claude_code_lane::{Route, refuse, route};
let env = || {
let config = self.options.subscription.clone().unwrap_or_default();
super::process::base_env(&config, options.base.env.as_ref())
};
let subscription = match route(model, context, env)? {
Route::Refused(error) => return Some(refuse(model, error, sink)),
Route::Subscription(subscription) => subscription,
};
if self.options.subscription.is_some() {
return Some(self.subscription(&subscription, context, options, sink).await);
}
let config = super::config_for(&subscription, options).and_then(|(mut config, _)| {
let cli_env = crate::claude_code_cli::child_env(&options.base);
let bin = crate::claude_code_cli::resolve_claude_cli(&cli_env).map_err(super::ClaudeError::Missing)?;
config.command = Some(vec![bin]);
Ok(config)
});
Some(match config {
Ok(config) => super::stream_with(&subscription, context, options, config, sink).await,
Err(error) => refuse(model, error.to_string(), sink),
})
}
pub async fn stream(
&self,
model: &Model,
context: &TranscriptContext,
options: &SimpleStreamOptions,
transport: &dyn Transport,
sink: &mut EventSink<'_>,
) -> AssistantMessage {
let agent_dir = self.agent_dir();
if !self.enabled(&agent_dir) {
*jsrt::sync::lock(&self.hold) = None;
return self.subscription(model, context, options, sink).await;
}
let now = (self.options.clock)();
let mut expired = false;
if let Some(until) = self.held_until() {
if now < until {
if let Some(key) = self.api_key(options, &agent_dir) {
return self
.api_held(until, model, context, options, transport, sink, &key, None)
.await;
}
} else {
expired = true;
}
self.end_hold(until);
}
let mut gate = Gate::new(sink);
let mut message = {
let mut forward = |event: &AssistantMessageEvent| gate.event(event);
self.subscription(model, context, options, &mut forward).await
};
let limit = usage_limit_of(&message);
match limit {
Some(resets_at) if !gate.committed => match self.api_key(options, &agent_dir) {
Some(key) => {
let until = resets_at.filter(|r| *r > now).unwrap_or(now + DEFAULT_HOLD_MS);
self.start_hold(until);
let switched = Switch {
until,
reason: message.error_message.clone().unwrap_or_default(),
};
return self
.api_held(
until,
model,
context,
options,
transport,
gate.sink,
&key,
Some(switched),
)
.await;
}
None => {
let error = message.error_message.get_or_insert_default();
error.push_str(&format!(" ({KEY_HINT})"));
}
},
_ if expired => {
let mut extra = Map::new();
extra.insert("provider".into(), super::PROVIDER.into());
message
.diagnostics
.get_or_insert_default()
.insert(0, route("subscription", SUBSCRIPTION_NOTICE.into(), extra));
}
_ => {}
}
gate.finish(&message);
message
}
#[allow(clippy::too_many_arguments)]
async fn api(
&self,
model: &Model,
context: &TranscriptContext,
options: &SimpleStreamOptions,
transport: &dyn Transport,
sink: &mut EventSink<'_>,
key: &str,
switched: Option<Switch>,
) -> AssistantMessage {
let mut api_model = api_model(model);
if let Some(base) = self.options.api_base_url.clone().or_else(|| self.configured_base_url()) {
api_model.base_url = base;
}
let mut request = options.clone();
request.base.api_key = Some(key.to_string());
let mut gate = Gate::new(sink);
let result = {
let mut forward = |event: &AssistantMessageEvent| gate.event(event);
crate::anthropic::stream_simple(&api_model, context, &request, transport, &mut forward).await
};
let mut message = result.unwrap_or_else(|error| {
let mut message = AssistantMessage::pending(&api_model, jsrt::date::now_ms());
message.stop_reason = StopReason::Error;
message.error_message = Some(error);
message
});
if message.stop_reason == StopReason::Error
&& let Some(error) = message.error_message.clone().filter(|e| billing_exhausted(e))
{
let until = self
.held_until()
.map(|u| format!(" until {}", jsrt::date::iso_string(u)))
.unwrap_or_default();
message.error_message = Some(format!(
"{BOTH_EXHAUSTED}: the subscription is out of usage{until}, and the API answered: {error}"
));
}
if let Some(switched) = switched {
let mut extra = Map::new();
extra.insert("provider".into(), "anthropic".into());
extra.insert("model".into(), api_model.id.clone().into());
extra.insert("until".into(), switched.until.into());
extra.insert("reason".into(), switched.reason.into());
message
.diagnostics
.get_or_insert_default()
.insert(0, route("api", api_notice(switched.until), extra));
}
gate.finish(&message);
message
}
}
struct Switch {
until: i64,
reason: String,
}