llm/providers/openrouter/
provider.rs

1use super::types::OpenRouterChatRequest;
2use crate::provider::{error_stream, get_context_window};
3use crate::providers::http::openai_client;
4use crate::providers::openai_compatible::{
5    AetherOpenAiConfig, build_chat_request, streaming::create_custom_stream_generic,
6};
7use crate::{
8    Context, LlmError, LlmResponseStream, ProviderAuthMode, ProviderConnectionConfig, ProviderFactory, Result,
9    StreamingModelProvider,
10};
11use async_openai::{Client, config::OpenAIConfig};
12use std::future::ready;
13
14pub struct OpenRouterProvider {
15    client: Client<AetherOpenAiConfig>,
16    model: String,
17}
18
19impl OpenRouterProvider {
20    pub fn new(api_key: String, model: String) -> Result<Self> {
21        let config = openai_config(Some(api_key), ProviderConnectionConfig::default());
22
23        let client = openai_client(config, reqwest::Client::new());
24        Ok(Self { client, model })
25    }
26
27    pub fn default(model: &str) -> Result<Self> {
28        let api_key = std::env::var("OPENROUTER_API_KEY")
29            .map_err(|_| LlmError::MissingApiKey("OPENROUTER_API_KEY".to_string()))?;
30
31        Self::new(api_key, model.to_string())
32    }
33}
34
35impl ProviderFactory for OpenRouterProvider {
36    async fn from_env() -> Result<Self> {
37        Self::from_env_with_connection(ProviderConnectionConfig::default()).await
38    }
39
40    fn from_env_with_connection(connection: ProviderConnectionConfig) -> impl Future<Output = Result<Self>> + Send {
41        ready(provider_from_connection(connection))
42    }
43
44    fn with_model(mut self, model: &str) -> Self {
45        self.model = model.to_string();
46        self
47    }
48}
49
50impl StreamingModelProvider for OpenRouterProvider {
51    fn model(&self) -> Option<crate::LlmModel> {
52        format!("openrouter:{}", self.model).parse().ok()
53    }
54
55    fn context_window(&self) -> Option<u32> {
56        get_context_window("openrouter", &self.model)
57    }
58
59    fn stream_response(&self, context: &Context) -> LlmResponseStream {
60        let mut request = match build_chat_request(&self.model, context, None) {
61            Ok(request) => request,
62            Err(e) => return error_stream(e),
63        };
64        request.prompt_cache_key = context.prompt_cache_key().map(String::from);
65        let request = OpenRouterChatRequest::from_compatible(request, context.session_affinity_key());
66
67        create_custom_stream_generic(&self.client, request)
68    }
69
70    fn display_name(&self) -> String {
71        format!("OpenRouter ({})", self.model)
72    }
73}
74
75fn openai_config(api_key: Option<String>, connection: ProviderConnectionConfig) -> AetherOpenAiConfig {
76    let api_key = api_key.unwrap_or_default();
77    let api_base = connection.base_url.unwrap_or_else(|| "https://openrouter.ai/api/v1".to_string());
78    let config = OpenAIConfig::new().with_api_key(api_key).with_api_base(api_base);
79    AetherOpenAiConfig::new(config, connection.auth_mode)
80}
81
82fn provider_from_connection(connection: ProviderConnectionConfig) -> Result<OpenRouterProvider> {
83    let api_key = match connection.auth_mode {
84        ProviderAuthMode::Default => Some(
85            std::env::var("OPENROUTER_API_KEY")
86                .map_err(|_| LlmError::MissingApiKey("OPENROUTER_API_KEY".to_string()))?,
87        ),
88        ProviderAuthMode::None => None,
89    };
90    let config = openai_config(api_key, connection);
91    let client = openai_client(config, reqwest::Client::new());
92
93    Ok(OpenRouterProvider { client, model: String::new() })
94}
95
96#[cfg(test)]
97mod tests {
98    use futures::{StreamExt, stream};
99    use reqwest::{Body, Method};
100
101    use super::*;
102    use crate::testing::FakeHttpService;
103    use crate::{ChatMessage, LlmResponse, ProviderErrorKind};
104
105    #[tokio::test]
106    async fn stream_response_propagates_prompt_cache_key_and_keeps_cache_control() {
107        let service = FakeHttpService::default();
108        service.route(Method::POST, OPENROUTER_URL, || response(200, OPENROUTER_FIXTURE));
109        let provider = provider_with_service(&service).with_model("anthropic/claude-haiku-4.5");
110        let mut context = Context::new(vec![ChatMessage::user("Hello")], vec![]);
111        context.set_prompt_cache_key(Some("prefix-abc".to_string()));
112        context.set_session_affinity_key(Some("conversation-abc".to_string()));
113        context.set_reasoning_effort(Some(crate::ReasoningEffort::High));
114
115        let responses = provider.stream_response(&context).collect::<Vec<_>>().await;
116        let body = request_bodies(&service).pop().unwrap();
117
118        assert!(responses.iter().all(Result::is_ok), "{responses:?}");
119        assert!(responses.iter().any(|response| matches!(response, Ok(LlmResponse::Done { .. }))));
120        assert_eq!(body["model"], "anthropic/claude-haiku-4.5");
121        assert_eq!(body["prompt_cache_key"], "prefix-abc");
122        assert_eq!(body["session_id"], "conversation-abc");
123        assert_eq!(body["reasoning_effort"], "high");
124        assert_eq!(body["cache_control"]["type"], "ephemeral");
125        assert_eq!(body["usage"]["include"], true);
126    }
127
128    #[tokio::test]
129    async fn openrouter_rate_limit_response_is_a_retryable_provider_error() {
130        let body = r#"{"error":{"message":"Rate limit exceeded: free-models-per-day. Add 10 credits to unlock 1000 free model requests per day","code":429}}"#;
131        let error = rejected_request(429, body).await;
132        let provider_error = error.provider().expect("a 429 must classify as a provider error");
133
134        assert_eq!(provider_error.kind, ProviderErrorKind::RateLimit);
135        assert_eq!(provider_error.http_status, Some(429));
136        assert_eq!(provider_error.code.as_deref(), Some("429"));
137        assert_eq!(provider_error.request_id.as_deref(), Some("request-123"));
138        assert!(provider_error.message.contains("free-models-per-day"));
139        assert!(error.is_retryable(), "429 must be retryable, got {error}");
140    }
141
142    #[tokio::test]
143    async fn string_error_codes_are_preserved() {
144        let error = rejected_request(429, r#"{"error":{"code":"rate_limit_exceeded","message":"slow down"}}"#).await;
145        let provider_error = error.provider().unwrap();
146
147        assert_eq!(provider_error.code.as_deref(), Some("rate_limit_exceeded"));
148        assert!(provider_error.message.contains("slow down"));
149        assert!(error.is_retryable());
150    }
151
152    #[tokio::test]
153    async fn http_status_is_preserved_when_error_body_read_fails() {
154        let service = FakeHttpService::default();
155        service.route(Method::POST, OPENROUTER_URL, || {
156            let body = stream::iter([Err::<String, _>(std::io::Error::other("connection reset"))]);
157            response(429, Body::wrap_stream(body))
158        });
159        let error = collect_rejection(&provider_with_service(&service)).await;
160        let provider_error = error.provider().unwrap();
161
162        assert_eq!(provider_error.http_status, Some(429));
163        assert_eq!(provider_error.request_id.as_deref(), Some("request-123"));
164        assert_eq!(provider_error.kind, ProviderErrorKind::RateLimit);
165        assert!(error.is_retryable());
166    }
167
168    const OPENROUTER_URL: &str = "https://openrouter.ai/api/v1/chat/completions";
169    const OPENROUTER_FIXTURE: &str = include_str!("../../../tests/fixtures/openrouter/01_minimal.sse");
170
171    fn provider_with_service(service: &FakeHttpService) -> OpenRouterProvider {
172        let config = openai_config(Some("test-key".into()), ProviderConnectionConfig::default());
173        let client = openai_client(config, service.clone());
174        OpenRouterProvider { client, model: "test-model".into() }
175    }
176
177    fn response(status: u16, body: impl Into<Body>) -> reqwest::Response {
178        http::Response::builder()
179            .status(status)
180            .header("content-type", "text/event-stream")
181            .header("x-request-id", "request-123")
182            .body(body.into())
183            .unwrap()
184            .into()
185    }
186
187    fn request_bodies(service: &FakeHttpService) -> Vec<serde_json::Value> {
188        service
189            .take_requests()
190            .iter()
191            .map(|request| serde_json::from_slice(request.body().unwrap().as_bytes().unwrap()).unwrap())
192            .collect()
193    }
194
195    async fn rejected_request(status: u16, body: &str) -> LlmError {
196        let service = FakeHttpService::default();
197        let body = body.to_string();
198        service.route(Method::POST, OPENROUTER_URL, move || response(status, body.clone()));
199        collect_rejection(&provider_with_service(&service)).await
200    }
201
202    async fn collect_rejection(provider: &OpenRouterProvider) -> LlmError {
203        let context = Context::new(vec![ChatMessage::user("Hello")], vec![]);
204        let mut events = provider.stream_response(&context).collect::<Vec<_>>().await;
205        assert_eq!(events.len(), 1, "a rejected request must yield exactly one error: {events:?}");
206        events.pop().unwrap().expect_err("request must fail")
207    }
208}
llm/providers/openrouter/provider.rs

llm/providers/openrouter/
provider.rs
