llm/providers/anthropic/
provider.rs

1use super::mappers::{map_messages, map_tools};
2use super::streaming::process_anthropic_stream;
3use super::types::{Request, Thinking};
4use crate::provider::{LlmResponseStream, ProviderFactory, StreamingModelProvider, get_context_window};
5use crate::{Context, LlmError, ReasoningEffort, Result};
6use async_stream;
7use eventsource_stream::Eventsource;
8use futures::StreamExt;
9use reqwest::header::{CONTENT_TYPE, HeaderMap, HeaderValue};
10use reqwest::{Client, header};
11use std::env;
12use std::time::Duration;
13use tracing::debug;
14
15#[derive(Clone)]
16pub struct AnthropicProvider {
17    client: Client,
18    model: String,
19    base_url: Option<String>,
20    temperature: Option<f32>,
21    max_tokens: u32,
22    api_key: Option<String>,
23}
24
25impl AnthropicProvider {
26    pub fn new(api_key: Option<String>) -> Result<Self> {
27        let client = build_client()?;
28
29        Ok(Self {
30            client,
31            model: "claude-sonnet-4-5-20250929".to_string(),
32            base_url: Some("https://api.anthropic.com".to_string()),
33            temperature: None,
34            max_tokens: 16_384,
35            api_key,
36        })
37    }
38
39    pub fn with_model(mut self, model: &str) -> Self {
40        self.model = model.to_string();
41        self
42    }
43
44    pub fn with_base_url(mut self, base_url: &str) -> Self {
45        self.base_url = Some(base_url.to_string());
46        self
47    }
48
49    pub fn with_temperature(mut self, temperature: f32) -> Self {
50        self.temperature = Some(temperature);
51        self
52    }
53
54    pub fn with_max_tokens(mut self, max_tokens: u32) -> Self {
55        self.max_tokens = max_tokens;
56        self
57    }
58
59    pub(crate) fn build_request(&self, context: &Context) -> Result<Request> {
60        let (system_prompt, messages) = map_messages(context.messages())?;
61        let tools = if context.tools().is_empty() { None } else { Some(map_tools(context.tools())?) };
62
63        let mut request = Request::new(self.model.clone(), messages)
64            .with_max_tokens(self.max_tokens)
65            .with_stream(true)
66            .with_auto_caching();
67
68        if let Some(temp) = self.temperature {
69            request = request.with_temperature(temp);
70        }
71
72        if let Some(system) = system_prompt {
73            request = request.with_system_cached(system);
74        }
75
76        if let Some(tools) = tools {
77            request = request.with_tools(tools);
78        }
79
80        if let Some(effort) = context.reasoning_effort() {
81            let budget_tokens = effort_to_budget_tokens(effort);
82            request = request.with_thinking(Thinking::new(budget_tokens));
83            // Anthropic requires temperature to be unset when thinking is enabled
84            request.temperature = None;
85            // max_tokens must be > budget_tokens
86            if request.max_tokens <= budget_tokens {
87                request.max_tokens = budget_tokens + 1024;
88            }
89        }
90
91        debug!("Built Anthropic request for model: {}", request.model);
92        Ok(request)
93    }
94
95    fn get_api_key(&self) -> Result<String> {
96        if let Some(key) = &self.api_key {
97            return Ok(key.clone());
98        }
99
100        if let Ok(api_key) = env::var("ANTHROPIC_API_KEY") {
101            return Ok(api_key);
102        }
103
104        Err(LlmError::MissingApiKey(
105            "No Anthropic credentials found. Set ANTHROPIC_API_KEY environment variable.".to_string(),
106        ))
107    }
108
109    fn build_headers(&self) -> Result<HeaderMap> {
110        let mut headers = HeaderMap::new();
111        headers.insert("anthropic-version", HeaderValue::from_static("2023-06-01"));
112        headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
113        let api_key = self.get_api_key()?;
114        headers.insert("x-api-key", HeaderValue::from_str(&api_key)?);
115        Ok(headers)
116    }
117
118    async fn send_request(
119        &self,
120        request: Request,
121        headers: header::HeaderMap,
122    ) -> Result<impl futures::Stream<Item = Result<String>>> {
123        let base_url = self.base_url.as_deref().unwrap_or("https://api.anthropic.com");
124        let url = format!("{base_url}/v1/messages");
125
126        debug!("Sending request to Anthropic API: {url}");
127        debug!(
128            "Anthropic request body: {}",
129            serde_json::to_string(&request).unwrap_or_else(|_| "<failed to serialize>".to_string())
130        );
131
132        debug!("Anthropic request headers: {}", format_headers(&headers));
133        let response = self.client.post(&url).headers(headers).json(&request).send().await?;
134
135        if !response.status().is_success() {
136            let status = response.status();
137            let error_text = response.text().await.unwrap_or_else(|_| "Unknown error".to_string());
138            let message = format!("Anthropic API request failed with status {status}: {error_text}");
139            return Err(match status.as_u16() {
140                429 => LlmError::RateLimited(message),
141                s if (500..600).contains(&s) => LlmError::ServerError { status: Some(s), message },
142                _ => LlmError::ApiError(message),
143            });
144        }
145
146        let event_stream = response.bytes_stream().eventsource();
147        let processed_stream = event_stream.filter_map(|result| {
148            std::future::ready(match result {
149                Ok(event) => {
150                    let data = event.data;
151                    if data == "[DONE]" { None } else { Some(Ok(data)) }
152                }
153                Err(e) => Some(Err(LlmError::StreamInterrupted(e.to_string()))),
154            })
155        });
156
157        Ok(processed_stream)
158    }
159}
160
161impl ProviderFactory for AnthropicProvider {
162    async fn from_env() -> Result<Self> {
163        Self::new(None)
164    }
165
166    fn with_model(self, model: &str) -> Self {
167        self.with_model(model)
168    }
169}
170
171impl StreamingModelProvider for AnthropicProvider {
172    fn model(&self) -> Option<crate::LlmModel> {
173        format!("anthropic:{}", self.model).parse().ok()
174    }
175
176    fn context_window(&self) -> Option<u32> {
177        get_context_window("anthropic", &self.model)
178    }
179
180    fn stream_response<'a>(&self, context: &Context) -> LlmResponseStream {
181        let provider = self.clone();
182        let context = context.clone();
183
184        Box::pin(async_stream::stream! {
185            let headers = match provider.build_headers() {
186                Ok(result) => result,
187                Err(e) => {
188                    yield Err(e);
189                    return;
190                }
191            };
192
193            let request = match provider.build_request(&context) {
194                Ok(req) => req,
195                Err(e) => {
196                    yield Err(e);
197                    return;
198                }
199            };
200
201            let stream = match provider.send_request(request, headers).await {
202                Ok(stream) => stream,
203                Err(e) => {
204                    yield Err(e);
205                    return;
206                }
207            };
208
209            let mut anthropic_stream = Box::pin(process_anthropic_stream(stream));
210            while let Some(result) = anthropic_stream.next().await {
211                yield result;
212            }
213        })
214    }
215
216    fn display_name(&self) -> String {
217        format!("Anthropic ({})", self.model)
218    }
219}
220
221fn build_client() -> Result<Client> {
222    Client::builder().timeout(Duration::from_mins(1)).build().map_err(|e| LlmError::HttpClientCreation(e.to_string()))
223}
224
225fn effort_to_budget_tokens(effort: ReasoningEffort) -> u32 {
226    match effort {
227        ReasoningEffort::Low => 1024,
228        ReasoningEffort::Medium => 4096,
229        ReasoningEffort::High | ReasoningEffort::Xhigh => 10240,
230    }
231}
232
233fn should_redact_header(name: &str) -> bool {
234    let lower = name.to_ascii_lowercase();
235    lower == "authorization" || lower == "x-api-key" || lower.contains("secret") || lower.contains("token")
236}
237
238fn format_headers(headers: &header::HeaderMap) -> String {
239    let mut parts = Vec::new();
240    for (name, value) in headers {
241        let name_str = name.as_str();
242        let value_str = if should_redact_header(name_str) {
243            "<redacted>".to_string()
244        } else {
245            value.to_str().unwrap_or("<non-utf8>").to_string()
246        };
247        parts.push(format!("{name_str}={value_str}"));
248    }
249    parts.join(", ")
250}
251
252#[cfg(test)]
253mod tests {
254    use super::*;
255    use crate::ChatMessage;
256    use crate::ContentBlock;
257    use crate::ToolDefinition;
258    use crate::providers::anthropic::types::{SystemContent, SystemContentBlock};
259    use crate::types::IsoString;
260    use reqwest::header::AUTHORIZATION;
261
262    fn create_test_provider() -> AnthropicProvider {
263        AnthropicProvider::new(Some("test-api-key".to_string()))
264            .unwrap()
265            .with_model("claude-sonnet-4-5-20250929")
266            .with_temperature(0.7)
267            .with_max_tokens(1000)
268    }
269
270    #[test]
271    fn test_provider_creation() {
272        let provider = AnthropicProvider::new(Some("test-api-key".to_string()));
273        assert!(provider.is_ok());
274    }
275
276    #[test]
277    fn build_headers_uses_api_key() {
278        let provider = AnthropicProvider::new(Some("test-api-key".to_string())).unwrap();
279        let headers = provider.build_headers().expect("headers");
280        assert_eq!(headers.get("x-api-key").and_then(|value| value.to_str().ok()), Some("test-api-key"));
281        assert!(headers.get(AUTHORIZATION).is_none());
282        assert!(headers.get("anthropic-beta").is_none());
283    }
284
285    #[test]
286    fn test_build_request_simple() {
287        let provider = create_test_provider();
288
289        let context = Context::new(
290            vec![ChatMessage::User { content: vec![ContentBlock::text("Hello")], timestamp: IsoString::now() }],
291            vec![],
292        );
293
294        let request = provider.build_request(&context).unwrap();
295        assert_eq!(request.model, "claude-sonnet-4-5-20250929");
296        assert_eq!(request.max_tokens, 1000);
297        assert_eq!(request.messages.len(), 1);
298        assert!(request.tools.is_none());
299        assert!(request.stream);
300    }
301
302    #[test]
303    fn test_build_request_with_system_and_tools() {
304        let provider = create_test_provider();
305
306        let context = Context::new(
307            vec![
308                ChatMessage::System { content: "You are helpful".to_string(), timestamp: IsoString::now() },
309                ChatMessage::User { content: vec![ContentBlock::text("Hello")], timestamp: IsoString::now() },
310            ],
311            vec![ToolDefinition {
312                name: "search".to_string(),
313                description: "Search for information".to_string(),
314                parameters: r#"{"type": "object", "properties": {"query": {"type": "string"}}}"#.to_string(),
315                server: None,
316            }],
317        );
318
319        let request = provider.build_request(&context).unwrap();
320        if let Some(system) = &request.system {
321            match system {
322                SystemContent::Blocks(blocks) => {
323                    assert_eq!(blocks.len(), 1);
324                    let SystemContentBlock::Text { text, .. } = &blocks[0];
325                    assert_eq!(text, "You are helpful");
326                }
327                SystemContent::Text(_) => panic!("Expected blocks system content"),
328            }
329        } else {
330            panic!("Expected system prompt");
331        }
332        assert_eq!(request.messages.len(), 1);
333        assert!(request.tools.is_some());
334        assert_eq!(request.tools.unwrap().len(), 1);
335    }
336
337    #[test]
338    fn test_build_request_with_caching() {
339        let provider = AnthropicProvider::new(Some("test-api-key".to_string())).unwrap(); // Caching is enabled by default
340
341        let context = Context::new(
342            vec![
343                ChatMessage::System { content: "Hello".to_string(), timestamp: IsoString::now() },
344                ChatMessage::User { content: vec![ContentBlock::text("Hello")], timestamp: IsoString::now() },
345            ],
346            vec![ToolDefinition {
347                name: "search".to_string(),
348                description: "Search for information".to_string(),
349                parameters: r#"{"type": "object", "properties": {"query": {"type": "string"}}}"#.to_string(),
350                server: None,
351            }],
352        );
353
354        let request = provider.build_request(&context).unwrap();
355
356        // With caching enabled, system prompt should be cached
357        if let Some(system) = &request.system {
358            match system {
359                SystemContent::Blocks(blocks) => {
360                    assert_eq!(blocks.len(), 1);
361                    let SystemContentBlock::Text { text, cache_control } = &blocks[0];
362                    assert_eq!(text, "Hello");
363                    assert!(cache_control.is_some());
364                }
365                SystemContent::Text(_) => panic!("Expected blocks system content for caching"),
366            }
367        } else {
368            panic!("Expected system prompt");
369        }
370
371        assert!(request.tools.is_some());
372
373        // Top-level cache_control enables automatic caching
374        assert!(request.cache_control.is_some());
375    }
376
377    #[test]
378    fn test_build_request_with_reasoning_effort() {
379        let provider = create_test_provider();
380
381        let mut context = Context::new(
382            vec![ChatMessage::User { content: vec![ContentBlock::text("Think hard")], timestamp: IsoString::now() }],
383            vec![],
384        );
385        context.set_reasoning_effort(Some(crate::ReasoningEffort::High));
386
387        let request = provider.build_request(&context).unwrap();
388        let thinking = request.thinking.expect("thinking should be set");
389        assert_eq!(thinking.thinking_type, "enabled");
390        assert_eq!(thinking.budget_tokens, 10240);
391        // Temperature must be unset when thinking is enabled
392        assert!(request.temperature.is_none());
393        // max_tokens must exceed budget_tokens
394        assert!(request.max_tokens > thinking.budget_tokens);
395    }
396
397    #[test]
398    fn test_build_request_without_reasoning_effort_has_no_thinking() {
399        let provider = create_test_provider();
400        let context = Context::new(
401            vec![ChatMessage::User { content: vec![ContentBlock::text("Hello")], timestamp: IsoString::now() }],
402            vec![],
403        );
404
405        let request = provider.build_request(&context).unwrap();
406        assert!(request.thinking.is_none());
407    }
408
409    #[test]
410    fn test_build_request_thinking_bumps_max_tokens_if_needed() {
411        let provider = AnthropicProvider::new(Some("test-api-key".to_string())).unwrap().with_max_tokens(500);
412
413        let mut context = Context::new(
414            vec![ChatMessage::User { content: vec![ContentBlock::text("Hi")], timestamp: IsoString::now() }],
415            vec![],
416        );
417        context.set_reasoning_effort(Some(crate::ReasoningEffort::Low));
418
419        let request = provider.build_request(&context).unwrap();
420        let thinking = request.thinking.as_ref().unwrap();
421        assert!(
422            request.max_tokens > thinking.budget_tokens,
423            "max_tokens ({}) should exceed budget_tokens ({})",
424            request.max_tokens,
425            thinking.budget_tokens
426        );
427    }
428
429    #[test]
430    fn test_anthropic_provider_display_name() {
431        let provider = create_test_provider();
432        assert_eq!(provider.display_name(), "Anthropic (claude-sonnet-4-5-20250929)");
433    }
434
435    #[test]
436    fn test_anthropic_provider_display_name_default() {
437        let provider = AnthropicProvider::new(Some("test-api-key".to_string())).unwrap();
438        assert_eq!(provider.display_name(), "Anthropic (claude-sonnet-4-5-20250929)");
439    }
440
441    #[test]
442    fn format_headers_redacts_x_api_key() {
443        let mut headers = HeaderMap::new();
444        headers.insert("x-api-key", HeaderValue::from_static("sk-secret-123"));
445        headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
446
447        let formatted = format_headers(&headers);
448        assert!(formatted.contains("x-api-key=<redacted>"));
449        assert!(formatted.contains("content-type=application/json"));
450        assert!(!formatted.contains("sk-secret-123"));
451    }
452
453    #[test]
454    fn format_headers_redacts_authorization() {
455        let mut headers = HeaderMap::new();
456        headers.insert(AUTHORIZATION, HeaderValue::from_static("Bearer token123"));
457
458        let formatted = format_headers(&headers);
459        assert!(formatted.contains("authorization=<redacted>"));
460        assert!(!formatted.contains("token123"));
461    }
462
463    #[test]
464    fn format_headers_redacts_secret_and_token_headers() {
465        let mut headers = HeaderMap::new();
466        headers.insert("x-client-secret", HeaderValue::from_static("mysecret"));
467        headers.insert("x-auth-token", HeaderValue::from_static("mytoken"));
468        headers.insert("accept", HeaderValue::from_static("text/plain"));
469
470        let formatted = format_headers(&headers);
471        assert!(formatted.contains("x-client-secret=<redacted>"));
472        assert!(formatted.contains("x-auth-token=<redacted>"));
473        assert!(formatted.contains("accept=text/plain"));
474        assert!(!formatted.contains("mysecret"));
475        assert!(!formatted.contains("mytoken"));
476    }
477}
llm/providers/anthropic/provider.rs

llm/providers/anthropic/
provider.rs
