Edvard
cc13fec16d
The first API request after daemon startup consistently timed out (120s) when using channels (Telegram, Discord, etc.), requiring a retry before succeeding. This happened because the reqwest HTTP client's connection pool was cold — no TLS handshake, DNS resolution, or HTTP/2 negotiation had occurred yet. The fix adds a `warmup()` method to the Provider trait that establishes the connection pool on startup by hitting a lightweight endpoint (`/api/v1/auth/key` for OpenRouter). The channel server calls this immediately after creating the provider, before entering the message processing loop. Tested on Raspberry Pi 5 (aarch64) with OpenRouter + DeepSeek v3.2 via Telegram channel. Before: first message took 2-7 minutes (120s timeout + retries). After: first message responds in <30s with no retries. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
128 lines
3.3 KiB
Rust
128 lines
3.3 KiB
Rust
use crate::providers::traits::Provider;
|
|
use async_trait::async_trait;
|
|
use reqwest::Client;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
pub struct OpenRouterProvider {
|
|
api_key: Option<String>,
|
|
client: Client,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
struct ChatRequest {
|
|
model: String,
|
|
messages: Vec<Message>,
|
|
temperature: f64,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
struct Message {
|
|
role: String,
|
|
content: String,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct ChatResponse {
|
|
choices: Vec<Choice>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct Choice {
|
|
message: ResponseMessage,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct ResponseMessage {
|
|
content: String,
|
|
}
|
|
|
|
impl OpenRouterProvider {
|
|
pub fn new(api_key: Option<&str>) -> Self {
|
|
Self {
|
|
api_key: api_key.map(ToString::to_string),
|
|
client: Client::builder()
|
|
.timeout(std::time::Duration::from_secs(120))
|
|
.connect_timeout(std::time::Duration::from_secs(10))
|
|
.build()
|
|
.unwrap_or_else(|_| Client::new()),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl Provider for OpenRouterProvider {
|
|
async fn warmup(&self) -> anyhow::Result<()> {
|
|
// Hit a lightweight endpoint to establish TLS + HTTP/2 connection pool.
|
|
// This prevents the first real chat request from timing out on cold start.
|
|
let api_key = self
|
|
.api_key
|
|
.as_ref()
|
|
.ok_or_else(|| anyhow::anyhow!("No API key for warmup"))?;
|
|
let _ = self
|
|
.client
|
|
.get("https://openrouter.ai/api/v1/auth/key")
|
|
.header("Authorization", format!("Bearer {api_key}"))
|
|
.send()
|
|
.await;
|
|
Ok(())
|
|
}
|
|
|
|
async fn chat_with_system(
|
|
&self,
|
|
system_prompt: Option<&str>,
|
|
message: &str,
|
|
model: &str,
|
|
temperature: f64,
|
|
) -> anyhow::Result<String> {
|
|
let api_key = self.api_key.as_ref()
|
|
.ok_or_else(|| anyhow::anyhow!("OpenRouter API key not set. Run `zeroclaw onboard` or set OPENROUTER_API_KEY env var."))?;
|
|
|
|
let mut messages = Vec::new();
|
|
|
|
if let Some(sys) = system_prompt {
|
|
messages.push(Message {
|
|
role: "system".to_string(),
|
|
content: sys.to_string(),
|
|
});
|
|
}
|
|
|
|
messages.push(Message {
|
|
role: "user".to_string(),
|
|
content: message.to_string(),
|
|
});
|
|
|
|
let request = ChatRequest {
|
|
model: model.to_string(),
|
|
messages,
|
|
temperature,
|
|
};
|
|
|
|
let response = self
|
|
.client
|
|
.post("https://openrouter.ai/api/v1/chat/completions")
|
|
.header("Authorization", format!("Bearer {api_key}"))
|
|
.header(
|
|
"HTTP-Referer",
|
|
"https://github.com/theonlyhennygod/zeroclaw",
|
|
)
|
|
.header("X-Title", "ZeroClaw")
|
|
.json(&request)
|
|
.send()
|
|
.await?;
|
|
|
|
if !response.status().is_success() {
|
|
let error = response.text().await?;
|
|
anyhow::bail!("OpenRouter API error: {error}");
|
|
}
|
|
|
|
let chat_response: ChatResponse = response.json().await?;
|
|
|
|
chat_response
|
|
.choices
|
|
.into_iter()
|
|
.next()
|
|
.map(|c| c.message.content)
|
|
.ok_or_else(|| anyhow::anyhow!("No response from OpenRouter"))
|
|
}
|
|
}
|