mermaid_cli/providers/model/
anthropic.rs

1//! Anthropic provider — wraps `models::adapters::anthropic::AnthropicAdapter`.
2//!
3//! Same pattern as `ollama.rs`: the adapter handles the wire format
4//! (cache_control blocks, extended-thinking signature round-trip);
5//! this wrapper plumbs `ChatRequest` / `StreamContext` into it.
6//!
7//! Anthropic is the one provider that emits a `thinking_signature`
8//! that MUST round-trip on the next request. The adapter's
9//! `ModelResponse.thinking_signature` already carries it; we forward
10//! that onto the `FinalResponse` so the reducer can commit it via
11//! `ChatMessage::with_thinking_signature`.
12
13use std::sync::Arc;
14
15use async_trait::async_trait;
16
17use crate::domain::ChatRequest;
18use crate::models::adapters::anthropic::AnthropicAdapter;
19use crate::models::{
20    Model, ModelConfig, ModelError, ReasoningChunk, Result, StreamCallback,
21    StreamEvent as ModelStreamEvent,
22};
23
24use super::super::capabilities::Capabilities;
25use super::super::ctx::{FinalResponse, StreamContext, StreamEvent};
26use super::ModelProvider;
27
28/// Anthropic adapter fronted by `ModelProvider`.
29pub struct AnthropicProvider {
30    adapter: AnthropicAdapter,
31    capabilities: Capabilities,
32}
33
34impl AnthropicProvider {
35    pub fn new(api_key: String, model_name: String, base_url: String) -> Result<Self> {
36        let adapter = AnthropicAdapter::new(api_key, model_name, base_url)?;
37        let capabilities =
38            Capabilities::from_legacy(adapter.capabilities()).with_thinking_signature();
39        Ok(Self {
40            adapter,
41            capabilities,
42        })
43    }
44}
45
46#[async_trait]
47impl ModelProvider for AnthropicProvider {
48    fn capabilities(&self) -> &Capabilities {
49        &self.capabilities
50    }
51
52    async fn chat(&self, request: ChatRequest, ctx: StreamContext) -> Result<FinalResponse> {
53        let config = build_model_config(&request);
54        // F2: ordered relay — see stream_bridge docs.
55        let relay_tx = super::stream_bridge::ordered_relay(ctx.sink.clone());
56        let callback = forward_callback(relay_tx);
57        let chat_fut = self
58            .adapter
59            .chat(&request.messages, &config, Some(callback));
60
61        let response = tokio::select! {
62            biased;
63            _ = ctx.token.cancelled() => {
64                return Err(ModelError::Cancelled);
65            },
66            r = chat_fut => r?,
67        };
68
69        let usage = response.usage.clone();
70        let thinking_signature = response.thinking_signature.clone();
71        let _ = ctx
72            .sink
73            .send(StreamEvent::Done {
74                usage: usage.clone(),
75                thinking_signature: thinking_signature.clone(),
76            })
77            .await;
78
79        Ok(FinalResponse {
80            usage,
81            thinking_signature,
82            tool_calls: response.tool_calls.unwrap_or_default(),
83        })
84    }
85}
86
87fn build_model_config(request: &ChatRequest) -> ModelConfig {
88    ModelConfig {
89        model: request.model_id.clone(),
90        temperature: request.temperature,
91        max_tokens: request.max_tokens,
92        reasoning: request.reasoning,
93        system_prompt: Some(request.system_prompt.clone()),
94        dynamic_system_suffix: request.instructions.clone(),
95        tools: request.tools.iter().map(|t| t.to_openai_json()).collect(),
96        ..Default::default()
97    }
98}
99
100fn forward_callback(sink: tokio::sync::mpsc::UnboundedSender<StreamEvent>) -> StreamCallback {
101    Arc::new(move |event: ModelStreamEvent| {
102        let mapped = match event {
103            ModelStreamEvent::Text(s) => StreamEvent::Text(s),
104            ModelStreamEvent::Reasoning(chunk) => StreamEvent::Reasoning(ReasoningChunk {
105                text: chunk.text,
106                signature: chunk.signature,
107            }),
108            ModelStreamEvent::ToolCall(tc) => StreamEvent::ToolCall(tc),
109            ModelStreamEvent::Done { tokens } => StreamEvent::Done {
110                usage: if tokens > 0 {
111                    Some(crate::models::TokenUsage::provider(0, tokens, tokens))
112                } else {
113                    None
114                },
115                thinking_signature: None,
116            },
117        };
118        let _ = sink.send(mapped);
119    })
120}
121
122#[cfg(test)]
123mod tests {
124    use super::*;
125
126    #[test]
127    fn build_model_config_maps_fields() {
128        let req = ChatRequest {
129            model_id: "anthropic/claude-opus-4-7".to_string(),
130            messages: vec![],
131            system_prompt: "sys".to_string(),
132            instructions: Some("MERMAID.md content".to_string()),
133            reasoning: crate::models::ReasoningLevel::XHigh,
134            temperature: 0.7,
135            max_tokens: 8192,
136            tools: vec![],
137        };
138        let cfg = build_model_config(&req);
139        assert_eq!(cfg.reasoning, crate::models::ReasoningLevel::XHigh);
140        assert_eq!(cfg.max_tokens, 8192);
141        assert_eq!(
142            cfg.dynamic_system_suffix.as_deref(),
143            Some("MERMAID.md content")
144        );
145    }
146}
mermaid_cli/providers/model/anthropic.rs

mermaid_cli/providers/model/
anthropic.rs
