feat: cache-tracking progress

rust/Cargo.lock

@@ -25,7 +25,6 @@ dependencies = [
  "runtime",
  "serde",
  "serde_json",
- "telemetry",
  "tokio",
 ]
 
@@ -1097,7 +1096,6 @@ dependencies = [
  "serde",
  "serde_json",
  "sha2",
- "telemetry",
  "tokio",
  "walkdir",
 ]
@@ -1430,14 +1428,6 @@ dependencies = [
  "yaml-rust",
 ]
 
-[[package]]
-name = "telemetry"
-version = "0.1.0"
-dependencies = [
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "thiserror"
 version = "2.0.18"

rust/crates/api/Cargo.toml

@@ -10,7 +10,6 @@ reqwest = { version = "0.12", default-features = false, features = ["json", "rus
 runtime = { path = "../runtime" }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-telemetry = { path = "../telemetry" }
 tokio = { version = "1", features = ["io-util", "macros", "net", "rt-multi-thread", "time"] }
 
 [lints]

rust/crates/api/src/client.rs

@@ -1,20 +1,20 @@
 use std::collections::VecDeque;
+use std::sync::{Arc, Mutex};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use runtime::{
-    format_usd, load_oauth_credentials, pricing_for_model, save_oauth_credentials, OAuthConfig,
-    OAuthRefreshRequest, OAuthTokenExchangeRequest,
+    load_oauth_credentials, save_oauth_credentials, OAuthConfig, OAuthRefreshRequest,
+    OAuthTokenExchangeRequest,
 };
 use serde::Deserialize;
-use serde_json::{Map, Value};
-use telemetry::{AnalyticsEvent, AnthropicRequestProfile, ClientIdentity, SessionTracer};
 
 use crate::error::ApiError;
+use crate::prompt_cache::{PromptCache, PromptCacheRecord, PromptCacheStats};
 use crate::sse::SseParser;
-use crate::types::{MessageRequest, MessageResponse, StreamEvent};
+use crate::types::{MessageRequest, MessageResponse, StreamEvent, Usage};
 
 const DEFAULT_BASE_URL: &str = "https://api.anthropic.com";
-const MESSAGES_PATH: &str = "/v1/messages";
+const ANTHROPIC_VERSION: &str = "2023-06-01";
 const REQUEST_ID_HEADER: &str = "request-id";
 const ALT_REQUEST_ID_HEADER: &str = "x-request-id";
 const DEFAULT_INITIAL_BACKOFF: Duration = Duration::from_millis(200);
@@ -110,8 +110,8 @@ pub struct AnthropicClient {
     max_retries: u32,
     initial_backoff: Duration,
     max_backoff: Duration,
-    request_profile: AnthropicRequestProfile,
-    session_tracer: Option<SessionTracer>,
+    prompt_cache: Option<PromptCache>,
+    last_prompt_cache_record: Arc<Mutex<Option<PromptCacheRecord>>>,
 }
 
 impl AnthropicClient {
@@ -124,8 +124,8 @@ impl AnthropicClient {
             max_retries: DEFAULT_MAX_RETRIES,
             initial_backoff: DEFAULT_INITIAL_BACKOFF,
             max_backoff: DEFAULT_MAX_BACKOFF,
-            request_profile: AnthropicRequestProfile::default(),
-            session_tracer: None,
+            prompt_cache: None,
+            last_prompt_cache_record: Arc::new(Mutex::new(None)),
         }
     }
 
@@ -138,8 +138,8 @@ impl AnthropicClient {
             max_retries: DEFAULT_MAX_RETRIES,
             initial_backoff: DEFAULT_INITIAL_BACKOFF,
             max_backoff: DEFAULT_MAX_BACKOFF,
-            request_profile: AnthropicRequestProfile::default(),
-            session_tracer: None,
+            prompt_cache: None,
+            last_prompt_cache_record: Arc::new(Mutex::new(None)),
         }
     }
 
@@ -184,39 +184,6 @@ impl AnthropicClient {
         self
     }
 
-    #[must_use]
-    pub fn with_request_profile(mut self, request_profile: AnthropicRequestProfile) -> Self {
-        self.request_profile = request_profile;
-        self
-    }
-
-    #[must_use]
-    pub fn with_client_identity(mut self, client_identity: ClientIdentity) -> Self {
-        self.request_profile.client_identity = client_identity;
-        self
-    }
-
-    #[must_use]
-    pub fn with_beta(mut self, beta: impl Into<String>) -> Self {
-        let beta = beta.into();
-        if !self.request_profile.betas.contains(&beta) {
-            self.request_profile.betas.push(beta);
-        }
-        self
-    }
-
-    #[must_use]
-    pub fn with_extra_body_param(mut self, key: impl Into<String>, value: Value) -> Self {
-        self.request_profile.extra_body.insert(key.into(), value);
-        self
-    }
-
-    #[must_use]
-    pub fn with_session_tracer(mut self, session_tracer: SessionTracer) -> Self {
-        self.session_tracer = Some(session_tracer);
-        self
-    }
-
     #[must_use]
     pub fn with_retry_policy(
         mut self,
@@ -230,6 +197,30 @@ impl AnthropicClient {
         self
     }
 
+    #[must_use]
+    pub fn with_prompt_cache(mut self, prompt_cache: PromptCache) -> Self {
+        self.prompt_cache = Some(prompt_cache);
+        self
+    }
+
+    #[must_use]
+    pub fn prompt_cache(&self) -> Option<&PromptCache> {
+        self.prompt_cache.as_ref()
+    }
+
+    #[must_use]
+    pub fn prompt_cache_stats(&self) -> Option<PromptCacheStats> {
+        self.prompt_cache.as_ref().map(PromptCache::stats)
+    }
+
+    #[must_use]
+    pub fn take_last_prompt_cache_record(&self) -> Option<PromptCacheRecord> {
+        self.last_prompt_cache_record()
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner)
+            .take()
+    }
+
     #[must_use]
     pub fn auth_source(&self) -> &AuthSource {
         &self.auth
@@ -239,10 +230,19 @@ impl AnthropicClient {
         &self,
         request: &MessageRequest,
     ) -> Result<MessageResponse, ApiError> {
+        self.store_last_prompt_cache_record(None);
         let request = MessageRequest {
             stream: false,
             ..request.clone()
         };
+        if let Some(prompt_cache) = &self.prompt_cache {
+            if let Some(response) = prompt_cache.lookup_completion(&request) {
+                self.store_last_prompt_cache_record(Some(prompt_cache_record_from_stats(
+                    prompt_cache.stats(),
+                )));
+                return Ok(response);
+            }
+        }
         let response = self.send_with_retry(&request).await?;
         let request_id = request_id_from_headers(response.headers());
         let mut response = response
@@ -252,7 +252,10 @@ impl AnthropicClient {
         if response.request_id.is_none() {
             response.request_id = request_id;
         }
-        self.record_response_usage(&response);
+        if let Some(prompt_cache) = &self.prompt_cache {
+            let record = prompt_cache.record_response(&request, &response);
+            self.store_last_prompt_cache_record(Some(record));
+        }
         Ok(response)
     }
 
@@ -260,6 +263,7 @@ impl AnthropicClient {
         &self,
         request: &MessageRequest,
     ) -> Result<MessageStream, ApiError> {
+        self.store_last_prompt_cache_record(None);
         let response = self
             .send_with_retry(&request.clone().with_streaming())
             .await?;
@@ -269,9 +273,30 @@ impl AnthropicClient {
             parser: SseParser::new(),
             pending: VecDeque::new(),
             done: false,
+            cache_tracking: self
+                .prompt_cache
+                .as_ref()
+                .map(|prompt_cache| StreamCacheTracking {
+                    prompt_cache: prompt_cache.clone(),
+                    request: request.clone().with_streaming(),
+                    last_usage: None,
+                    finalized: false,
+                    last_record: self.last_prompt_cache_record.clone(),
+                }),
         })
     }
 
+    fn store_last_prompt_cache_record(&self, record: Option<PromptCacheRecord>) {
+        *self
+            .last_prompt_cache_record()
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner) = record;
+    }
+
+    fn last_prompt_cache_record(&self) -> &Arc<Mutex<Option<PromptCacheRecord>>> {
+        &self.last_prompt_cache_record
+    }
+
     pub async fn exchange_oauth_code(
         &self,
         config: &OAuthConfig,
@@ -321,30 +346,18 @@ impl AnthropicClient {
 
         loop {
             attempts += 1;
-            self.record_request_started(request, attempts);
             match self.send_raw_request(request).await {
                 Ok(response) => match expect_success(response).await {
-                    Ok(response) => {
-                        self.record_request_succeeded(request, attempts, &response);
-                        return Ok(response);
-                    }
+                    Ok(response) => return Ok(response),
                     Err(error) if error.is_retryable() && attempts <= self.max_retries + 1 => {
-                        self.record_request_failed(request, attempts, &error);
                         last_error = Some(error);
                     }
-                    Err(error) => {
-                        self.record_request_failed(request, attempts, &error);
-                        return Err(error);
-                    }
+                    Err(error) => return Err(error),
                 },
                 Err(error) if error.is_retryable() && attempts <= self.max_retries + 1 => {
-                    self.record_request_failed(request, attempts, &error);
                     last_error = Some(error);
                 }
-                Err(error) => {
-                    self.record_request_failed(request, attempts, &error);
-                    return Err(error);
-                }
+                Err(error) => return Err(error),
             }
 
             if attempts > self.max_retries {
@@ -364,213 +377,18 @@ impl AnthropicClient {
         &self,
         request: &MessageRequest,
     ) -> Result<reqwest::Response, ApiError> {
-        let request_url = format!("{}{}", self.base_url.trim_end_matches('/'), MESSAGES_PATH);
-        let mut request_builder = self
+        let request_url = format!("{}/v1/messages", self.base_url.trim_end_matches('/'));
+        let request_builder = self
             .http
             .post(&request_url)
+            .header("anthropic-version", ANTHROPIC_VERSION)
             .header("content-type", "application/json");
-        for (name, value) in self.request_profile.header_pairs() {
-            request_builder = request_builder.header(name, value);
-        }
         let mut request_builder = self.auth.apply(request_builder);
 
-        let request_body = self.request_profile.render_json_body(request)?;
-        request_builder = request_builder.json(&request_body);
+        request_builder = request_builder.json(request);
         request_builder.send().await.map_err(ApiError::from)
     }
 
-    fn record_request_started(&self, request: &MessageRequest, attempt: u32) {
-        if let Some(tracer) = &self.session_tracer {
-            tracer.record_http_request_started(
-                attempt,
-                "POST",
-                MESSAGES_PATH,
-                self.request_attributes(request),
-            );
-        }
-    }
-
-    fn record_request_succeeded(
-        &self,
-        request: &MessageRequest,
-        attempt: u32,
-        response: &reqwest::Response,
-    ) {
-        if let Some(tracer) = &self.session_tracer {
-            tracer.record_http_request_succeeded(
-                attempt,
-                "POST",
-                MESSAGES_PATH,
-                response.status().as_u16(),
-                request_id_from_headers(response.headers()),
-                self.request_attributes(request),
-            );
-        }
-    }
-
-    fn record_request_failed(&self, request: &MessageRequest, attempt: u32, error: &ApiError) {
-        if let Some(tracer) = &self.session_tracer {
-            tracer.record_http_request_failed(
-                attempt,
-                "POST",
-                MESSAGES_PATH,
-                error.to_string(),
-                error.is_retryable(),
-                self.error_attributes(request, error),
-            );
-        }
-    }
-
-    fn record_response_usage(&self, response: &MessageResponse) {
-        let Some(tracer) = &self.session_tracer else {
-            return;
-        };
-
-        let cost = response.usage.estimated_cost_usd(&response.model);
-        let pricing_source = if pricing_for_model(&response.model).is_some() {
-            "model-specific"
-        } else {
-            "default-sonnet"
-        };
-
-        let mut properties = Map::new();
-        properties.insert("model".to_string(), Value::String(response.model.clone()));
-        properties.insert(
-            "pricing_source".to_string(),
-            Value::String(pricing_source.to_string()),
-        );
-        properties.insert(
-            "input_tokens".to_string(),
-            Value::from(response.usage.input_tokens),
-        );
-        properties.insert(
-            "output_tokens".to_string(),
-            Value::from(response.usage.output_tokens),
-        );
-        properties.insert(
-            "cache_creation_input_tokens".to_string(),
-            Value::from(response.usage.cache_creation_input_tokens),
-        );
-        properties.insert(
-            "cache_read_input_tokens".to_string(),
-            Value::from(response.usage.cache_read_input_tokens),
-        );
-        properties.insert(
-            "total_tokens".to_string(),
-            Value::from(response.usage.total_tokens()),
-        );
-        properties.insert(
-            "estimated_cost_usd".to_string(),
-            Value::String(format_usd(cost.total_cost_usd())),
-        );
-        properties.insert(
-            "estimated_input_cost_usd".to_string(),
-            Value::String(format_usd(cost.input_cost_usd)),
-        );
-        properties.insert(
-            "estimated_output_cost_usd".to_string(),
-            Value::String(format_usd(cost.output_cost_usd)),
-        );
-        properties.insert(
-            "estimated_cache_creation_cost_usd".to_string(),
-            Value::String(format_usd(cost.cache_creation_cost_usd)),
-        );
-        properties.insert(
-            "estimated_cache_read_cost_usd".to_string(),
-            Value::String(format_usd(cost.cache_read_cost_usd)),
-        );
-        if let Some(request_id) = &response.request_id {
-            properties.insert("request_id".to_string(), Value::String(request_id.clone()));
-        }
-
-        tracer.record_analytics(AnalyticsEvent {
-            namespace: "api".to_string(),
-            action: "message_usage".to_string(),
-            properties,
-        });
-    }
-
-    fn request_attributes(&self, request: &MessageRequest) -> Map<String, Value> {
-        let mut attributes = Map::new();
-        attributes.insert("model".to_string(), Value::String(request.model.clone()));
-        attributes.insert("stream".to_string(), Value::Bool(request.stream));
-        attributes.insert("max_tokens".to_string(), Value::from(request.max_tokens));
-        attributes.insert(
-            "message_count".to_string(),
-            Value::from(u64::try_from(request.messages.len()).unwrap_or(u64::MAX)),
-        );
-        attributes.insert(
-            "tool_count".to_string(),
-            Value::from(
-                u64::try_from(request.tools.as_ref().map_or(0, Vec::len)).unwrap_or(u64::MAX),
-            ),
-        );
-        attributes.insert(
-            "beta_count".to_string(),
-            Value::from(u64::try_from(self.request_profile.betas.len()).unwrap_or(u64::MAX)),
-        );
-        if !self.request_profile.betas.is_empty() {
-            attributes.insert(
-                "betas".to_string(),
-                Value::Array(
-                    self.request_profile
-                        .betas
-                        .iter()
-                        .cloned()
-                        .map(Value::String)
-                        .collect(),
-                ),
-            );
-        }
-        if !self.request_profile.extra_body.is_empty() {
-            attributes.insert(
-                "extra_body_keys".to_string(),
-                Value::Array(
-                    self.request_profile
-                        .extra_body
-                        .keys()
-                        .cloned()
-                        .map(Value::String)
-                        .collect(),
-                ),
-            );
-        }
-        attributes
-    }
-
-    fn error_attributes(&self, request: &MessageRequest, error: &ApiError) -> Map<String, Value> {
-        let mut attributes = self.request_attributes(request);
-        match error {
-            ApiError::Api {
-                status,
-                error_type,
-                message,
-                ..
-            } => {
-                attributes.insert("status".to_string(), Value::from(status.as_u16()));
-                if let Some(error_type) = error_type {
-                    attributes.insert("error_type".to_string(), Value::String(error_type.clone()));
-                }
-                if let Some(message) = message {
-                    attributes.insert("api_message".to_string(), Value::String(message.clone()));
-                }
-            }
-            ApiError::Http(_) => {
-                attributes.insert("error_type".to_string(), Value::String("http".to_string()));
-            }
-            ApiError::Json(_) => {
-                attributes.insert("error_type".to_string(), Value::String("json".to_string()));
-            }
-            _ => {
-                attributes.insert(
-                    "error_type".to_string(),
-                    Value::String("client".to_string()),
-                );
-            }
-        }
-        attributes
-    }
-
     fn backoff_for_attempt(&self, attempt: u32) -> Result<Duration, ApiError> {
         let Some(multiplier) = 1_u32.checked_shl(attempt.saturating_sub(1)) else {
             return Err(ApiError::BackoffOverflow {
@@ -776,6 +594,7 @@ pub struct MessageStream {
     parser: SseParser,
     pending: VecDeque<StreamEvent>,
     done: bool,
+    cache_tracking: Option<StreamCacheTracking>,
 }
 
 impl MessageStream {
@@ -787,6 +606,9 @@ impl MessageStream {
     pub async fn next_event(&mut self) -> Result<Option<StreamEvent>, ApiError> {
         loop {
             if let Some(event) = self.pending.pop_front() {
+                if let Some(cache_tracking) = &mut self.cache_tracking {
+                    cache_tracking.observe(&event);
+                }
                 return Ok(Some(event));
             }
 
@@ -794,8 +616,14 @@ impl MessageStream {
                 let remaining = self.parser.finish()?;
                 self.pending.extend(remaining);
                 if let Some(event) = self.pending.pop_front() {
+                    if let Some(cache_tracking) = &mut self.cache_tracking {
+                        cache_tracking.observe(&event);
+                    }
                     return Ok(Some(event));
                 }
+                if let Some(cache_tracking) = &mut self.cache_tracking {
+                    cache_tracking.finalize();
+                }
                 return Ok(None);
             }
 
@@ -811,6 +639,53 @@ impl MessageStream {
     }
 }
 
+#[derive(Debug, Clone)]
+struct StreamCacheTracking {
+    prompt_cache: PromptCache,
+    request: MessageRequest,
+    last_usage: Option<Usage>,
+    finalized: bool,
+    last_record: Arc<Mutex<Option<PromptCacheRecord>>>,
+}
+
+impl StreamCacheTracking {
+    fn observe(&mut self, event: &StreamEvent) {
+        match event {
+            StreamEvent::MessageStart(event) => {
+                self.last_usage = Some(event.message.usage.clone());
+            }
+            StreamEvent::MessageDelta(event) => {
+                self.last_usage = Some(event.usage.clone());
+            }
+            StreamEvent::ContentBlockStart(_)
+            | StreamEvent::ContentBlockDelta(_)
+            | StreamEvent::ContentBlockStop(_)
+            | StreamEvent::MessageStop(_) => {}
+        }
+    }
+
+    fn finalize(&mut self) {
+        if self.finalized {
+            return;
+        }
+        if let Some(usage) = &self.last_usage {
+            let record = self.prompt_cache.record_usage(&self.request, usage);
+            *self
+                .last_record
+                .lock()
+                .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(record);
+        }
+        self.finalized = true;
+    }
+}
+
+fn prompt_cache_record_from_stats(stats: PromptCacheStats) -> PromptCacheRecord {
+    PromptCacheRecord {
+        cache_break: None,
+        stats,
+    }
+}
+
 async fn expect_success(response: reqwest::Response) -> Result<reqwest::Response, ApiError> {
     let status = response.status();
     if status.is_success() {
@@ -855,7 +730,7 @@ mod tests {
     use super::{ALT_REQUEST_ID_HEADER, REQUEST_ID_HEADER};
     use std::io::{Read, Write};
     use std::net::TcpListener;
-    use std::sync::{Mutex, OnceLock};
+    use std::sync::atomic::{AtomicU64, Ordering};
     use std::thread;
     use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
@@ -865,19 +740,15 @@ mod tests {
         now_unix_timestamp, oauth_token_is_expired, resolve_saved_oauth_token,
         resolve_startup_auth_source, AnthropicClient, AuthSource, OAuthTokenSet,
     };
+    use crate::test_env_lock;
     use crate::types::{ContentBlockDelta, MessageRequest};
 
-    fn env_lock() -> std::sync::MutexGuard<'static, ()> {
-        static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
-        LOCK.get_or_init(|| Mutex::new(()))
-            .lock()
-            .expect("env lock")
-    }
-
     fn temp_config_home() -> std::path::PathBuf {
+        static NEXT_ID: AtomicU64 = AtomicU64::new(0);
         std::env::temp_dir().join(format!(
-            "api-oauth-test-{}-{}",
+            "api-oauth-test-{}-{}-{}",
             std::process::id(),
+            NEXT_ID.fetch_add(1, Ordering::Relaxed),
             SystemTime::now()
                 .duration_since(UNIX_EPOCH)
                 .expect("time")
@@ -917,7 +788,7 @@ mod tests {
 
     #[test]
     fn read_api_key_requires_presence() {
-        let _guard = env_lock();
+        let _guard = test_env_lock();
         std::env::remove_var("ANTHROPIC_AUTH_TOKEN");
         std::env::remove_var("ANTHROPIC_API_KEY");
         std::env::remove_var("CLAUDE_CONFIG_HOME");
@@ -927,7 +798,7 @@ mod tests {
 
     #[test]
     fn read_api_key_requires_non_empty_value() {
-        let _guard = env_lock();
+        let _guard = test_env_lock();
         std::env::set_var("ANTHROPIC_AUTH_TOKEN", "");
         std::env::remove_var("ANTHROPIC_API_KEY");
         let error = super::read_api_key().expect_err("empty key should error");
@@ -937,7 +808,7 @@ mod tests {
 
     #[test]
     fn read_api_key_prefers_api_key_env() {
-        let _guard = env_lock();
+        let _guard = test_env_lock();
         std::env::set_var("ANTHROPIC_AUTH_TOKEN", "auth-token");
         std::env::set_var("ANTHROPIC_API_KEY", "legacy-key");
         assert_eq!(
@@ -950,7 +821,7 @@ mod tests {
 
     #[test]
     fn read_auth_token_reads_auth_token_env() {
-        let _guard = env_lock();
+        let _guard = test_env_lock();
         std::env::set_var("ANTHROPIC_AUTH_TOKEN", "auth-token");
         assert_eq!(super::read_auth_token().as_deref(), Some("auth-token"));
         std::env::remove_var("ANTHROPIC_AUTH_TOKEN");
@@ -970,7 +841,7 @@ mod tests {
 
     #[test]
     fn auth_source_from_env_combines_api_key_and_bearer_token() {
-        let _guard = env_lock();
+        let _guard = test_env_lock();
         std::env::set_var("ANTHROPIC_AUTH_TOKEN", "auth-token");
         std::env::set_var("ANTHROPIC_API_KEY", "legacy-key");
         let auth = AuthSource::from_env().expect("env auth");
@@ -982,7 +853,7 @@ mod tests {
 
     #[test]
     fn auth_source_from_saved_oauth_when_env_absent() {
-        let _guard = env_lock();
+        let _guard = test_env_lock();
         let config_home = temp_config_home();
         std::env::set_var("CLAUDE_CONFIG_HOME", &config_home);
         std::env::remove_var("ANTHROPIC_AUTH_TOKEN");
@@ -1021,7 +892,7 @@ mod tests {
 
     #[test]
     fn resolve_saved_oauth_token_refreshes_expired_credentials() {
-        let _guard = env_lock();
+        let _guard = test_env_lock();
         let config_home = temp_config_home();
         std::env::set_var("CLAUDE_CONFIG_HOME", &config_home);
         std::env::remove_var("ANTHROPIC_AUTH_TOKEN");
@@ -1053,7 +924,7 @@ mod tests {
 
     #[test]
     fn resolve_startup_auth_source_uses_saved_oauth_without_loading_config() {
-        let _guard = env_lock();
+        let _guard = test_env_lock();
         let config_home = temp_config_home();
         std::env::set_var("CLAUDE_CONFIG_HOME", &config_home);
         std::env::remove_var("ANTHROPIC_AUTH_TOKEN");
@@ -1077,7 +948,7 @@ mod tests {
 
     #[test]
     fn resolve_startup_auth_source_errors_when_refreshable_token_lacks_config() {
-        let _guard = env_lock();
+        let _guard = test_env_lock();
         let config_home = temp_config_home();
         std::env::set_var("CLAUDE_CONFIG_HOME", &config_home);
         std::env::remove_var("ANTHROPIC_AUTH_TOKEN");
@@ -1109,7 +980,7 @@ mod tests {
 
     #[test]
     fn resolve_saved_oauth_token_preserves_refresh_token_when_refresh_response_omits_it() {
-        let _guard = env_lock();
+        let _guard = test_env_lock();
         let config_home = temp_config_home();
         std::env::set_var("CLAUDE_CONFIG_HOME", &config_home);
         std::env::remove_var("ANTHROPIC_AUTH_TOKEN");

rust/crates/api/src/lib.rs

@@ -1,5 +1,6 @@
 mod client;
 mod error;
+mod prompt_cache;
 mod sse;
 mod types;
 
@@ -8,6 +9,10 @@ pub use client::{
     AnthropicClient, AuthSource, MessageStream, OAuthTokenSet,
 };
 pub use error::ApiError;
+pub use prompt_cache::{
+    CacheBreakEvent, PromptCache, PromptCacheConfig, PromptCachePaths, PromptCacheRecord,
+    PromptCacheStats,
+};
 pub use sse::{parse_frame, SseParser};
 pub use types::{
     ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockStartEvent, ContentBlockStopEvent,
@@ -16,8 +21,10 @@ pub use types::{
     ToolChoice, ToolDefinition, ToolResultContentBlock, Usage,
 };
 
-pub use telemetry::{
-    AnalyticsEvent, AnthropicRequestProfile, ClientIdentity, JsonlTelemetrySink,
-    MemoryTelemetrySink, SessionTraceRecord, SessionTracer, TelemetryEvent, TelemetrySink,
-    DEFAULT_ANTHROPIC_VERSION,
-};
+#[cfg(test)]
+pub(crate) fn test_env_lock() -> std::sync::MutexGuard<'static, ()> {
+    static LOCK: std::sync::OnceLock<std::sync::Mutex<()>> = std::sync::OnceLock::new();
+    LOCK.get_or_init(|| std::sync::Mutex::new(()))
+        .lock()
+        .unwrap_or_else(std::sync::PoisonError::into_inner)
+}

rust/crates/api/src/prompt_cache.rs

@@ -0,0 +1,727 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+use serde::{Deserialize, Serialize};
+
+use crate::types::{MessageRequest, MessageResponse, Usage};
+
+const DEFAULT_COMPLETION_TTL_SECS: u64 = 30;
+const DEFAULT_PROMPT_TTL_SECS: u64 = 5 * 60;
+const DEFAULT_BREAK_MIN_DROP: u32 = 2_000;
+const MAX_SANITIZED_LENGTH: usize = 80;
+const REQUEST_FINGERPRINT_VERSION: u32 = 1;
+const REQUEST_FINGERPRINT_PREFIX: &str = "v1";
+const FNV_OFFSET_BASIS: u64 = 0xcbf2_9ce4_8422_2325;
+const FNV_PRIME: u64 = 0x0000_0100_0000_01b3;
+
+#[derive(Debug, Clone)]
+pub struct PromptCacheConfig {
+    pub session_id: String,
+    pub completion_ttl: Duration,
+    pub prompt_ttl: Duration,
+    pub cache_break_min_drop: u32,
+}
+
+impl PromptCacheConfig {
+    #[must_use]
+    pub fn new(session_id: impl Into<String>) -> Self {
+        Self {
+            session_id: session_id.into(),
+            completion_ttl: Duration::from_secs(DEFAULT_COMPLETION_TTL_SECS),
+            prompt_ttl: Duration::from_secs(DEFAULT_PROMPT_TTL_SECS),
+            cache_break_min_drop: DEFAULT_BREAK_MIN_DROP,
+        }
+    }
+}
+
+impl Default for PromptCacheConfig {
+    fn default() -> Self {
+        Self::new("default")
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct PromptCachePaths {
+    pub root: PathBuf,
+    pub session_dir: PathBuf,
+    pub completion_dir: PathBuf,
+    pub session_state_path: PathBuf,
+    pub stats_path: PathBuf,
+}
+
+impl PromptCachePaths {
+    #[must_use]
+    pub fn for_session(session_id: &str) -> Self {
+        let root = base_cache_root();
+        let session_dir = root.join(sanitize_path_segment(session_id));
+        let completion_dir = session_dir.join("completions");
+        Self {
+            root,
+            session_state_path: session_dir.join("session-state.json"),
+            stats_path: session_dir.join("stats.json"),
+            session_dir,
+            completion_dir,
+        }
+    }
+
+    #[must_use]
+    pub fn completion_entry_path(&self, request_hash: &str) -> PathBuf {
+        self.completion_dir.join(format!("{request_hash}.json"))
+    }
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct PromptCacheStats {
+    pub tracked_requests: u64,
+    pub completion_cache_hits: u64,
+    pub completion_cache_misses: u64,
+    pub completion_cache_writes: u64,
+    pub expected_invalidations: u64,
+    pub unexpected_cache_breaks: u64,
+    pub total_cache_creation_input_tokens: u64,
+    pub total_cache_read_input_tokens: u64,
+    pub last_cache_creation_input_tokens: Option<u32>,
+    pub last_cache_read_input_tokens: Option<u32>,
+    pub last_request_hash: Option<String>,
+    pub last_completion_cache_key: Option<String>,
+    pub last_break_reason: Option<String>,
+    pub last_cache_source: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CacheBreakEvent {
+    pub unexpected: bool,
+    pub reason: String,
+    pub previous_cache_read_input_tokens: u32,
+    pub current_cache_read_input_tokens: u32,
+    pub token_drop: u32,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PromptCacheRecord {
+    pub cache_break: Option<CacheBreakEvent>,
+    pub stats: PromptCacheStats,
+}
+
+#[derive(Debug, Clone)]
+pub struct PromptCache {
+    inner: Arc<Mutex<PromptCacheInner>>,
+}
+
+impl PromptCache {
+    #[must_use]
+    pub fn new(session_id: impl Into<String>) -> Self {
+        Self::with_config(PromptCacheConfig::new(session_id))
+    }
+
+    #[must_use]
+    pub fn with_config(config: PromptCacheConfig) -> Self {
+        let paths = PromptCachePaths::for_session(&config.session_id);
+        let stats = read_json::<PromptCacheStats>(&paths.stats_path).unwrap_or_default();
+        let previous = read_json::<TrackedPromptState>(&paths.session_state_path);
+        Self {
+            inner: Arc::new(Mutex::new(PromptCacheInner {
+                config,
+                paths,
+                stats,
+                previous,
+            })),
+        }
+    }
+
+    #[must_use]
+    pub fn paths(&self) -> PromptCachePaths {
+        self.lock().paths.clone()
+    }
+
+    #[must_use]
+    pub fn stats(&self) -> PromptCacheStats {
+        self.lock().stats.clone()
+    }
+
+    #[must_use]
+    pub fn lookup_completion(&self, request: &MessageRequest) -> Option<MessageResponse> {
+        let request_hash = request_hash_hex(request);
+        let (paths, ttl) = {
+            let inner = self.lock();
+            (inner.paths.clone(), inner.config.completion_ttl)
+        };
+        let entry_path = paths.completion_entry_path(&request_hash);
+        let entry = read_json::<CompletionCacheEntry>(&entry_path);
+        let Some(entry) = entry else {
+            let mut inner = self.lock();
+            inner.stats.completion_cache_misses += 1;
+            inner.stats.last_completion_cache_key = Some(request_hash);
+            persist_state(&inner);
+            return None;
+        };
+
+        if entry.fingerprint_version != current_fingerprint_version() {
+            let mut inner = self.lock();
+            inner.stats.completion_cache_misses += 1;
+            inner.stats.last_completion_cache_key = Some(request_hash.clone());
+            let _ = fs::remove_file(entry_path);
+            persist_state(&inner);
+            return None;
+        }
+
+        let expired = now_unix_secs().saturating_sub(entry.cached_at_unix_secs) >= ttl.as_secs();
+        let mut inner = self.lock();
+        inner.stats.last_completion_cache_key = Some(request_hash.clone());
+        if expired {
+            inner.stats.completion_cache_misses += 1;
+            let _ = fs::remove_file(entry_path);
+            persist_state(&inner);
+            return None;
+        }
+
+        inner.stats.completion_cache_hits += 1;
+        apply_usage_to_stats(
+            &mut inner.stats,
+            &entry.response.usage,
+            &request_hash,
+            "completion-cache",
+        );
+        inner.previous = Some(TrackedPromptState::from_usage(
+            request,
+            &entry.response.usage,
+        ));
+        persist_state(&inner);
+        Some(entry.response)
+    }
+
+    #[must_use]
+    pub fn record_response(
+        &self,
+        request: &MessageRequest,
+        response: &MessageResponse,
+    ) -> PromptCacheRecord {
+        self.record_usage_internal(request, &response.usage, Some(response))
+    }
+
+    #[must_use]
+    pub fn record_usage(&self, request: &MessageRequest, usage: &Usage) -> PromptCacheRecord {
+        self.record_usage_internal(request, usage, None)
+    }
+
+    fn record_usage_internal(
+        &self,
+        request: &MessageRequest,
+        usage: &Usage,
+        response: Option<&MessageResponse>,
+    ) -> PromptCacheRecord {
+        let request_hash = request_hash_hex(request);
+        let mut inner = self.lock();
+        let previous = inner.previous.clone();
+        let current = TrackedPromptState::from_usage(request, usage);
+        let cache_break = detect_cache_break(&inner.config, previous.as_ref(), &current);
+
+        inner.stats.tracked_requests += 1;
+        apply_usage_to_stats(&mut inner.stats, usage, &request_hash, "api-response");
+        if let Some(event) = &cache_break {
+            if event.unexpected {
+                inner.stats.unexpected_cache_breaks += 1;
+            } else {
+                inner.stats.expected_invalidations += 1;
+            }
+            inner.stats.last_break_reason = Some(event.reason.clone());
+        }
+
+        inner.previous = Some(current);
+        if let Some(response) = response {
+            write_completion_entry(&inner.paths, &request_hash, response);
+            inner.stats.completion_cache_writes += 1;
+        }
+        persist_state(&inner);
+
+        PromptCacheRecord {
+            cache_break,
+            stats: inner.stats.clone(),
+        }
+    }
+
+    fn lock(&self) -> std::sync::MutexGuard<'_, PromptCacheInner> {
+        self.inner
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner)
+    }
+}
+
+#[derive(Debug)]
+struct PromptCacheInner {
+    config: PromptCacheConfig,
+    paths: PromptCachePaths,
+    stats: PromptCacheStats,
+    previous: Option<TrackedPromptState>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct CompletionCacheEntry {
+    cached_at_unix_secs: u64,
+    #[serde(default = "current_fingerprint_version")]
+    fingerprint_version: u32,
+    response: MessageResponse,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+struct TrackedPromptState {
+    observed_at_unix_secs: u64,
+    #[serde(default = "current_fingerprint_version")]
+    fingerprint_version: u32,
+    model_hash: u64,
+    system_hash: u64,
+    tools_hash: u64,
+    messages_hash: u64,
+    cache_read_input_tokens: u32,
+}
+
+impl TrackedPromptState {
+    fn from_usage(request: &MessageRequest, usage: &Usage) -> Self {
+        let hashes = RequestFingerprints::from_request(request);
+        Self {
+            observed_at_unix_secs: now_unix_secs(),
+            fingerprint_version: current_fingerprint_version(),
+            model_hash: hashes.model,
+            system_hash: hashes.system,
+            tools_hash: hashes.tools,
+            messages_hash: hashes.messages,
+            cache_read_input_tokens: usage.cache_read_input_tokens,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+struct RequestFingerprints {
+    model: u64,
+    system: u64,
+    tools: u64,
+    messages: u64,
+}
+
+impl RequestFingerprints {
+    fn from_request(request: &MessageRequest) -> Self {
+        Self {
+            model: hash_serializable(&request.model),
+            system: hash_serializable(&request.system),
+            tools: hash_serializable(&request.tools),
+            messages: hash_serializable(&request.messages),
+        }
+    }
+}
+
+fn detect_cache_break(
+    config: &PromptCacheConfig,
+    previous: Option<&TrackedPromptState>,
+    current: &TrackedPromptState,
+) -> Option<CacheBreakEvent> {
+    let previous = previous?;
+    if previous.fingerprint_version != current.fingerprint_version {
+        return Some(CacheBreakEvent {
+            unexpected: false,
+            reason: format!(
+                "fingerprint version changed (v{} -> v{})",
+                previous.fingerprint_version, current.fingerprint_version
+            ),
+            previous_cache_read_input_tokens: previous.cache_read_input_tokens,
+            current_cache_read_input_tokens: current.cache_read_input_tokens,
+            token_drop: previous
+                .cache_read_input_tokens
+                .saturating_sub(current.cache_read_input_tokens),
+        });
+    }
+    let token_drop = previous
+        .cache_read_input_tokens
+        .saturating_sub(current.cache_read_input_tokens);
+    if token_drop < config.cache_break_min_drop {
+        return None;
+    }
+
+    let mut reasons = Vec::new();
+    if previous.model_hash != current.model_hash {
+        reasons.push("model changed");
+    }
+    if previous.system_hash != current.system_hash {
+        reasons.push("system prompt changed");
+    }
+    if previous.tools_hash != current.tools_hash {
+        reasons.push("tool definitions changed");
+    }
+    if previous.messages_hash != current.messages_hash {
+        reasons.push("message payload changed");
+    }
+
+    let elapsed = current
+        .observed_at_unix_secs
+        .saturating_sub(previous.observed_at_unix_secs);
+
+    let (unexpected, reason) = if reasons.is_empty() {
+        if elapsed > config.prompt_ttl.as_secs() {
+            (
+                false,
+                format!("possible prompt cache TTL expiry after {elapsed}s"),
+            )
+        } else {
+            (
+                true,
+                "cache read tokens dropped while prompt fingerprint remained stable".to_string(),
+            )
+        }
+    } else {
+        (false, reasons.join(", "))
+    };
+
+    Some(CacheBreakEvent {
+        unexpected,
+        reason,
+        previous_cache_read_input_tokens: previous.cache_read_input_tokens,
+        current_cache_read_input_tokens: current.cache_read_input_tokens,
+        token_drop,
+    })
+}
+
+fn apply_usage_to_stats(
+    stats: &mut PromptCacheStats,
+    usage: &Usage,
+    request_hash: &str,
+    source: &str,
+) {
+    stats.total_cache_creation_input_tokens += u64::from(usage.cache_creation_input_tokens);
+    stats.total_cache_read_input_tokens += u64::from(usage.cache_read_input_tokens);
+    stats.last_cache_creation_input_tokens = Some(usage.cache_creation_input_tokens);
+    stats.last_cache_read_input_tokens = Some(usage.cache_read_input_tokens);
+    stats.last_request_hash = Some(request_hash.to_string());
+    stats.last_cache_source = Some(source.to_string());
+}
+
+fn persist_state(inner: &PromptCacheInner) {
+    let _ = ensure_cache_dirs(&inner.paths);
+    let _ = write_json(&inner.paths.stats_path, &inner.stats);
+    if let Some(previous) = &inner.previous {
+        let _ = write_json(&inner.paths.session_state_path, previous);
+    }
+}
+
+fn write_completion_entry(
+    paths: &PromptCachePaths,
+    request_hash: &str,
+    response: &MessageResponse,
+) {
+    let _ = ensure_cache_dirs(paths);
+    let entry = CompletionCacheEntry {
+        cached_at_unix_secs: now_unix_secs(),
+        fingerprint_version: current_fingerprint_version(),
+        response: response.clone(),
+    };
+    let _ = write_json(&paths.completion_entry_path(request_hash), &entry);
+}
+
+fn ensure_cache_dirs(paths: &PromptCachePaths) -> std::io::Result<()> {
+    fs::create_dir_all(&paths.completion_dir)
+}
+
+fn write_json<T: Serialize>(path: &Path, value: &T) -> std::io::Result<()> {
+    let json = serde_json::to_vec_pretty(value)
+        .map_err(|error| std::io::Error::new(std::io::ErrorKind::InvalidData, error))?;
+    fs::write(path, json)
+}
+
+fn read_json<T: for<'de> Deserialize<'de>>(path: &Path) -> Option<T> {
+    let bytes = fs::read(path).ok()?;
+    serde_json::from_slice(&bytes).ok()
+}
+
+fn request_hash_hex(request: &MessageRequest) -> String {
+    format!(
+        "{REQUEST_FINGERPRINT_PREFIX}-{:016x}",
+        hash_serializable(request)
+    )
+}
+
+fn hash_serializable<T: Serialize>(value: &T) -> u64 {
+    let json = serde_json::to_vec(value).unwrap_or_default();
+    stable_hash_bytes(&json)
+}
+
+fn sanitize_path_segment(value: &str) -> String {
+    let sanitized: String = value
+        .chars()
+        .map(|ch| if ch.is_ascii_alphanumeric() { ch } else { '-' })
+        .collect();
+    if sanitized.len() <= MAX_SANITIZED_LENGTH {
+        return sanitized;
+    }
+    let suffix = format!("-{:x}", hash_string(value));
+    format!(
+        "{}{}",
+        &sanitized[..MAX_SANITIZED_LENGTH.saturating_sub(suffix.len())],
+        suffix
+    )
+}
+
+fn hash_string(value: &str) -> u64 {
+    stable_hash_bytes(value.as_bytes())
+}
+
+fn base_cache_root() -> PathBuf {
+    if let Some(config_home) = std::env::var_os("CLAUDE_CONFIG_HOME") {
+        return PathBuf::from(config_home)
+            .join("cache")
+            .join("prompt-cache");
+    }
+    if let Some(home) = std::env::var_os("HOME") {
+        return PathBuf::from(home)
+            .join(".claude")
+            .join("cache")
+            .join("prompt-cache");
+    }
+    std::env::temp_dir().join("claude-prompt-cache")
+}
+
+fn now_unix_secs() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map_or(0, |duration| duration.as_secs())
+}
+
+const fn current_fingerprint_version() -> u32 {
+    REQUEST_FINGERPRINT_VERSION
+}
+
+fn stable_hash_bytes(bytes: &[u8]) -> u64 {
+    let mut hash = FNV_OFFSET_BASIS;
+    for byte in bytes {
+        hash ^= u64::from(*byte);
+        hash = hash.wrapping_mul(FNV_PRIME);
+    }
+    hash
+}
+
+#[cfg(test)]
+mod tests {
+    use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+    use super::{
+        detect_cache_break, read_json, request_hash_hex, sanitize_path_segment, PromptCache,
+        PromptCacheConfig, PromptCachePaths, TrackedPromptState, REQUEST_FINGERPRINT_PREFIX,
+    };
+    use crate::test_env_lock;
+    use crate::types::{InputMessage, MessageRequest, MessageResponse, OutputContentBlock, Usage};
+
+    #[test]
+    fn path_builder_sanitizes_session_identifier() {
+        let paths = PromptCachePaths::for_session("session:/with spaces");
+        let session_dir = paths
+            .session_dir
+            .file_name()
+            .and_then(|value| value.to_str())
+            .expect("session dir name");
+        assert_eq!(session_dir, "session--with-spaces");
+        assert!(paths.completion_dir.ends_with("completions"));
+        assert!(paths.stats_path.ends_with("stats.json"));
+        assert!(paths.session_state_path.ends_with("session-state.json"));
+    }
+
+    #[test]
+    fn request_fingerprint_drives_unexpected_break_detection() {
+        let request = sample_request("same");
+        let previous = TrackedPromptState::from_usage(
+            &request,
+            &Usage {
+                input_tokens: 0,
+                cache_creation_input_tokens: 0,
+                cache_read_input_tokens: 6_000,
+                output_tokens: 0,
+            },
+        );
+        let current = TrackedPromptState::from_usage(
+            &request,
+            &Usage {
+                input_tokens: 0,
+                cache_creation_input_tokens: 0,
+                cache_read_input_tokens: 1_000,
+                output_tokens: 0,
+            },
+        );
+        let event = detect_cache_break(&PromptCacheConfig::default(), Some(&previous), &current)
+            .expect("break should be detected");
+        assert!(event.unexpected);
+        assert!(event.reason.contains("stable"));
+    }
+
+    #[test]
+    fn changed_prompt_marks_break_as_expected() {
+        let previous_request = sample_request("first");
+        let current_request = sample_request("second");
+        let previous = TrackedPromptState::from_usage(
+            &previous_request,
+            &Usage {
+                input_tokens: 0,
+                cache_creation_input_tokens: 0,
+                cache_read_input_tokens: 6_000,
+                output_tokens: 0,
+            },
+        );
+        let current = TrackedPromptState::from_usage(
+            &current_request,
+            &Usage {
+                input_tokens: 0,
+                cache_creation_input_tokens: 0,
+                cache_read_input_tokens: 1_000,
+                output_tokens: 0,
+            },
+        );
+        let event = detect_cache_break(&PromptCacheConfig::default(), Some(&previous), &current)
+            .expect("break should be detected");
+        assert!(!event.unexpected);
+        assert!(event.reason.contains("message payload changed"));
+    }
+
+    #[test]
+    fn completion_cache_round_trip_persists_recent_response() {
+        let _guard = test_env_lock();
+        let temp_root = std::env::temp_dir().join(format!(
+            "prompt-cache-test-{}-{}",
+            std::process::id(),
+            SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .expect("time")
+                .as_nanos()
+        ));
+        std::env::set_var("CLAUDE_CONFIG_HOME", &temp_root);
+        let cache = PromptCache::new("unit-test-session");
+        let request = sample_request("cache me");
+        let response = sample_response(42, 12, "cached");
+
+        assert!(cache.lookup_completion(&request).is_none());
+        let record = cache.record_response(&request, &response);
+        assert!(record.cache_break.is_none());
+
+        let cached = cache
+            .lookup_completion(&request)
+            .expect("cached response should load");
+        assert_eq!(cached.content, response.content);
+
+        let stats = cache.stats();
+        assert_eq!(stats.completion_cache_hits, 1);
+        assert_eq!(stats.completion_cache_misses, 1);
+        assert_eq!(stats.completion_cache_writes, 1);
+
+        let persisted = read_json::<super::PromptCacheStats>(&cache.paths().stats_path)
+            .expect("stats should persist");
+        assert_eq!(persisted.completion_cache_hits, 1);
+
+        std::fs::remove_dir_all(temp_root).expect("cleanup temp root");
+        std::env::remove_var("CLAUDE_CONFIG_HOME");
+    }
+
+    #[test]
+    fn distinct_requests_do_not_collide_in_completion_cache() {
+        let _guard = test_env_lock();
+        let temp_root = std::env::temp_dir().join(format!(
+            "prompt-cache-distinct-{}-{}",
+            std::process::id(),
+            SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .expect("time")
+                .as_nanos()
+        ));
+        std::env::set_var("CLAUDE_CONFIG_HOME", &temp_root);
+        let cache = PromptCache::new("distinct-request-session");
+        let first_request = sample_request("first");
+        let second_request = sample_request("second");
+
+        let response = sample_response(42, 12, "cached");
+        let _ = cache.record_response(&first_request, &response);
+
+        assert!(cache.lookup_completion(&second_request).is_none());
+
+        std::fs::remove_dir_all(temp_root).expect("cleanup temp root");
+        std::env::remove_var("CLAUDE_CONFIG_HOME");
+    }
+
+    #[test]
+    fn expired_completion_entries_are_not_reused() {
+        let _guard = test_env_lock();
+        let temp_root = std::env::temp_dir().join(format!(
+            "prompt-cache-expired-{}-{}",
+            std::process::id(),
+            SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .expect("time")
+                .as_nanos()
+        ));
+        std::env::set_var("CLAUDE_CONFIG_HOME", &temp_root);
+        let cache = PromptCache::with_config(PromptCacheConfig {
+            session_id: "expired-session".to_string(),
+            completion_ttl: Duration::ZERO,
+            ..PromptCacheConfig::default()
+        });
+        let request = sample_request("expire me");
+        let response = sample_response(7, 3, "stale");
+
+        let _ = cache.record_response(&request, &response);
+
+        assert!(cache.lookup_completion(&request).is_none());
+        let stats = cache.stats();
+        assert_eq!(stats.completion_cache_hits, 0);
+        assert_eq!(stats.completion_cache_misses, 1);
+
+        std::fs::remove_dir_all(temp_root).expect("cleanup temp root");
+        std::env::remove_var("CLAUDE_CONFIG_HOME");
+    }
+
+    #[test]
+    fn sanitize_path_caps_long_values() {
+        let long_value = "x".repeat(200);
+        let sanitized = sanitize_path_segment(&long_value);
+        assert!(sanitized.len() <= 80);
+    }
+
+    #[test]
+    fn request_hashes_are_versioned_and_stable() {
+        let request = sample_request("stable");
+        let first = request_hash_hex(&request);
+        let second = request_hash_hex(&request);
+        assert_eq!(first, second);
+        assert!(first.starts_with(REQUEST_FINGERPRINT_PREFIX));
+    }
+
+    fn sample_request(text: &str) -> MessageRequest {
+        MessageRequest {
+            model: "claude-3-7-sonnet-latest".to_string(),
+            max_tokens: 64,
+            messages: vec![InputMessage::user_text(text)],
+            system: Some("system".to_string()),
+            tools: None,
+            tool_choice: None,
+            stream: false,
+        }
+    }
+
+    fn sample_response(
+        cache_read_input_tokens: u32,
+        output_tokens: u32,
+        text: &str,
+    ) -> MessageResponse {
+        MessageResponse {
+            id: "msg_test".to_string(),
+            kind: "message".to_string(),
+            role: "assistant".to_string(),
+            content: vec![OutputContentBlock::Text {
+                text: text.to_string(),
+            }],
+            model: "claude-3-7-sonnet-latest".to_string(),
+            stop_reason: Some("end_turn".to_string()),
+            stop_sequence: None,
+            usage: Usage {
+                input_tokens: 10,
+                cache_creation_input_tokens: 5,
+                cache_read_input_tokens,
+                output_tokens,
+            },
+            request_id: Some("req_test".to_string()),
+        }
+    }
+}

rust/crates/api/src/types.rs

@@ -1,4 +1,3 @@
-use runtime::{pricing_for_model, TokenUsage, UsageCostEstimate};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
@@ -151,29 +150,7 @@ pub struct Usage {
 impl Usage {
     #[must_use]
     pub const fn total_tokens(&self) -> u32 {
-        self.input_tokens
-            + self.output_tokens
-            + self.cache_creation_input_tokens
-            + self.cache_read_input_tokens
-    }
-
-    #[must_use]
-    pub const fn token_usage(&self) -> TokenUsage {
-        TokenUsage {
-            input_tokens: self.input_tokens,
-            output_tokens: self.output_tokens,
-            cache_creation_input_tokens: self.cache_creation_input_tokens,
-            cache_read_input_tokens: self.cache_read_input_tokens,
-        }
-    }
-
-    #[must_use]
-    pub fn estimated_cost_usd(&self, model: &str) -> UsageCostEstimate {
-        let usage = self.token_usage();
-        pricing_for_model(model).map_or_else(
-            || usage.estimate_cost_usd(),
-            |pricing| usage.estimate_cost_usd_with_pricing(pricing),
-        )
+        self.input_tokens + self.output_tokens
     }
 }
 
@@ -233,47 +210,3 @@ pub enum StreamEvent {
     ContentBlockStop(ContentBlockStopEvent),
     MessageStop(MessageStopEvent),
 }
-
-#[cfg(test)]
-mod tests {
-    use runtime::format_usd;
-
-    use super::{MessageResponse, Usage};
-
-    #[test]
-    fn usage_total_tokens_includes_cache_tokens() {
-        let usage = Usage {
-            input_tokens: 10,
-            cache_creation_input_tokens: 2,
-            cache_read_input_tokens: 3,
-            output_tokens: 4,
-        };
-
-        assert_eq!(usage.total_tokens(), 19);
-        assert_eq!(usage.token_usage().total_tokens(), 19);
-    }
-
-    #[test]
-    fn message_response_estimates_cost_from_model_usage() {
-        let response = MessageResponse {
-            id: "msg_cost".to_string(),
-            kind: "message".to_string(),
-            role: "assistant".to_string(),
-            content: Vec::new(),
-            model: "claude-sonnet-4-20250514".to_string(),
-            stop_reason: Some("end_turn".to_string()),
-            stop_sequence: None,
-            usage: Usage {
-                input_tokens: 1_000_000,
-                cache_creation_input_tokens: 100_000,
-                cache_read_input_tokens: 200_000,
-                output_tokens: 500_000,
-            },
-            request_id: None,
-        };
-
-        let cost = response.usage.estimated_cost_usd(&response.model);
-        assert_eq!(format_usd(cost.total_cost_usd()), "$54.6750");
-        assert_eq!(response.total_tokens(), 1_800_000);
-    }
-}

rust/crates/api/tests/client_integration.rs

@@ -1,18 +1,25 @@
 use std::collections::HashMap;
 use std::sync::Arc;
+use std::sync::{Mutex as StdMutex, OnceLock};
 use std::time::Duration;
 
 use api::{
     AnthropicClient, ApiError, ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockStartEvent,
     InputContentBlock, InputMessage, MessageDeltaEvent, MessageRequest, OutputContentBlock,
-    StreamEvent, ToolChoice, ToolDefinition,
+    PromptCache, StreamEvent, ToolChoice, ToolDefinition,
 };
 use serde_json::json;
-use telemetry::{ClientIdentity, MemoryTelemetrySink, SessionTracer, TelemetryEvent};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpListener;
 use tokio::sync::Mutex;
 
+fn env_lock() -> std::sync::MutexGuard<'static, ()> {
+    static LOCK: OnceLock<StdMutex<()>> = OnceLock::new();
+    LOCK.get_or_init(|| StdMutex::new(()))
+        .lock()
+        .unwrap_or_else(std::sync::PoisonError::into_inner)
+}
+
 #[tokio::test]
 async fn send_message_posts_json_and_parses_response() {
     let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
@@ -46,6 +53,8 @@ async fn send_message_posts_json_and_parses_response() {
     assert_eq!(response.id, "msg_test");
     assert_eq!(response.total_tokens(), 16);
     assert_eq!(response.request_id.as_deref(), Some("req_body_123"));
+    assert_eq!(response.usage.cache_creation_input_tokens, 0);
+    assert_eq!(response.usage.cache_read_input_tokens, 0);
     assert_eq!(
         response.content,
         vec![OutputContentBlock::Text {
@@ -65,18 +74,6 @@ async fn send_message_posts_json_and_parses_response() {
         request.headers.get("authorization").map(String::as_str),
         Some("Bearer proxy-token")
     );
-    assert_eq!(
-        request.headers.get("anthropic-version").map(String::as_str),
-        Some("2023-06-01")
-    );
-    assert_eq!(
-        request.headers.get("user-agent").map(String::as_str),
-        Some("claude-code/0.1.0")
-    );
-    assert_eq!(
-        request.headers.get("anthropic-beta").map(String::as_str),
-        Some("claude-code-20250219,prompt-caching-scope-2026-01-05")
-    );
     let body: serde_json::Value =
         serde_json::from_str(&request.body).expect("request body should be json");
     assert_eq!(
@@ -86,123 +83,58 @@ async fn send_message_posts_json_and_parses_response() {
     assert!(body.get("stream").is_none());
     assert_eq!(body["tools"][0]["name"], json!("get_weather"));
     assert_eq!(body["tool_choice"]["type"], json!("auto"));
-    assert_eq!(
-        body["betas"],
-        json!(["claude-code-20250219", "prompt-caching-scope-2026-01-05"])
-    );
 }
 
 #[tokio::test]
-async fn send_message_applies_request_profile_and_records_telemetry() {
+async fn send_message_parses_prompt_cache_token_usage_from_response() {
     let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
+    let body = concat!(
+        "{",
+        "\"id\":\"msg_cache_tokens\",",
+        "\"type\":\"message\",",
+        "\"role\":\"assistant\",",
+        "\"content\":[{\"type\":\"text\",\"text\":\"Cache tokens\"}],",
+        "\"model\":\"claude-3-7-sonnet-latest\",",
+        "\"stop_reason\":\"end_turn\",",
+        "\"stop_sequence\":null,",
+        "\"usage\":{\"input_tokens\":12,\"cache_creation_input_tokens\":321,\"cache_read_input_tokens\":654,\"output_tokens\":4}",
+        "}"
+    );
     let server = spawn_server(
-        state.clone(),
-        vec![http_response_with_headers(
-            "200 OK",
-            "application/json",
-            concat!(
-                "{",
-                "\"id\":\"msg_profile\",",
-                "\"type\":\"message\",",
-                "\"role\":\"assistant\",",
-                "\"content\":[{\"type\":\"text\",\"text\":\"ok\"}],",
-                "\"model\":\"claude-3-7-sonnet-latest\",",
-                "\"stop_reason\":\"end_turn\",",
-                "\"stop_sequence\":null,",
-                "\"usage\":{\"input_tokens\":1,\"cache_creation_input_tokens\":2,\"cache_read_input_tokens\":3,\"output_tokens\":1}",
-                "}"
-            ),
-            &[("request-id", "req_profile_123")],
-        )],
+        state,
+        vec![http_response("200 OK", "application/json", body)],
     )
     .await;
-    let sink = Arc::new(MemoryTelemetrySink::default());
-
-    let client = AnthropicClient::new("test-key")
-        .with_base_url(server.base_url())
-        .with_client_identity(ClientIdentity::new("claude-code", "9.9.9").with_runtime("rust-cli"))
-        .with_beta("tools-2026-04-01")
-        .with_extra_body_param("metadata", json!({"source": "clawd-code"}))
-        .with_session_tracer(SessionTracer::new("session-telemetry", sink.clone()));
 
+    let client = AnthropicClient::new("test-key").with_base_url(server.base_url());
     let response = client
         .send_message(&sample_request(false))
         .await
         .expect("request should succeed");
 
-    assert_eq!(response.request_id.as_deref(), Some("req_profile_123"));
-
-    let captured = state.lock().await;
-    let request = captured.first().expect("server should capture request");
-    assert_eq!(
-        request.headers.get("anthropic-beta").map(String::as_str),
-        Some("claude-code-20250219,prompt-caching-scope-2026-01-05,tools-2026-04-01")
-    );
-    assert_eq!(
-        request.headers.get("user-agent").map(String::as_str),
-        Some("claude-code/9.9.9")
-    );
-    let body: serde_json::Value =
-        serde_json::from_str(&request.body).expect("request body should be json");
-    assert_eq!(body["metadata"]["source"], json!("clawd-code"));
-    assert_eq!(
-        body["betas"],
-        json!([
-            "claude-code-20250219",
-            "prompt-caching-scope-2026-01-05",
-            "tools-2026-04-01"
-        ])
-    );
-
-    let events = sink.events();
-    assert_eq!(events.len(), 6);
-    assert!(matches!(
-        &events[0],
-        TelemetryEvent::HttpRequestStarted {
-            session_id,
-            attempt: 1,
-            method,
-            path,
-            ..
-        } if session_id == "session-telemetry" && method == "POST" && path == "/v1/messages"
-    ));
-    assert!(matches!(
-        &events[1],
-        TelemetryEvent::SessionTrace(trace) if trace.name == "http_request_started"
-    ));
-    assert!(matches!(
-        &events[2],
-        TelemetryEvent::HttpRequestSucceeded {
-            request_id,
-            status: 200,
-            ..
-        } if request_id.as_deref() == Some("req_profile_123")
-    ));
-    assert!(matches!(
-        &events[3],
-        TelemetryEvent::SessionTrace(trace) if trace.name == "http_request_succeeded"
-    ));
-    assert!(matches!(
-        &events[4],
-        TelemetryEvent::Analytics(event)
-            if event.namespace == "api"
-                && event.action == "message_usage"
-                && event.properties.get("request_id") == Some(&json!("req_profile_123"))
-                && event.properties.get("total_tokens") == Some(&json!(7))
-                && event.properties.get("estimated_cost_usd") == Some(&json!("$0.0001"))
-    ));
-    assert!(matches!(
-        &events[5],
-        TelemetryEvent::SessionTrace(trace) if trace.name == "analytics"
-    ));
+    assert_eq!(response.usage.input_tokens, 12);
+    assert_eq!(response.usage.cache_creation_input_tokens, 321);
+    assert_eq!(response.usage.cache_read_input_tokens, 654);
+    assert_eq!(response.usage.output_tokens, 4);
 }
 
 #[tokio::test]
+#[allow(clippy::await_holding_lock)]
 async fn stream_message_parses_sse_events_with_tool_use() {
+    let _guard = env_lock();
+    let temp_root = std::env::temp_dir().join(format!(
+        "api-stream-cache-{}-{}",
+        std::process::id(),
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .expect("time")
+            .as_nanos()
+    ));
+    std::env::set_var("CLAUDE_CONFIG_HOME", &temp_root);
     let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
     let sse = concat!(
         "event: message_start\n",
-        "data: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_stream\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"claude-3-7-sonnet-latest\",\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":8,\"output_tokens\":0}}}\n\n",
+        "data: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_stream\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"claude-3-7-sonnet-latest\",\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":8,\"cache_creation_input_tokens\":13,\"cache_read_input_tokens\":21,\"output_tokens\":0}}}\n\n",
         "event: content_block_start\n",
         "data: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"tool_use\",\"id\":\"toolu_123\",\"name\":\"get_weather\",\"input\":{}}}\n\n",
         "event: content_block_delta\n",
@@ -210,7 +142,7 @@ async fn stream_message_parses_sse_events_with_tool_use() {
         "event: content_block_stop\n",
         "data: {\"type\":\"content_block_stop\",\"index\":0}\n\n",
         "event: message_delta\n",
-        "data: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"tool_use\",\"stop_sequence\":null},\"usage\":{\"input_tokens\":8,\"output_tokens\":1}}\n\n",
+        "data: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"tool_use\",\"stop_sequence\":null},\"usage\":{\"input_tokens\":8,\"cache_creation_input_tokens\":34,\"cache_read_input_tokens\":55,\"output_tokens\":1}}\n\n",
         "event: message_stop\n",
         "data: {\"type\":\"message_stop\"}\n\n",
         "data: [DONE]\n\n"
@@ -228,7 +160,8 @@ async fn stream_message_parses_sse_events_with_tool_use() {
 
     let client = AnthropicClient::new("test-key")
         .with_auth_token(Some("proxy-token".to_string()))
-        .with_base_url(server.base_url());
+        .with_base_url(server.base_url())
+        .with_prompt_cache(PromptCache::new("stream-session"));
     let mut stream = client
         .stream_message(&sample_request(false))
         .await
@@ -282,6 +215,20 @@ async fn stream_message_parses_sse_events_with_tool_use() {
     let captured = state.lock().await;
     let request = captured.first().expect("server should capture request");
     assert!(request.body.contains("\"stream\":true"));
+
+    let cache_stats = client
+        .prompt_cache_stats()
+        .expect("prompt cache stats should exist");
+    assert_eq!(cache_stats.tracked_requests, 1);
+    assert_eq!(cache_stats.last_cache_creation_input_tokens, Some(34));
+    assert_eq!(cache_stats.last_cache_read_input_tokens, Some(55));
+    assert_eq!(
+        cache_stats.last_cache_source.as_deref(),
+        Some("api-response")
+    );
+
+    std::fs::remove_dir_all(temp_root).expect("cleanup temp root");
+    std::env::remove_var("CLAUDE_CONFIG_HOME");
 }
 
 #[tokio::test]
@@ -365,6 +312,121 @@ async fn surfaces_retry_exhaustion_for_persistent_retryable_errors() {
     }
 }
 
+#[tokio::test]
+#[allow(clippy::await_holding_lock)]
+async fn send_message_reuses_recent_completion_cache_entries() {
+    let _guard = env_lock();
+    let temp_root = std::env::temp_dir().join(format!(
+        "api-prompt-cache-{}-{}",
+        std::process::id(),
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .expect("time")
+            .as_nanos()
+    ));
+    std::env::set_var("CLAUDE_CONFIG_HOME", &temp_root);
+
+    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
+    let server = spawn_server(
+        state.clone(),
+        vec![http_response(
+            "200 OK",
+            "application/json",
+            "{\"id\":\"msg_cached\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"Cached once\"}],\"model\":\"claude-3-7-sonnet-latest\",\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":5,\"cache_read_input_tokens\":4000,\"output_tokens\":2}}",
+        )],
+    )
+    .await;
+
+    let client = AnthropicClient::new("test-key")
+        .with_base_url(server.base_url())
+        .with_prompt_cache(PromptCache::new("integration-session"));
+
+    let first = client
+        .send_message(&sample_request(false))
+        .await
+        .expect("first request should succeed");
+    let second = client
+        .send_message(&sample_request(false))
+        .await
+        .expect("second request should reuse cache");
+
+    assert_eq!(first.content, second.content);
+    assert_eq!(state.lock().await.len(), 1);
+
+    let cache_stats = client
+        .prompt_cache_stats()
+        .expect("prompt cache stats should exist");
+    assert_eq!(cache_stats.completion_cache_hits, 1);
+    assert_eq!(cache_stats.completion_cache_misses, 1);
+    assert_eq!(cache_stats.completion_cache_writes, 1);
+
+    std::fs::remove_dir_all(temp_root).expect("cleanup temp root");
+    std::env::remove_var("CLAUDE_CONFIG_HOME");
+}
+
+#[tokio::test]
+#[allow(clippy::await_holding_lock)]
+async fn send_message_tracks_unexpected_prompt_cache_breaks() {
+    let _guard = env_lock();
+    let temp_root = std::env::temp_dir().join(format!(
+        "api-prompt-break-{}-{}",
+        std::process::id(),
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .expect("time")
+            .as_nanos()
+    ));
+    std::env::set_var("CLAUDE_CONFIG_HOME", &temp_root);
+
+    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
+    let server = spawn_server(
+        state,
+        vec![
+            http_response(
+                "200 OK",
+                "application/json",
+                "{\"id\":\"msg_one\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"One\"}],\"model\":\"claude-3-7-sonnet-latest\",\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":5,\"cache_read_input_tokens\":6000,\"output_tokens\":2}}",
+            ),
+            http_response(
+                "200 OK",
+                "application/json",
+                "{\"id\":\"msg_two\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"Two\"}],\"model\":\"claude-3-7-sonnet-latest\",\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":3,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":1000,\"output_tokens\":2}}",
+            ),
+        ],
+    )
+    .await;
+
+    let request = sample_request(false);
+    let client = AnthropicClient::new("test-key")
+        .with_base_url(server.base_url())
+        .with_prompt_cache(PromptCache::with_config(api::PromptCacheConfig {
+            session_id: "break-session".to_string(),
+            completion_ttl: Duration::from_secs(0),
+            ..api::PromptCacheConfig::default()
+        }));
+
+    client
+        .send_message(&request)
+        .await
+        .expect("first response should succeed");
+    client
+        .send_message(&request)
+        .await
+        .expect("second response should succeed");
+
+    let cache_stats = client
+        .prompt_cache_stats()
+        .expect("prompt cache stats should exist");
+    assert_eq!(cache_stats.unexpected_cache_breaks, 1);
+    assert_eq!(
+        cache_stats.last_break_reason.as_deref(),
+        Some("cache read tokens dropped while prompt fingerprint remained stable")
+    );
+
+    std::fs::remove_dir_all(temp_root).expect("cleanup temp root");
+    std::env::remove_var("CLAUDE_CONFIG_HOME");
+}
+
 #[tokio::test]
 #[ignore = "requires ANTHROPIC_API_KEY and network access"]
 async fn live_stream_smoke_test() {

rust/crates/runtime/Cargo.toml

@@ -11,7 +11,6 @@ glob = "0.3"
 regex = "1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-telemetry = { path = "../telemetry" }
 tokio = { version = "1", features = ["io-util", "macros", "process", "rt", "rt-multi-thread", "time"] }
 walkdir = "2"
 

rust/crates/runtime/src/conversation.rs

@@ -1,9 +1,6 @@
 use std::collections::BTreeMap;
 use std::fmt::{Display, Formatter};
 
-use serde_json::{Map, Value};
-use telemetry::SessionTracer;
-
 use crate::compact::{
     compact_session, estimate_session_tokens, CompactionConfig, CompactionResult,
 };
@@ -28,9 +25,19 @@ pub enum AssistantEvent {
         input: String,
     },
     Usage(TokenUsage),
+    PromptCache(PromptCacheEvent),
     MessageStop,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PromptCacheEvent {
+    pub unexpected: bool,
+    pub reason: String,
+    pub previous_cache_read_input_tokens: u32,
+    pub current_cache_read_input_tokens: u32,
+    pub token_drop: u32,
+}
+
 pub trait ApiClient {
     fn stream(&mut self, request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError>;
 }
@@ -87,6 +94,7 @@ impl std::error::Error for RuntimeError {}
 pub struct TurnSummary {
     pub assistant_messages: Vec<ConversationMessage>,
     pub tool_results: Vec<ConversationMessage>,
+    pub prompt_cache_events: Vec<PromptCacheEvent>,
     pub iterations: usize,
     pub usage: TokenUsage,
 }
@@ -100,7 +108,6 @@ pub struct ConversationRuntime<C, T> {
     max_iterations: usize,
     usage_tracker: UsageTracker,
     hook_runner: HookRunner,
-    session_tracer: Option<SessionTracer>,
 }
 
 impl<C, T> ConversationRuntime<C, T>
@@ -145,7 +152,6 @@ where
             max_iterations: usize::MAX,
             usage_tracker,
             hook_runner: HookRunner::from_feature_config(feature_config),
-            session_tracer: None,
         }
     }
 
@@ -155,59 +161,39 @@ where
         self
     }
 
-    #[must_use]
-    pub fn with_session_tracer(mut self, session_tracer: SessionTracer) -> Self {
-        self.session_tracer = Some(session_tracer);
-        self
-    }
-
-    #[allow(clippy::too_many_lines)]
     pub fn run_turn(
         &mut self,
         user_input: impl Into<String>,
         mut prompter: Option<&mut dyn PermissionPrompter>,
     ) -> Result<TurnSummary, RuntimeError> {
-        let user_input = user_input.into();
-        self.record_turn_started(&user_input);
         self.session
             .messages
-            .push(ConversationMessage::user_text(user_input));
+            .push(ConversationMessage::user_text(user_input.into()));
 
         let mut assistant_messages = Vec::new();
         let mut tool_results = Vec::new();
+        let mut prompt_cache_events = Vec::new();
         let mut iterations = 0;
 
         loop {
             iterations += 1;
             if iterations > self.max_iterations {
-                let error = RuntimeError::new(
+                return Err(RuntimeError::new(
                     "conversation loop exceeded the maximum number of iterations",
-                );
-                self.record_turn_failed(iterations, &error);
-                return Err(error);
+                ));
             }
 
             let request = ApiRequest {
                 system_prompt: self.system_prompt.clone(),
                 messages: self.session.messages.clone(),
             };
-            let events = match self.api_client.stream(request) {
-                Ok(events) => events,
-                Err(error) => {
-                    self.record_turn_failed(iterations, &error);
-                    return Err(error);
-                }
-            };
-            let (assistant_message, usage) = match build_assistant_message(events) {
-                Ok(result) => result,
-                Err(error) => {
-                    self.record_turn_failed(iterations, &error);
-                    return Err(error);
-                }
-            };
+            let events = self.api_client.stream(request)?;
+            let (assistant_message, usage, turn_prompt_cache_events) =
+                build_assistant_message(events)?;
             if let Some(usage) = usage {
                 self.usage_tracker.record(usage);
             }
+            prompt_cache_events.extend(turn_prompt_cache_events);
             let pending_tool_uses = assistant_message
                 .blocks
                 .iter()
@@ -218,11 +204,6 @@ where
                     _ => None,
                 })
                 .collect::<Vec<_>>();
-            self.record_assistant_iteration(
-                iterations,
-                &assistant_message,
-                pending_tool_uses.len(),
-            );
 
             self.session.messages.push(assistant_message.clone());
             assistant_messages.push(assistant_message);
@@ -232,7 +213,6 @@ where
             }
 
             for (tool_use_id, tool_name, input) in pending_tool_uses {
-                self.record_tool_started(iterations, &tool_name);
                 let permission_outcome = if let Some(prompt) = prompter.as_mut() {
                     self.permission_policy
                         .authorize(&tool_name, &input, Some(*prompt))
@@ -283,20 +263,18 @@ where
                         ConversationMessage::tool_result(tool_use_id, tool_name, reason, true)
                     }
                 };
-                self.record_tool_finished(iterations, &result_message);
                 self.session.messages.push(result_message.clone());
                 tool_results.push(result_message);
             }
         }
 
-        let summary = TurnSummary {
+        Ok(TurnSummary {
             assistant_messages,
             tool_results,
+            prompt_cache_events,
             iterations,
             usage: self.usage_tracker.cumulative_usage(),
-        };
-        self.record_turn_completed(&summary);
-        Ok(summary)
+        })
     }
 
     #[must_use]
@@ -323,133 +301,21 @@ where
     pub fn into_session(self) -> Session {
         self.session
     }
-
-    fn record_turn_started(&self, user_input: &str) {
-        if let Some(tracer) = &self.session_tracer {
-            let mut attributes = Map::new();
-            attributes.insert(
-                "message_count_before".to_string(),
-                Value::from(u64::try_from(self.session.messages.len()).unwrap_or(u64::MAX)),
-            );
-            attributes.insert(
-                "input_chars".to_string(),
-                Value::from(u64::try_from(user_input.chars().count()).unwrap_or(u64::MAX)),
-            );
-            tracer.record("turn_started", attributes);
-        }
-    }
-
-    fn record_assistant_iteration(
-        &self,
-        iteration: usize,
-        assistant_message: &ConversationMessage,
-        pending_tool_count: usize,
-    ) {
-        if let Some(tracer) = &self.session_tracer {
-            let mut attributes = Map::new();
-            attributes.insert(
-                "iteration".to_string(),
-                Value::from(u64::try_from(iteration).unwrap_or(u64::MAX)),
-            );
-            attributes.insert(
-                "block_count".to_string(),
-                Value::from(u64::try_from(assistant_message.blocks.len()).unwrap_or(u64::MAX)),
-            );
-            attributes.insert(
-                "pending_tool_count".to_string(),
-                Value::from(u64::try_from(pending_tool_count).unwrap_or(u64::MAX)),
-            );
-            tracer.record("assistant_iteration_completed", attributes);
-        }
-    }
-
-    fn record_tool_started(&self, iteration: usize, tool_name: &str) {
-        if let Some(tracer) = &self.session_tracer {
-            let mut attributes = Map::new();
-            attributes.insert(
-                "iteration".to_string(),
-                Value::from(u64::try_from(iteration).unwrap_or(u64::MAX)),
-            );
-            attributes.insert(
-                "tool_name".to_string(),
-                Value::String(tool_name.to_string()),
-            );
-            tracer.record("tool_execution_started", attributes);
-        }
-    }
-
-    fn record_tool_finished(&self, iteration: usize, result_message: &ConversationMessage) {
-        let Some(tracer) = &self.session_tracer else {
-            return;
-        };
-        let Some(ContentBlock::ToolResult {
-            tool_name,
-            is_error,
-            output,
-            ..
-        }) = result_message.blocks.first()
-        else {
-            return;
-        };
-        let mut attributes = Map::new();
-        attributes.insert(
-            "iteration".to_string(),
-            Value::from(u64::try_from(iteration).unwrap_or(u64::MAX)),
-        );
-        attributes.insert("tool_name".to_string(), Value::String(tool_name.clone()));
-        attributes.insert("is_error".to_string(), Value::Bool(*is_error));
-        attributes.insert(
-            "output_chars".to_string(),
-            Value::from(u64::try_from(output.chars().count()).unwrap_or(u64::MAX)),
-        );
-        tracer.record("tool_execution_finished", attributes);
-    }
-
-    fn record_turn_completed(&self, summary: &TurnSummary) {
-        if let Some(tracer) = &self.session_tracer {
-            let mut attributes = Map::new();
-            attributes.insert(
-                "assistant_message_count".to_string(),
-                Value::from(u64::try_from(summary.assistant_messages.len()).unwrap_or(u64::MAX)),
-            );
-            attributes.insert(
-                "tool_result_count".to_string(),
-                Value::from(u64::try_from(summary.tool_results.len()).unwrap_or(u64::MAX)),
-            );
-            attributes.insert(
-                "iterations".to_string(),
-                Value::from(u64::try_from(summary.iterations).unwrap_or(u64::MAX)),
-            );
-            attributes.insert(
-                "total_input_tokens".to_string(),
-                Value::from(summary.usage.input_tokens),
-            );
-            attributes.insert(
-                "total_output_tokens".to_string(),
-                Value::from(summary.usage.output_tokens),
-            );
-            tracer.record("turn_completed", attributes);
-        }
-    }
-
-    fn record_turn_failed(&self, iteration: usize, error: &RuntimeError) {
-        if let Some(tracer) = &self.session_tracer {
-            let mut attributes = Map::new();
-            attributes.insert(
-                "iteration".to_string(),
-                Value::from(u64::try_from(iteration).unwrap_or(u64::MAX)),
-            );
-            attributes.insert("error".to_string(), Value::String(error.to_string()));
-            tracer.record("turn_failed", attributes);
-        }
-    }
 }
 
 fn build_assistant_message(
     events: Vec<AssistantEvent>,
-) -> Result<(ConversationMessage, Option<TokenUsage>), RuntimeError> {
+) -> Result<
+    (
+        ConversationMessage,
+        Option<TokenUsage>,
+        Vec<PromptCacheEvent>,
+    ),
+    RuntimeError,
+> {
     let mut text = String::new();
     let mut blocks = Vec::new();
+    let mut prompt_cache_events = Vec::new();
     let mut finished = false;
     let mut usage = None;
 
@@ -461,6 +327,7 @@ fn build_assistant_message(
                 blocks.push(ContentBlock::ToolUse { id, name, input });
             }
             AssistantEvent::Usage(value) => usage = Some(value),
+            AssistantEvent::PromptCache(event) => prompt_cache_events.push(event),
             AssistantEvent::MessageStop => {
                 finished = true;
             }
@@ -481,6 +348,7 @@ fn build_assistant_message(
     Ok((
         ConversationMessage::assistant_with_usage(blocks, usage),
         usage,
+        prompt_cache_events,
     ))
 }
 
@@ -553,7 +421,7 @@ impl ToolExecutor for StaticToolExecutor {
 #[cfg(test)]
 mod tests {
     use super::{
-        ApiClient, ApiRequest, AssistantEvent, ConversationRuntime, RuntimeError,
+        ApiClient, ApiRequest, AssistantEvent, ConversationRuntime, PromptCacheEvent, RuntimeError,
         StaticToolExecutor,
     };
     use crate::compact::CompactionConfig;
@@ -566,8 +434,6 @@ mod tests {
     use crate::session::{ContentBlock, MessageRole, Session};
     use crate::usage::TokenUsage;
     use std::path::PathBuf;
-    use std::sync::Arc;
-    use telemetry::{MemoryTelemetrySink, SessionTracer, TelemetryEvent};
 
     struct ScriptedApiClient {
         call_count: usize,
@@ -612,6 +478,15 @@ mod tests {
                             cache_creation_input_tokens: 1,
                             cache_read_input_tokens: 3,
                         }),
+                        AssistantEvent::PromptCache(PromptCacheEvent {
+                            unexpected: true,
+                            reason:
+                                "cache read tokens dropped while prompt fingerprint remained stable"
+                                    .to_string(),
+                            previous_cache_read_input_tokens: 6_000,
+                            current_cache_read_input_tokens: 1_000,
+                            token_drop: 5_000,
+                        }),
                         AssistantEvent::MessageStop,
                     ])
                 }
@@ -665,8 +540,10 @@ mod tests {
         assert_eq!(summary.iterations, 2);
         assert_eq!(summary.assistant_messages.len(), 2);
         assert_eq!(summary.tool_results.len(), 1);
+        assert_eq!(summary.prompt_cache_events.len(), 1);
         assert_eq!(runtime.session().messages.len(), 4);
         assert_eq!(summary.usage.output_tokens, 10);
+        assert!(summary.prompt_cache_events[0].unexpected);
         assert!(matches!(
             runtime.session().messages[1].blocks[1],
             ContentBlock::ToolUse { .. }
@@ -680,39 +557,6 @@ mod tests {
         ));
     }
 
-    #[test]
-    fn records_runtime_session_trace_events() {
-        let sink = Arc::new(MemoryTelemetrySink::default());
-        let tracer = SessionTracer::new("session-runtime", sink.clone());
-        let mut runtime = ConversationRuntime::new(
-            Session::new(),
-            ScriptedApiClient { call_count: 0 },
-            StaticToolExecutor::new().register("add", |_input| Ok("4".to_string())),
-            PermissionPolicy::new(PermissionMode::WorkspaceWrite),
-            vec!["system".to_string()],
-        )
-        .with_session_tracer(tracer);
-
-        runtime
-            .run_turn("what is 2 + 2?", Some(&mut PromptAllowOnce))
-            .expect("conversation loop should succeed");
-
-        let events = sink.events();
-        let trace_names = events
-            .iter()
-            .filter_map(|event| match event {
-                TelemetryEvent::SessionTrace(trace) => Some(trace.name.as_str()),
-                _ => None,
-            })
-            .collect::<Vec<_>>();
-
-        assert!(trace_names.contains(&"turn_started"));
-        assert!(trace_names.contains(&"assistant_iteration_completed"));
-        assert!(trace_names.contains(&"tool_execution_started"));
-        assert!(trace_names.contains(&"tool_execution_finished"));
-        assert!(trace_names.contains(&"turn_completed"));
-    }
-
     #[test]
     fn records_denied_tool_results_when_prompt_rejects() {
         struct RejectPrompter;

rust/crates/runtime/src/hooks.rs

@@ -113,19 +113,19 @@ impl HookRunner {
             "tool_result_is_error": is_error,
         })
         .to_string();
-        let invocation = HookInvocation {
-            event,
-            tool_name,
-            tool_input,
-            tool_output,
-            is_error,
-            payload: &payload,
-        };
 
         let mut messages = Vec::new();
 
         for command in commands {
-            match Self::run_command(command, &invocation) {
+            match Self::run_command(
+                command,
+                event,
+                tool_name,
+                tool_input,
+                tool_output,
+                is_error,
+                &payload,
+            ) {
                 HookCommandOutcome::Allow { message } => {
                     if let Some(message) = message {
                         messages.push(message);
@@ -148,23 +148,28 @@ impl HookRunner {
         HookRunResult::allow(messages)
     }
 
-    fn run_command(command: &str, invocation: &HookInvocation<'_>) -> HookCommandOutcome {
+    fn run_command(
+        command: &str,
+        event: HookEvent,
+        tool_name: &str,
+        tool_input: &str,
+        tool_output: Option<&str>,
+        is_error: bool,
+        payload: &str,
+    ) -> HookCommandOutcome {
         let mut child = shell_command(command);
         child.stdin(std::process::Stdio::piped());
         child.stdout(std::process::Stdio::piped());
         child.stderr(std::process::Stdio::piped());
-        child.env("HOOK_EVENT", invocation.event.as_str());
-        child.env("HOOK_TOOL_NAME", invocation.tool_name);
-        child.env("HOOK_TOOL_INPUT", invocation.tool_input);
-        child.env(
-            "HOOK_TOOL_IS_ERROR",
-            if invocation.is_error { "1" } else { "0" },
-        );
-        if let Some(tool_output) = invocation.tool_output {
+        child.env("HOOK_EVENT", event.as_str());
+        child.env("HOOK_TOOL_NAME", tool_name);
+        child.env("HOOK_TOOL_INPUT", tool_input);
+        child.env("HOOK_TOOL_IS_ERROR", if is_error { "1" } else { "0" });
+        if let Some(tool_output) = tool_output {
             child.env("HOOK_TOOL_OUTPUT", tool_output);
         }
 
-        match child.output_with_stdin(invocation.payload.as_bytes()) {
+        match child.output_with_stdin(payload.as_bytes()) {
             Ok(output) => {
                 let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
                 let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
@@ -182,9 +187,8 @@ impl HookRunner {
                     },
                     None => HookCommandOutcome::Warn {
                         message: format!(
-                            "{} hook `{command}` terminated by signal while handling `{}`",
-                            invocation.event.as_str(),
-                            invocation.tool_name
+                            "{} hook `{command}` terminated by signal while handling `{tool_name}`",
+                            event.as_str()
                         ),
                     },
                 }
@@ -192,23 +196,13 @@ impl HookRunner {
             Err(error) => HookCommandOutcome::Warn {
                 message: format!(
                     "{} hook `{command}` failed to start for `{tool_name}`: {error}",
-                    invocation.event.as_str(),
-                    tool_name = invocation.tool_name
+                    event.as_str()
                 ),
             },
         }
     }
 }
 
-struct HookInvocation<'a> {
-    event: HookEvent,
-    tool_name: &'a str,
-    tool_input: &'a str,
-    tool_output: Option<&'a str>,
-    is_error: bool,
-    payload: &'a str,
-}
-
 enum HookCommandOutcome {
     Allow { message: Option<String> },
     Deny { message: Option<String> },

rust/crates/runtime/src/lib.rs

@@ -31,8 +31,8 @@ pub use config::{
     ScopedMcpServerConfig, CLAUDE_CODE_SETTINGS_SCHEMA_NAME,
 };
 pub use conversation::{
-    ApiClient, ApiRequest, AssistantEvent, ConversationRuntime, RuntimeError, StaticToolExecutor,
-    ToolError, ToolExecutor, TurnSummary,
+    ApiClient, ApiRequest, AssistantEvent, ConversationRuntime, PromptCacheEvent, RuntimeError,
+    StaticToolExecutor, ToolError, ToolExecutor, TurnSummary,
 };
 pub use file_ops::{
     edit_file, glob_search, grep_search, read_file, write_file, EditFileOutput, GlobSearchOutput,

rust/crates/runtime/src/mcp_stdio.rs

@@ -1144,20 +1144,8 @@ mod tests {
     }
 
     fn cleanup_script(script_path: &Path) {
-        if let Err(error) = fs::remove_file(script_path) {
-            assert_eq!(
-                error.kind(),
-                std::io::ErrorKind::NotFound,
-                "cleanup script: {error}"
-            );
-        }
-        if let Err(error) = fs::remove_dir_all(script_path.parent().expect("script parent")) {
-            assert_eq!(
-                error.kind(),
-                std::io::ErrorKind::NotFound,
-                "cleanup dir: {error}"
-            );
-        }
+        fs::remove_file(script_path).expect("cleanup script");
+        fs::remove_dir_all(script_path.parent().expect("script parent")).expect("cleanup dir");
     }
 
     fn manager_server_config(

rust/crates/rusty-claude-cli/src/main.rs

@@ -4,7 +4,6 @@ mod render;
 
 use std::collections::{BTreeMap, BTreeSet};
 use std::env;
-use std::fmt::Write as _;
 use std::fs;
 use std::io::{self, Read, Write};
 use std::net::TcpListener;
@@ -14,8 +13,8 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 use api::{
     resolve_startup_auth_source, AnthropicClient, AuthSource, ContentBlockDelta, InputContentBlock,
-    InputMessage, JsonlTelemetrySink, MessageRequest, MessageResponse, OutputContentBlock,
-    SessionTracer, StreamEvent as ApiStreamEvent, ToolChoice, ToolDefinition,
+    InputMessage, MessageRequest, MessageResponse, OutputContentBlock, PromptCache,
+    PromptCacheRecord, StreamEvent as ApiStreamEvent, ToolChoice, ToolDefinition,
     ToolResultContentBlock,
 };
 
@@ -30,8 +29,8 @@ use runtime::{
     parse_oauth_callback_request_target, save_oauth_credentials, ApiClient, ApiRequest,
     AssistantEvent, CompactionConfig, ConfigLoader, ConfigSource, ContentBlock,
     ConversationMessage, ConversationRuntime, MessageRole, OAuthAuthorizationRequest, OAuthConfig,
-    OAuthTokenExchangeRequest, PermissionMode, PermissionPolicy, ProjectContext, RuntimeError,
-    Session, TokenUsage, ToolError, ToolExecutor, UsageTracker,
+    OAuthTokenExchangeRequest, PermissionMode, PermissionPolicy, ProjectContext, PromptCacheEvent,
+    RuntimeError, Session, TokenUsage, ToolError, ToolExecutor, UsageTracker,
 };
 use serde_json::json;
 use tools::{execute_tool, mvp_tool_specs, ToolSpec};
@@ -46,7 +45,6 @@ fn max_tokens_for_model(model: &str) -> u32 {
 }
 const DEFAULT_DATE: &str = "2026-03-31";
 const DEFAULT_OAUTH_CALLBACK_PORT: u16 = 4545;
-const TELEMETRY_LOG_PATH_ENV: &str = "CLAW_TELEMETRY_LOG_PATH";
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 const BUILD_TARGET: Option<&str> = option_env!("TARGET");
 const GIT_SHA: Option<&str> = option_env!("GIT_SHA");
@@ -998,7 +996,7 @@ impl LiveCli {
         let session = create_managed_session_handle()?;
         let runtime = build_runtime(
             Session::new(),
-            &session.id,
+            session.id.clone(),
             model.clone(),
             system_prompt.clone(),
             enable_tools,
@@ -1054,13 +1052,14 @@ impl LiveCli {
         let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
         let result = self.runtime.run_turn(input, Some(&mut permission_prompter));
         match result {
-            Ok(_) => {
+            Ok(summary) => {
                 spinner.finish(
                     "✨ Done",
                     TerminalRenderer::new().color_theme(),
                     &mut stdout,
                 )?;
                 println!();
+                print_prompt_cache_events(&summary);
                 self.persist_session()?;
                 Ok(())
             }
@@ -1090,7 +1089,7 @@ impl LiveCli {
         let session = self.runtime.session().clone();
         let mut runtime = build_runtime(
             session,
-            &self.session.id,
+            self.session.id.clone(),
             self.model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1110,6 +1109,7 @@ impl LiveCli {
                 "iterations": summary.iterations,
                 "tool_uses": collect_tool_uses(&summary),
                 "tool_results": collect_tool_results(&summary),
+                "prompt_cache_events": collect_prompt_cache_events(&summary),
                 "usage": {
                     "input_tokens": summary.usage.input_tokens,
                     "output_tokens": summary.usage.output_tokens,
@@ -1237,7 +1237,7 @@ impl LiveCli {
         let message_count = session.messages.len();
         self.runtime = build_runtime(
             session,
-            &self.session.id,
+            self.session.id.clone(),
             model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1281,7 +1281,7 @@ impl LiveCli {
         self.permission_mode = permission_mode_from_label(normalized);
         self.runtime = build_runtime(
             session,
-            &self.session.id,
+            self.session.id.clone(),
             self.model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1307,7 +1307,7 @@ impl LiveCli {
         self.session = create_managed_session_handle()?;
         self.runtime = build_runtime(
             Session::new(),
-            &self.session.id,
+            self.session.id.clone(),
             self.model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1343,7 +1343,7 @@ impl LiveCli {
         let message_count = session.messages.len();
         self.runtime = build_runtime(
             session,
-            &handle.id,
+            handle.id.clone(),
             self.model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1416,7 +1416,7 @@ impl LiveCli {
                 let message_count = session.messages.len();
                 self.runtime = build_runtime(
                     session,
-                    &handle.id,
+                    handle.id.clone(),
                     self.model.clone(),
                     self.system_prompt.clone(),
                     true,
@@ -1447,7 +1447,7 @@ impl LiveCli {
         let skipped = removed == 0;
         self.runtime = build_runtime(
             result.compacted_session,
-            &self.session.id,
+            self.session.id.clone(),
             self.model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1926,7 +1926,7 @@ fn build_runtime_feature_config(
 #[allow(clippy::too_many_arguments)]
 fn build_runtime(
     session: Session,
-    session_id: &str,
+    session_id: String,
     model: String,
     system_prompt: Vec<String>,
     enable_tools: bool,
@@ -1935,41 +1935,20 @@ fn build_runtime(
     permission_mode: PermissionMode,
 ) -> Result<ConversationRuntime<AnthropicRuntimeClient, CliToolExecutor>, Box<dyn std::error::Error>>
 {
-    let session_tracer = build_session_tracer(session_id)?;
-    let api_client = match session_tracer.clone() {
-        Some(session_tracer) => {
-            AnthropicRuntimeClient::new(model, enable_tools, emit_output, allowed_tools.clone())?
-                .with_session_tracer(session_tracer)
-        }
-        None => {
-            AnthropicRuntimeClient::new(model, enable_tools, emit_output, allowed_tools.clone())?
-        }
-    };
-    let runtime = ConversationRuntime::new_with_features(
+    Ok(ConversationRuntime::new_with_features(
         session,
-        api_client,
+        AnthropicRuntimeClient::new(
+            model,
+            enable_tools,
+            emit_output,
+            allowed_tools.clone(),
+            session_id,
+        )?,
         CliToolExecutor::new(allowed_tools, emit_output),
         permission_policy(permission_mode),
         system_prompt,
         &build_runtime_feature_config()?,
-    );
-    Ok(match session_tracer {
-        Some(session_tracer) => runtime.with_session_tracer(session_tracer),
-        None => runtime,
-    })
-}
-
-fn build_session_tracer(
-    session_id: &str,
-) -> Result<Option<SessionTracer>, Box<dyn std::error::Error>> {
-    let Some(path) = env::var_os(TELEMETRY_LOG_PATH_ENV) else {
-        return Ok(None);
-    };
-    let sink = JsonlTelemetrySink::new(PathBuf::from(path))?;
-    Ok(Some(SessionTracer::new(
-        session_id.to_string(),
-        std::sync::Arc::new(sink),
-    )))
+    ))
 }
 
 struct CliPermissionPrompter {
@@ -2033,22 +2012,19 @@ impl AnthropicRuntimeClient {
         enable_tools: bool,
         emit_output: bool,
         allowed_tools: Option<AllowedToolSet>,
+        session_id: impl Into<String>,
     ) -> Result<Self, Box<dyn std::error::Error>> {
         Ok(Self {
             runtime: tokio::runtime::Runtime::new()?,
             client: AnthropicClient::from_auth(resolve_cli_auth_source()?)
-                .with_base_url(api::read_base_url()),
+                .with_base_url(api::read_base_url())
+                .with_prompt_cache(PromptCache::new(session_id)),
             model,
             enable_tools,
             emit_output,
             allowed_tools,
         })
     }
-
-    fn with_session_tracer(mut self, session_tracer: SessionTracer) -> Self {
-        self.client = self.client.with_session_tracer(session_tracer);
-        self
-    }
 }
 
 fn resolve_cli_auth_source() -> Result<AuthSource, Box<dyn std::error::Error>> {
@@ -2154,7 +2130,12 @@ impl ApiClient for AnthropicRuntimeClient {
                         }
                     }
                     ApiStreamEvent::MessageDelta(delta) => {
-                        events.push(AssistantEvent::Usage(delta.usage.token_usage()));
+                        events.push(AssistantEvent::Usage(TokenUsage {
+                            input_tokens: delta.usage.input_tokens,
+                            output_tokens: delta.usage.output_tokens,
+                            cache_creation_input_tokens: delta.usage.cache_creation_input_tokens,
+                            cache_read_input_tokens: delta.usage.cache_read_input_tokens,
+                        }));
                     }
                     ApiStreamEvent::MessageStop(_) => {
                         saw_stop = true;
@@ -2168,6 +2149,8 @@ impl ApiClient for AnthropicRuntimeClient {
                 }
             }
 
+            push_prompt_cache_record(&self.client, &mut events);
+
             if !saw_stop
                 && events.iter().any(|event| {
                     matches!(event, AssistantEvent::TextDelta(text) if !text.is_empty())
@@ -2192,7 +2175,9 @@ impl ApiClient for AnthropicRuntimeClient {
                 })
                 .await
                 .map_err(|error| RuntimeError::new(error.to_string()))?;
-            response_to_events(response, out)
+            let mut events = response_to_events(response, out)?;
+            push_prompt_cache_record(&self.client, &mut events);
+            Ok(events)
         })
     }
 }
@@ -2253,6 +2238,39 @@ fn collect_tool_results(summary: &runtime::TurnSummary) -> Vec<serde_json::Value
         .collect()
 }
 
+fn collect_prompt_cache_events(summary: &runtime::TurnSummary) -> Vec<serde_json::Value> {
+    summary
+        .prompt_cache_events
+        .iter()
+        .map(|event| {
+            json!({
+                "unexpected": event.unexpected,
+                "reason": event.reason,
+                "previous_cache_read_input_tokens": event.previous_cache_read_input_tokens,
+                "current_cache_read_input_tokens": event.current_cache_read_input_tokens,
+                "token_drop": event.token_drop,
+            })
+        })
+        .collect()
+}
+
+fn print_prompt_cache_events(summary: &runtime::TurnSummary) {
+    for event in &summary.prompt_cache_events {
+        let label = if event.unexpected {
+            "Prompt cache break"
+        } else {
+            "Prompt cache invalidation"
+        };
+        println!(
+            "{label}: {} (cache read {} -> {}, drop {})",
+            event.reason,
+            event.previous_cache_read_input_tokens,
+            event.current_cache_read_input_tokens,
+            event.token_drop,
+        );
+    }
+}
+
 fn slash_command_completion_candidates() -> Vec<String> {
     slash_command_specs()
         .iter()
@@ -2399,18 +2417,20 @@ fn first_visible_line(text: &str) -> &str {
 }
 
 fn format_bash_result(icon: &str, parsed: &serde_json::Value) -> String {
+    use std::fmt::Write as _;
+
     let mut lines = vec![format!("{icon} \x1b[38;5;245mbash\x1b[0m")];
     if let Some(task_id) = parsed
         .get("backgroundTaskId")
         .and_then(|value| value.as_str())
     {
-        write!(&mut lines[0], " backgrounded ({task_id})").expect("write to string");
+        let _ = write!(lines[0], " backgrounded ({task_id})");
     } else if let Some(status) = parsed
         .get("returnCodeInterpretation")
         .and_then(|value| value.as_str())
         .filter(|status| !status.is_empty())
     {
-        write!(&mut lines[0], " {status}").expect("write to string");
+        let _ = write!(lines[0], " {status}");
     }
 
     if let Some(stdout) = parsed.get("stdout").and_then(|value| value.as_str()) {
@@ -2650,11 +2670,36 @@ fn response_to_events(
         }
     }
 
-    events.push(AssistantEvent::Usage(response.usage.token_usage()));
+    events.push(AssistantEvent::Usage(TokenUsage {
+        input_tokens: response.usage.input_tokens,
+        output_tokens: response.usage.output_tokens,
+        cache_creation_input_tokens: response.usage.cache_creation_input_tokens,
+        cache_read_input_tokens: response.usage.cache_read_input_tokens,
+    }));
     events.push(AssistantEvent::MessageStop);
     Ok(events)
 }
 
+fn push_prompt_cache_record(client: &AnthropicClient, events: &mut Vec<AssistantEvent>) {
+    if let Some(event) = client
+        .take_last_prompt_cache_record()
+        .and_then(prompt_cache_record_to_runtime_event)
+    {
+        events.push(AssistantEvent::PromptCache(event));
+    }
+}
+
+fn prompt_cache_record_to_runtime_event(record: PromptCacheRecord) -> Option<PromptCacheEvent> {
+    let cache_break = record.cache_break?;
+    Some(PromptCacheEvent {
+        unexpected: cache_break.unexpected,
+        reason: cache_break.reason,
+        previous_cache_read_input_tokens: cache_break.previous_cache_read_input_tokens,
+        current_cache_read_input_tokens: cache_break.current_cache_read_input_tokens,
+        token_drop: cache_break.token_drop,
+    })
+}
+
 struct CliToolExecutor {
     renderer: TerminalRenderer,
     emit_output: bool,

rust/crates/telemetry/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "telemetry"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-publish.workspace = true
-
-[dependencies]
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-
-[lints]
-workspace = true

rust/crates/telemetry/src/lib.rs

@@ -1,526 +0,0 @@
-use std::fmt::{Debug, Formatter};
-use std::fs::{File, OpenOptions};
-use std::io::Write;
-use std::path::{Path, PathBuf};
-use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::{Arc, Mutex};
-use std::time::{SystemTime, UNIX_EPOCH};
-
-use serde::{Deserialize, Serialize};
-use serde_json::{Map, Value};
-
-pub const DEFAULT_ANTHROPIC_VERSION: &str = "2023-06-01";
-pub const DEFAULT_APP_NAME: &str = "claude-code";
-pub const DEFAULT_RUNTIME: &str = "rust";
-pub const DEFAULT_AGENTIC_BETA: &str = "claude-code-20250219";
-pub const DEFAULT_PROMPT_CACHING_SCOPE_BETA: &str = "prompt-caching-scope-2026-01-05";
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct ClientIdentity {
-    pub app_name: String,
-    pub app_version: String,
-    pub runtime: String,
-}
-
-impl ClientIdentity {
-    #[must_use]
-    pub fn new(app_name: impl Into<String>, app_version: impl Into<String>) -> Self {
-        Self {
-            app_name: app_name.into(),
-            app_version: app_version.into(),
-            runtime: DEFAULT_RUNTIME.to_string(),
-        }
-    }
-
-    #[must_use]
-    pub fn with_runtime(mut self, runtime: impl Into<String>) -> Self {
-        self.runtime = runtime.into();
-        self
-    }
-
-    #[must_use]
-    pub fn user_agent(&self) -> String {
-        format!("{}/{}", self.app_name, self.app_version)
-    }
-}
-
-impl Default for ClientIdentity {
-    fn default() -> Self {
-        Self::new(DEFAULT_APP_NAME, env!("CARGO_PKG_VERSION"))
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct AnthropicRequestProfile {
-    pub anthropic_version: String,
-    pub client_identity: ClientIdentity,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub betas: Vec<String>,
-    #[serde(default, skip_serializing_if = "Map::is_empty")]
-    pub extra_body: Map<String, Value>,
-}
-
-impl AnthropicRequestProfile {
-    #[must_use]
-    pub fn new(client_identity: ClientIdentity) -> Self {
-        Self {
-            anthropic_version: DEFAULT_ANTHROPIC_VERSION.to_string(),
-            client_identity,
-            betas: vec![
-                DEFAULT_AGENTIC_BETA.to_string(),
-                DEFAULT_PROMPT_CACHING_SCOPE_BETA.to_string(),
-            ],
-            extra_body: Map::new(),
-        }
-    }
-
-    #[must_use]
-    pub fn with_beta(mut self, beta: impl Into<String>) -> Self {
-        let beta = beta.into();
-        if !self.betas.contains(&beta) {
-            self.betas.push(beta);
-        }
-        self
-    }
-
-    #[must_use]
-    pub fn with_extra_body(mut self, key: impl Into<String>, value: Value) -> Self {
-        self.extra_body.insert(key.into(), value);
-        self
-    }
-
-    #[must_use]
-    pub fn header_pairs(&self) -> Vec<(String, String)> {
-        let mut headers = vec![
-            (
-                "anthropic-version".to_string(),
-                self.anthropic_version.clone(),
-            ),
-            ("user-agent".to_string(), self.client_identity.user_agent()),
-        ];
-        if !self.betas.is_empty() {
-            headers.push(("anthropic-beta".to_string(), self.betas.join(",")));
-        }
-        headers
-    }
-
-    pub fn render_json_body<T: Serialize>(&self, request: &T) -> Result<Value, serde_json::Error> {
-        let mut body = serde_json::to_value(request)?;
-        let object = body.as_object_mut().ok_or_else(|| {
-            serde_json::Error::io(std::io::Error::new(
-                std::io::ErrorKind::InvalidData,
-                "request body must serialize to a JSON object",
-            ))
-        })?;
-        for (key, value) in &self.extra_body {
-            object.insert(key.clone(), value.clone());
-        }
-        if !self.betas.is_empty() {
-            object.insert(
-                "betas".to_string(),
-                Value::Array(self.betas.iter().cloned().map(Value::String).collect()),
-            );
-        }
-        Ok(body)
-    }
-}
-
-impl Default for AnthropicRequestProfile {
-    fn default() -> Self {
-        Self::new(ClientIdentity::default())
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct AnalyticsEvent {
-    pub namespace: String,
-    pub action: String,
-    #[serde(default, skip_serializing_if = "Map::is_empty")]
-    pub properties: Map<String, Value>,
-}
-
-impl AnalyticsEvent {
-    #[must_use]
-    pub fn new(namespace: impl Into<String>, action: impl Into<String>) -> Self {
-        Self {
-            namespace: namespace.into(),
-            action: action.into(),
-            properties: Map::new(),
-        }
-    }
-
-    #[must_use]
-    pub fn with_property(mut self, key: impl Into<String>, value: Value) -> Self {
-        self.properties.insert(key.into(), value);
-        self
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct SessionTraceRecord {
-    pub session_id: String,
-    pub sequence: u64,
-    pub name: String,
-    pub timestamp_ms: u64,
-    #[serde(default, skip_serializing_if = "Map::is_empty")]
-    pub attributes: Map<String, Value>,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(tag = "type", rename_all = "snake_case")]
-pub enum TelemetryEvent {
-    HttpRequestStarted {
-        session_id: String,
-        attempt: u32,
-        method: String,
-        path: String,
-        #[serde(default, skip_serializing_if = "Map::is_empty")]
-        attributes: Map<String, Value>,
-    },
-    HttpRequestSucceeded {
-        session_id: String,
-        attempt: u32,
-        method: String,
-        path: String,
-        status: u16,
-        #[serde(default, skip_serializing_if = "Option::is_none")]
-        request_id: Option<String>,
-        #[serde(default, skip_serializing_if = "Map::is_empty")]
-        attributes: Map<String, Value>,
-    },
-    HttpRequestFailed {
-        session_id: String,
-        attempt: u32,
-        method: String,
-        path: String,
-        error: String,
-        retryable: bool,
-        #[serde(default, skip_serializing_if = "Map::is_empty")]
-        attributes: Map<String, Value>,
-    },
-    Analytics(AnalyticsEvent),
-    SessionTrace(SessionTraceRecord),
-}
-
-pub trait TelemetrySink: Send + Sync {
-    fn record(&self, event: TelemetryEvent);
-}
-
-#[derive(Default)]
-pub struct MemoryTelemetrySink {
-    events: Mutex<Vec<TelemetryEvent>>,
-}
-
-impl MemoryTelemetrySink {
-    #[must_use]
-    pub fn events(&self) -> Vec<TelemetryEvent> {
-        self.events
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner)
-            .clone()
-    }
-}
-
-impl TelemetrySink for MemoryTelemetrySink {
-    fn record(&self, event: TelemetryEvent) {
-        self.events
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner)
-            .push(event);
-    }
-}
-
-pub struct JsonlTelemetrySink {
-    path: PathBuf,
-    file: Mutex<File>,
-}
-
-impl Debug for JsonlTelemetrySink {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("JsonlTelemetrySink")
-            .field("path", &self.path)
-            .finish_non_exhaustive()
-    }
-}
-
-impl JsonlTelemetrySink {
-    pub fn new(path: impl AsRef<Path>) -> Result<Self, std::io::Error> {
-        let path = path.as_ref().to_path_buf();
-        if let Some(parent) = path.parent() {
-            std::fs::create_dir_all(parent)?;
-        }
-        let file = OpenOptions::new().create(true).append(true).open(&path)?;
-        Ok(Self {
-            path,
-            file: Mutex::new(file),
-        })
-    }
-
-    #[must_use]
-    pub fn path(&self) -> &Path {
-        &self.path
-    }
-}
-
-impl TelemetrySink for JsonlTelemetrySink {
-    fn record(&self, event: TelemetryEvent) {
-        let Ok(line) = serde_json::to_string(&event) else {
-            return;
-        };
-        let mut file = self
-            .file
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner);
-        let _ = writeln!(file, "{line}");
-        let _ = file.flush();
-    }
-}
-
-#[derive(Clone)]
-pub struct SessionTracer {
-    session_id: String,
-    sequence: Arc<AtomicU64>,
-    sink: Arc<dyn TelemetrySink>,
-}
-
-impl Debug for SessionTracer {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("SessionTracer")
-            .field("session_id", &self.session_id)
-            .finish_non_exhaustive()
-    }
-}
-
-impl SessionTracer {
-    #[must_use]
-    pub fn new(session_id: impl Into<String>, sink: Arc<dyn TelemetrySink>) -> Self {
-        Self {
-            session_id: session_id.into(),
-            sequence: Arc::new(AtomicU64::new(0)),
-            sink,
-        }
-    }
-
-    #[must_use]
-    pub fn session_id(&self) -> &str {
-        &self.session_id
-    }
-
-    pub fn record(&self, name: impl Into<String>, attributes: Map<String, Value>) {
-        let record = SessionTraceRecord {
-            session_id: self.session_id.clone(),
-            sequence: self.sequence.fetch_add(1, Ordering::Relaxed),
-            name: name.into(),
-            timestamp_ms: current_timestamp_ms(),
-            attributes,
-        };
-        self.sink.record(TelemetryEvent::SessionTrace(record));
-    }
-
-    pub fn record_http_request_started(
-        &self,
-        attempt: u32,
-        method: impl Into<String>,
-        path: impl Into<String>,
-        attributes: Map<String, Value>,
-    ) {
-        let method = method.into();
-        let path = path.into();
-        self.sink.record(TelemetryEvent::HttpRequestStarted {
-            session_id: self.session_id.clone(),
-            attempt,
-            method: method.clone(),
-            path: path.clone(),
-            attributes: attributes.clone(),
-        });
-        self.record(
-            "http_request_started",
-            merge_trace_fields(method, path, attempt, attributes),
-        );
-    }
-
-    pub fn record_http_request_succeeded(
-        &self,
-        attempt: u32,
-        method: impl Into<String>,
-        path: impl Into<String>,
-        status: u16,
-        request_id: Option<String>,
-        attributes: Map<String, Value>,
-    ) {
-        let method = method.into();
-        let path = path.into();
-        self.sink.record(TelemetryEvent::HttpRequestSucceeded {
-            session_id: self.session_id.clone(),
-            attempt,
-            method: method.clone(),
-            path: path.clone(),
-            status,
-            request_id: request_id.clone(),
-            attributes: attributes.clone(),
-        });
-        let mut trace_attributes = merge_trace_fields(method, path, attempt, attributes);
-        trace_attributes.insert("status".to_string(), Value::from(status));
-        if let Some(request_id) = request_id {
-            trace_attributes.insert("request_id".to_string(), Value::String(request_id));
-        }
-        self.record("http_request_succeeded", trace_attributes);
-    }
-
-    pub fn record_http_request_failed(
-        &self,
-        attempt: u32,
-        method: impl Into<String>,
-        path: impl Into<String>,
-        error: impl Into<String>,
-        retryable: bool,
-        attributes: Map<String, Value>,
-    ) {
-        let method = method.into();
-        let path = path.into();
-        let error = error.into();
-        self.sink.record(TelemetryEvent::HttpRequestFailed {
-            session_id: self.session_id.clone(),
-            attempt,
-            method: method.clone(),
-            path: path.clone(),
-            error: error.clone(),
-            retryable,
-            attributes: attributes.clone(),
-        });
-        let mut trace_attributes = merge_trace_fields(method, path, attempt, attributes);
-        trace_attributes.insert("error".to_string(), Value::String(error));
-        trace_attributes.insert("retryable".to_string(), Value::Bool(retryable));
-        self.record("http_request_failed", trace_attributes);
-    }
-
-    pub fn record_analytics(&self, event: AnalyticsEvent) {
-        let mut attributes = event.properties.clone();
-        attributes.insert(
-            "namespace".to_string(),
-            Value::String(event.namespace.clone()),
-        );
-        attributes.insert("action".to_string(), Value::String(event.action.clone()));
-        self.sink.record(TelemetryEvent::Analytics(event));
-        self.record("analytics", attributes);
-    }
-}
-
-fn merge_trace_fields(
-    method: String,
-    path: String,
-    attempt: u32,
-    mut attributes: Map<String, Value>,
-) -> Map<String, Value> {
-    attributes.insert("method".to_string(), Value::String(method));
-    attributes.insert("path".to_string(), Value::String(path));
-    attributes.insert("attempt".to_string(), Value::from(attempt));
-    attributes
-}
-
-fn current_timestamp_ms() -> u64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap_or_default()
-        .as_millis()
-        .try_into()
-        .unwrap_or(u64::MAX)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn request_profile_emits_headers_and_merges_body() {
-        let profile = AnthropicRequestProfile::new(
-            ClientIdentity::new("claude-code", "1.2.3").with_runtime("rust-cli"),
-        )
-        .with_beta("tools-2026-04-01")
-        .with_extra_body("metadata", serde_json::json!({"source": "test"}));
-
-        assert_eq!(
-            profile.header_pairs(),
-            vec![
-                (
-                    "anthropic-version".to_string(),
-                    DEFAULT_ANTHROPIC_VERSION.to_string()
-                ),
-                ("user-agent".to_string(), "claude-code/1.2.3".to_string()),
-                (
-                    "anthropic-beta".to_string(),
-                    "claude-code-20250219,prompt-caching-scope-2026-01-05,tools-2026-04-01"
-                        .to_string(),
-                ),
-            ]
-        );
-
-        let body = profile
-            .render_json_body(&serde_json::json!({"model": "claude-sonnet"}))
-            .expect("body should serialize");
-        assert_eq!(
-            body["metadata"]["source"],
-            Value::String("test".to_string())
-        );
-        assert_eq!(
-            body["betas"],
-            serde_json::json!([
-                "claude-code-20250219",
-                "prompt-caching-scope-2026-01-05",
-                "tools-2026-04-01"
-            ])
-        );
-    }
-
-    #[test]
-    fn session_tracer_records_structured_events_and_trace_sequence() {
-        let sink = Arc::new(MemoryTelemetrySink::default());
-        let tracer = SessionTracer::new("session-123", sink.clone());
-
-        tracer.record_http_request_started(1, "POST", "/v1/messages", Map::new());
-        tracer.record_analytics(
-            AnalyticsEvent::new("cli", "prompt_sent")
-                .with_property("model", Value::String("claude-opus".to_string())),
-        );
-
-        let events = sink.events();
-        assert!(matches!(
-            &events[0],
-            TelemetryEvent::HttpRequestStarted {
-                session_id,
-                attempt: 1,
-                method,
-                path,
-                ..
-            } if session_id == "session-123" && method == "POST" && path == "/v1/messages"
-        ));
-        assert!(matches!(
-            &events[1],
-            TelemetryEvent::SessionTrace(SessionTraceRecord { sequence: 0, name, .. })
-            if name == "http_request_started"
-        ));
-        assert!(matches!(&events[2], TelemetryEvent::Analytics(_)));
-        assert!(matches!(
-            &events[3],
-            TelemetryEvent::SessionTrace(SessionTraceRecord { sequence: 1, name, .. })
-            if name == "analytics"
-        ));
-    }
-
-    #[test]
-    fn jsonl_sink_persists_events() {
-        let path =
-            std::env::temp_dir().join(format!("telemetry-jsonl-{}.log", current_timestamp_ms()));
-        let sink = JsonlTelemetrySink::new(&path).expect("sink should create file");
-
-        sink.record(TelemetryEvent::Analytics(
-            AnalyticsEvent::new("cli", "turn_completed").with_property("ok", Value::Bool(true)),
-        ));
-
-        let contents = std::fs::read_to_string(&path).expect("telemetry log should be readable");
-        assert!(contents.contains("\"type\":\"analytics\""));
-        assert!(contents.contains("\"action\":\"turn_completed\""));
-
-        let _ = std::fs::remove_file(path);
-    }
-}

rust/crates/tools/src/lib.rs

@@ -5,15 +5,15 @@ use std::time::{Duration, Instant};
 
 use api::{
     read_base_url, AnthropicClient, ContentBlockDelta, InputContentBlock, InputMessage,
-    MessageRequest, MessageResponse, OutputContentBlock, StreamEvent as ApiStreamEvent, ToolChoice,
-    ToolDefinition, ToolResultContentBlock,
+    MessageRequest, MessageResponse, OutputContentBlock, PromptCache, PromptCacheRecord,
+    StreamEvent as ApiStreamEvent, ToolChoice, ToolDefinition, ToolResultContentBlock,
 };
 use reqwest::blocking::Client;
 use runtime::{
     edit_file, execute_bash, glob_search, grep_search, load_system_prompt, read_file, write_file,
     ApiClient, ApiRequest, AssistantEvent, BashCommandInput, ContentBlock, ConversationMessage,
     ConversationRuntime, GrepSearchInput, MessageRole, PermissionMode, PermissionPolicy,
-    RuntimeError, Session, ToolError, ToolExecutor,
+    PromptCacheEvent, RuntimeError, Session, TokenUsage, ToolError, ToolExecutor,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
@@ -1466,7 +1466,8 @@ fn build_agent_runtime(
         .clone()
         .unwrap_or_else(|| DEFAULT_AGENT_MODEL.to_string());
     let allowed_tools = job.allowed_tools.clone();
-    let api_client = AnthropicRuntimeClient::new(model, allowed_tools.clone())?;
+    let api_client =
+        AnthropicRuntimeClient::new(model, allowed_tools.clone(), job.manifest.agent_id.clone())?;
     let tool_executor = SubagentToolExecutor::new(allowed_tools);
     Ok(ConversationRuntime::new(
         Session::new(),
@@ -1643,10 +1644,15 @@ struct AnthropicRuntimeClient {
 }
 
 impl AnthropicRuntimeClient {
-    fn new(model: String, allowed_tools: BTreeSet<String>) -> Result<Self, String> {
+    fn new(
+        model: String,
+        allowed_tools: BTreeSet<String>,
+        session_id: impl Into<String>,
+    ) -> Result<Self, String> {
         let client = AnthropicClient::from_env()
             .map_err(|error| error.to_string())?
-            .with_base_url(read_base_url());
+            .with_base_url(read_base_url())
+            .with_prompt_cache(PromptCache::new(session_id));
         Ok(Self {
             runtime: tokio::runtime::Runtime::new().map_err(|error| error.to_string())?,
             client,
@@ -1657,6 +1663,7 @@ impl AnthropicRuntimeClient {
 }
 
 impl ApiClient for AnthropicRuntimeClient {
+    #[allow(clippy::too_many_lines)]
     fn stream(&mut self, request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError> {
         let tools = tool_specs_for_allowed_tools(Some(&self.allowed_tools))
             .into_iter()
@@ -1723,7 +1730,12 @@ impl ApiClient for AnthropicRuntimeClient {
                         }
                     }
                     ApiStreamEvent::MessageDelta(delta) => {
-                        events.push(AssistantEvent::Usage(delta.usage.token_usage()));
+                        events.push(AssistantEvent::Usage(TokenUsage {
+                            input_tokens: delta.usage.input_tokens,
+                            output_tokens: delta.usage.output_tokens,
+                            cache_creation_input_tokens: delta.usage.cache_creation_input_tokens,
+                            cache_read_input_tokens: delta.usage.cache_read_input_tokens,
+                        }));
                     }
                     ApiStreamEvent::MessageStop(_) => {
                         saw_stop = true;
@@ -1732,6 +1744,8 @@ impl ApiClient for AnthropicRuntimeClient {
                 }
             }
 
+            push_prompt_cache_record(&self.client, &mut events);
+
             if !saw_stop
                 && events.iter().any(|event| {
                     matches!(event, AssistantEvent::TextDelta(text) if !text.is_empty())
@@ -1756,7 +1770,9 @@ impl ApiClient for AnthropicRuntimeClient {
                 })
                 .await
                 .map_err(|error| RuntimeError::new(error.to_string()))?;
-            Ok(response_to_events(response))
+            let mut events = response_to_events(response);
+            push_prompt_cache_record(&self.client, &mut events);
+            Ok(events)
         })
     }
 }
@@ -1869,11 +1885,36 @@ fn response_to_events(response: MessageResponse) -> Vec<AssistantEvent> {
         }
     }
 
-    events.push(AssistantEvent::Usage(response.usage.token_usage()));
+    events.push(AssistantEvent::Usage(TokenUsage {
+        input_tokens: response.usage.input_tokens,
+        output_tokens: response.usage.output_tokens,
+        cache_creation_input_tokens: response.usage.cache_creation_input_tokens,
+        cache_read_input_tokens: response.usage.cache_read_input_tokens,
+    }));
     events.push(AssistantEvent::MessageStop);
     events
 }
 
+fn push_prompt_cache_record(client: &AnthropicClient, events: &mut Vec<AssistantEvent>) {
+    if let Some(event) = client
+        .take_last_prompt_cache_record()
+        .and_then(prompt_cache_record_to_runtime_event)
+    {
+        events.push(AssistantEvent::PromptCache(event));
+    }
+}
+
+fn prompt_cache_record_to_runtime_event(record: PromptCacheRecord) -> Option<PromptCacheEvent> {
+    let cache_break = record.cache_break?;
+    Some(PromptCacheEvent {
+        unexpected: cache_break.unexpected,
+        reason: cache_break.reason,
+        previous_cache_read_input_tokens: cache_break.previous_cache_read_input_tokens,
+        current_cache_read_input_tokens: cache_break.current_cache_read_input_tokens,
+        token_drop: cache_break.token_drop,
+    })
+}
+
 fn final_assistant_text(summary: &runtime::TurnSummary) -> String {
     summary
         .assistant_messages