mirror of
https://github.com/fawney19/Aether.git
synced 2026-10-08 18:37:46 +08:00
483 lines
16 KiB
Rust
483 lines
16 KiB
Rust
use std::collections::{BTreeMap, BTreeSet};
|
|
use std::sync::{Arc, OnceLock};
|
|
|
|
use aether_ai_formats::client_profile::ClientProfileStore;
|
|
|
|
use aether_ai_formats::ApiOperation;
|
|
|
|
pub const CLAUDE_CODE_CONTEXT_MANAGEMENT_BETA: &str = "context-management-2025-06-27";
|
|
|
|
/// Built-in Claude Code CLI version used until the gateway publishes a newer
|
|
/// verified release (or when release checks are disabled / unavailable).
|
|
pub const CLAUDE_CODE_BUILTIN_CLI_VERSION: &str = "2.1.284";
|
|
|
|
const MESSAGE_BETAS_2026_04: &[&str] = &[
|
|
"claude-code-20250219",
|
|
"oauth-2025-04-20",
|
|
"interleaved-thinking-2025-05-14",
|
|
"prompt-caching-scope-2026-01-05",
|
|
"effort-2025-11-24",
|
|
CLAUDE_CODE_CONTEXT_MANAGEMENT_BETA,
|
|
"extended-cache-ttl-2025-04-11",
|
|
];
|
|
const COUNT_TOKENS_BETAS_2026_04: &[&str] = &[
|
|
"claude-code-20250219",
|
|
"oauth-2025-04-20",
|
|
"interleaved-thinking-2025-05-14",
|
|
"prompt-caching-scope-2026-01-05",
|
|
"effort-2025-11-24",
|
|
CLAUDE_CODE_CONTEXT_MANAGEMENT_BETA,
|
|
"extended-cache-ttl-2025-04-11",
|
|
"token-counting-2024-11-01",
|
|
];
|
|
const DROPPED_BETAS_2026_04: &[&str] = &[];
|
|
const BODY_CAPABILITY_GATES_2026_04: &[ClaudeCodeBodyCapabilityGate] =
|
|
&[ClaudeCodeBodyCapabilityGate {
|
|
body_field: "context_management",
|
|
beta_token: CLAUDE_CODE_CONTEXT_MANAGEMENT_BETA,
|
|
inject_when_thinking_enabled: true,
|
|
default_edit_type: Some("clear_thinking_20251015"),
|
|
}];
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum ClaudeCodeTransportIdentityProfileVersion {
|
|
V2026_04,
|
|
}
|
|
|
|
impl ClaudeCodeTransportIdentityProfileVersion {
|
|
pub const fn as_str(self) -> &'static str {
|
|
match self {
|
|
Self::V2026_04 => "2026-04",
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub struct ClaudeCodeBodyCapabilityGate {
|
|
pub body_field: &'static str,
|
|
pub beta_token: &'static str,
|
|
pub inject_when_thinking_enabled: bool,
|
|
pub default_edit_type: Option<&'static str>,
|
|
}
|
|
|
|
/// Dynamic Claude Code CLI identity (version-derived wire values).
|
|
///
|
|
/// The gateway refreshes this from verified official releases in a background
|
|
/// task; request paths only read an immutable snapshot and never touch the
|
|
/// network.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ClaudeCodeClientProfile {
|
|
pub cli_version: String,
|
|
pub user_agent: String,
|
|
}
|
|
|
|
impl ClaudeCodeClientProfile {
|
|
/// Builds a CLI profile from a release version. Release verification is owned
|
|
/// by the release checker; the constructor only rejects clearly invalid values.
|
|
pub fn cli(version: &str) -> Result<Self, &'static str> {
|
|
let version = version.trim();
|
|
if version.is_empty()
|
|
|| version.len() > 64
|
|
|| !version.bytes().all(|byte| (33..=126).contains(&byte))
|
|
{
|
|
return Err("invalid Claude Code CLI version");
|
|
}
|
|
Ok(Self {
|
|
cli_version: version.to_owned(),
|
|
user_agent: format!("claude-cli/{version} (external, cli)"),
|
|
})
|
|
}
|
|
}
|
|
|
|
impl Default for ClaudeCodeClientProfile {
|
|
fn default() -> Self {
|
|
Self::cli(CLAUDE_CODE_BUILTIN_CLI_VERSION)
|
|
.expect("built-in Claude Code CLI profile must be valid")
|
|
}
|
|
}
|
|
|
|
static ACTIVE_CLIENT_PROFILE: OnceLock<ClientProfileStore<ClaudeCodeClientProfile>> =
|
|
OnceLock::new();
|
|
|
|
fn active_client_profile() -> &'static ClientProfileStore<ClaudeCodeClientProfile> {
|
|
ACTIVE_CLIENT_PROFILE
|
|
.get_or_init(|| ClientProfileStore::new(ClaudeCodeClientProfile::default()))
|
|
}
|
|
|
|
/// Returns a snapshot of the active CLI profile without holding the global lock.
|
|
pub fn claude_code_client_profile() -> Arc<ClaudeCodeClientProfile> {
|
|
active_client_profile().snapshot()
|
|
}
|
|
|
|
/// Atomically replaces the active CLI profile and returns the previous one.
|
|
pub fn set_claude_code_client_profile(
|
|
profile: ClaudeCodeClientProfile,
|
|
) -> Arc<ClaudeCodeClientProfile> {
|
|
active_client_profile().publish(profile)
|
|
}
|
|
|
|
/// Publishes a CLI profile for the given release version.
|
|
pub fn set_claude_code_cli_version(
|
|
version: &str,
|
|
) -> Result<Arc<ClaudeCodeClientProfile>, &'static str> {
|
|
let profile = ClaudeCodeClientProfile::cli(version)?;
|
|
Ok(set_claude_code_client_profile(profile))
|
|
}
|
|
|
|
/// Returns the active Claude Code CLI version.
|
|
pub fn claude_code_client_version() -> String {
|
|
claude_code_client_profile().cli_version.clone()
|
|
}
|
|
|
|
/// Returns the active Claude Code CLI User-Agent.
|
|
pub fn claude_code_client_user_agent() -> String {
|
|
claude_code_client_profile().user_agent.clone()
|
|
}
|
|
|
|
/// Versioned, static part of the Claude Code transport identity: Stainless SDK
|
|
/// and runtime values, beta policy and body capability gates. These values are
|
|
/// calibrated together and change only with a new template version; the CLI
|
|
/// version itself is supplied by the dynamic [`ClaudeCodeClientProfile`].
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub struct ClaudeCodeTransportIdentityTemplate {
|
|
version: ClaudeCodeTransportIdentityProfileVersion,
|
|
transport_profile_id: &'static str,
|
|
anthropic_version: &'static str,
|
|
stainless_lang: &'static str,
|
|
stainless_package_version: &'static str,
|
|
stainless_os: &'static str,
|
|
stainless_arch: &'static str,
|
|
stainless_runtime: &'static str,
|
|
stainless_runtime_version: &'static str,
|
|
stainless_retry_count: &'static str,
|
|
stainless_timeout: &'static str,
|
|
message_required_betas: &'static [&'static str],
|
|
count_tokens_required_betas: &'static [&'static str],
|
|
preserve_incoming_betas: bool,
|
|
dropped_betas: &'static [&'static str],
|
|
body_capability_gates: &'static [ClaudeCodeBodyCapabilityGate],
|
|
}
|
|
|
|
pub const CLAUDE_CODE_TRANSPORT_IDENTITY_2026_04: ClaudeCodeTransportIdentityTemplate =
|
|
ClaudeCodeTransportIdentityTemplate {
|
|
version: ClaudeCodeTransportIdentityProfileVersion::V2026_04,
|
|
transport_profile_id: "claude_code_nodejs",
|
|
anthropic_version: "2023-06-01",
|
|
stainless_lang: "js",
|
|
stainless_package_version: "0.112.1",
|
|
stainless_os: "Linux",
|
|
stainless_arch: "arm64",
|
|
stainless_runtime: "node",
|
|
stainless_runtime_version: "v26.3.0",
|
|
stainless_retry_count: "0",
|
|
stainless_timeout: "600",
|
|
message_required_betas: MESSAGE_BETAS_2026_04,
|
|
count_tokens_required_betas: COUNT_TOKENS_BETAS_2026_04,
|
|
preserve_incoming_betas: true,
|
|
dropped_betas: DROPPED_BETAS_2026_04,
|
|
body_capability_gates: BODY_CAPABILITY_GATES_2026_04,
|
|
};
|
|
|
|
/// Upstream identity used when Aether is intentionally acting as a Claude Code
|
|
/// transport. Native Anthropic transports never resolve this profile and
|
|
/// therefore keep their original headers and body untouched.
|
|
///
|
|
/// Each value is one coherent snapshot of the static template plus the active
|
|
/// CLI profile, so headers and billing attribution derived from the same
|
|
/// snapshot always agree on the CLI version.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ClaudeCodeTransportIdentityProfile {
|
|
template: &'static ClaudeCodeTransportIdentityTemplate,
|
|
client: Arc<ClaudeCodeClientProfile>,
|
|
}
|
|
|
|
pub fn current_claude_code_transport_identity_profile() -> ClaudeCodeTransportIdentityProfile {
|
|
ClaudeCodeTransportIdentityProfile::new(
|
|
&CLAUDE_CODE_TRANSPORT_IDENTITY_2026_04,
|
|
claude_code_client_profile(),
|
|
)
|
|
}
|
|
|
|
impl ClaudeCodeTransportIdentityProfile {
|
|
pub fn new(
|
|
template: &'static ClaudeCodeTransportIdentityTemplate,
|
|
client: Arc<ClaudeCodeClientProfile>,
|
|
) -> Self {
|
|
Self { template, client }
|
|
}
|
|
|
|
pub fn version(&self) -> ClaudeCodeTransportIdentityProfileVersion {
|
|
self.template.version
|
|
}
|
|
|
|
pub fn transport_profile_id(&self) -> &'static str {
|
|
self.template.transport_profile_id
|
|
}
|
|
|
|
pub fn cli_version(&self) -> &str {
|
|
&self.client.cli_version
|
|
}
|
|
|
|
pub fn billing_cli_version(&self) -> &str {
|
|
&self.client.cli_version
|
|
}
|
|
|
|
pub fn user_agent(&self) -> &str {
|
|
&self.client.user_agent
|
|
}
|
|
|
|
pub fn stainless_package_version(&self) -> &'static str {
|
|
self.template.stainless_package_version
|
|
}
|
|
|
|
pub fn stainless_lang(&self) -> &'static str {
|
|
self.template.stainless_lang
|
|
}
|
|
|
|
pub fn stainless_os(&self) -> &'static str {
|
|
self.template.stainless_os
|
|
}
|
|
|
|
pub fn stainless_arch(&self) -> &'static str {
|
|
self.template.stainless_arch
|
|
}
|
|
|
|
pub fn stainless_runtime(&self) -> &'static str {
|
|
self.template.stainless_runtime
|
|
}
|
|
|
|
pub fn stainless_runtime_version(&self) -> &'static str {
|
|
self.template.stainless_runtime_version
|
|
}
|
|
|
|
pub fn stainless_retry_count(&self) -> &'static str {
|
|
self.template.stainless_retry_count
|
|
}
|
|
|
|
pub fn stainless_timeout(&self) -> &'static str {
|
|
self.template.stainless_timeout
|
|
}
|
|
|
|
pub fn required_beta_tokens(&self, operation: Option<ApiOperation>) -> &'static [&'static str] {
|
|
if operation == Some(ApiOperation::ClaudeCountTokens) {
|
|
self.template.count_tokens_required_betas
|
|
} else {
|
|
self.template.message_required_betas
|
|
}
|
|
}
|
|
|
|
pub fn preserves_incoming_betas(&self) -> bool {
|
|
self.template.preserve_incoming_betas
|
|
}
|
|
|
|
pub fn dropped_beta_tokens(&self) -> &'static [&'static str] {
|
|
self.template.dropped_betas
|
|
}
|
|
|
|
pub fn body_capability_gates(&self) -> &'static [ClaudeCodeBodyCapabilityGate] {
|
|
self.template.body_capability_gates
|
|
}
|
|
|
|
pub fn body_capability_gate(&self, field: &str) -> Option<ClaudeCodeBodyCapabilityGate> {
|
|
self.template
|
|
.body_capability_gates
|
|
.iter()
|
|
.copied()
|
|
.find(|gate| gate.body_field == field)
|
|
}
|
|
|
|
pub fn apply_fixed_headers(&self, headers: &mut BTreeMap<String, String>, stream: bool) {
|
|
let template = self.template;
|
|
for (name, value) in [
|
|
("accept", "application/json"),
|
|
("anthropic-version", template.anthropic_version),
|
|
("anthropic-dangerous-direct-browser-access", "true"),
|
|
("x-app", "cli"),
|
|
("x-stainless-lang", template.stainless_lang),
|
|
(
|
|
"x-stainless-package-version",
|
|
template.stainless_package_version,
|
|
),
|
|
("x-stainless-os", template.stainless_os),
|
|
("x-stainless-arch", template.stainless_arch),
|
|
("x-stainless-runtime", template.stainless_runtime),
|
|
(
|
|
"x-stainless-runtime-version",
|
|
template.stainless_runtime_version,
|
|
),
|
|
("x-stainless-retry-count", template.stainless_retry_count),
|
|
("x-stainless-timeout", template.stainless_timeout),
|
|
] {
|
|
headers.retain(|existing, _| !existing.eq_ignore_ascii_case(name));
|
|
headers.insert(name.to_string(), value.to_string());
|
|
}
|
|
headers.retain(|name, _| {
|
|
!name.eq_ignore_ascii_case("user-agent")
|
|
&& !name.eq_ignore_ascii_case("x-stainless-helper-method")
|
|
});
|
|
headers.insert("user-agent".to_string(), self.user_agent().to_string());
|
|
if stream {
|
|
headers.insert(
|
|
"x-stainless-helper-method".to_string(),
|
|
"stream".to_string(),
|
|
);
|
|
} else {
|
|
headers.remove("x-stainless-helper-method");
|
|
}
|
|
}
|
|
|
|
pub fn apply_beta_policy(
|
|
&self,
|
|
headers: &mut BTreeMap<String, String>,
|
|
operation: Option<ApiOperation>,
|
|
) {
|
|
let incoming = headers
|
|
.iter()
|
|
.filter(|(name, _)| name.eq_ignore_ascii_case("anthropic-beta"))
|
|
.map(|(_, value)| value.as_str())
|
|
.collect::<Vec<_>>()
|
|
.join(",");
|
|
let merged = self.merge_beta_tokens(Some(&incoming), operation);
|
|
headers.retain(|name, _| !name.eq_ignore_ascii_case("anthropic-beta"));
|
|
if merged.is_empty() {
|
|
headers.remove("anthropic-beta");
|
|
} else {
|
|
headers.insert("anthropic-beta".to_string(), merged);
|
|
}
|
|
}
|
|
|
|
pub fn merge_beta_tokens(
|
|
&self,
|
|
incoming: Option<&str>,
|
|
operation: Option<ApiOperation>,
|
|
) -> String {
|
|
let mut seen = BTreeSet::new();
|
|
let mut merged = Vec::new();
|
|
|
|
for token in self.required_beta_tokens(operation) {
|
|
self.append_beta_token(&mut seen, &mut merged, token);
|
|
}
|
|
if self.template.preserve_incoming_betas {
|
|
for token in incoming.unwrap_or_default().split(',') {
|
|
self.append_beta_token(&mut seen, &mut merged, token);
|
|
}
|
|
}
|
|
merged.join(",")
|
|
}
|
|
|
|
pub fn beta_header_enables_body_field(&self, beta_header: &str, field: &str) -> bool {
|
|
let Some(gate) = self.body_capability_gate(field) else {
|
|
return true;
|
|
};
|
|
beta_header
|
|
.split(',')
|
|
.map(str::trim)
|
|
.any(|token| token.eq_ignore_ascii_case(gate.beta_token))
|
|
}
|
|
|
|
fn append_beta_token(
|
|
&self,
|
|
seen: &mut BTreeSet<String>,
|
|
merged: &mut Vec<String>,
|
|
token: &str,
|
|
) {
|
|
let token = token.trim();
|
|
if token.is_empty()
|
|
|| self
|
|
.template
|
|
.dropped_betas
|
|
.iter()
|
|
.any(|dropped| token.eq_ignore_ascii_case(dropped))
|
|
{
|
|
return;
|
|
}
|
|
if seen.insert(token.to_ascii_lowercase()) {
|
|
merged.push(token.to_string());
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use std::sync::Arc;
|
|
|
|
use super::{
|
|
current_claude_code_transport_identity_profile, ClaudeCodeClientProfile,
|
|
ClaudeCodeTransportIdentityProfile, CLAUDE_CODE_TRANSPORT_IDENTITY_2026_04,
|
|
};
|
|
use aether_ai_formats::ApiOperation;
|
|
|
|
#[test]
|
|
fn profile_versions_cli_user_agent_stainless_and_billing_together() {
|
|
let profile = current_claude_code_transport_identity_profile();
|
|
|
|
assert_eq!(profile.version().as_str(), "2026-04");
|
|
assert_eq!(profile.cli_version(), "2.1.284");
|
|
assert_eq!(profile.billing_cli_version(), profile.cli_version());
|
|
assert_eq!(
|
|
profile.user_agent(),
|
|
format!("claude-cli/{} (external, cli)", profile.cli_version())
|
|
);
|
|
assert_eq!(profile.stainless_package_version(), "0.112.1");
|
|
assert_eq!(profile.stainless_runtime_version(), "v26.3.0");
|
|
}
|
|
|
|
#[test]
|
|
fn cli_profile_derives_wire_identity_from_version() {
|
|
let client = ClaudeCodeClientProfile::cli(" 2.1.300 ").expect("valid version");
|
|
assert_eq!(client.cli_version, "2.1.300");
|
|
assert_eq!(client.user_agent, "claude-cli/2.1.300 (external, cli)");
|
|
|
|
// A snapshot keeps headers and billing attribution on the same CLI version
|
|
// without mutating the process-wide active profile.
|
|
let profile = ClaudeCodeTransportIdentityProfile::new(
|
|
&CLAUDE_CODE_TRANSPORT_IDENTITY_2026_04,
|
|
Arc::new(client),
|
|
);
|
|
let mut headers = std::collections::BTreeMap::new();
|
|
profile.apply_fixed_headers(&mut headers, false);
|
|
assert_eq!(
|
|
headers.get("user-agent").map(String::as_str),
|
|
Some("claude-cli/2.1.300 (external, cli)")
|
|
);
|
|
assert_eq!(profile.billing_cli_version(), "2.1.300");
|
|
assert_eq!(
|
|
headers
|
|
.get("x-stainless-package-version")
|
|
.map(String::as_str),
|
|
Some("0.112.1")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn cli_profile_rejects_empty_or_control_values() {
|
|
assert!(ClaudeCodeClientProfile::cli("").is_err());
|
|
assert!(ClaudeCodeClientProfile::cli("2.1.0\nspoof").is_err());
|
|
assert!(ClaudeCodeClientProfile::cli("2.1.0 spoof").is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn profile_preserves_context_1m_and_adds_operation_specific_betas() {
|
|
let profile = current_claude_code_transport_identity_profile();
|
|
let messages = profile.merge_beta_tokens(Some("context-1m-2025-08-07,custom"), None);
|
|
|
|
assert!(messages
|
|
.split(',')
|
|
.any(|token| token == "context-1m-2025-08-07"));
|
|
assert!(messages.split(',').any(|token| token == "custom"));
|
|
assert!(!messages
|
|
.split(',')
|
|
.any(|token| token == "token-counting-2024-11-01"));
|
|
|
|
let count_tokens = profile.merge_beta_tokens(
|
|
Some("context-1m-2025-08-07"),
|
|
Some(ApiOperation::ClaudeCountTokens),
|
|
);
|
|
assert!(count_tokens
|
|
.split(',')
|
|
.any(|token| token == "token-counting-2024-11-01"));
|
|
assert!(profile.dropped_beta_tokens().is_empty());
|
|
assert!(profile.preserves_incoming_betas());
|
|
}
|
|
}
|