feat:(first commit)created repository and complete 0.1.0

src/llm/anthropic.rs

@@ -0,0 +1,227 @@
+use super::{create_http_client, LlmProvider};
+use anyhow::{bail, Context, Result};
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+use std::time::Duration;
+
+/// Anthropic Claude API client
+pub struct AnthropicClient {
+    api_key: String,
+    model: String,
+    client: reqwest::Client,
+}
+
+#[derive(Debug, Serialize)]
+struct MessagesRequest {
+    model: String,
+    max_tokens: u32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    temperature: Option<f32>,
+    messages: Vec<AnthropicMessage>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    system: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct AnthropicMessage {
+    role: String,
+    content: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct MessagesResponse {
+    content: Vec<ContentBlock>,
+}
+
+#[derive(Debug, Deserialize)]
+struct ContentBlock {
+    #[serde(rename = "type")]
+    content_type: String,
+    text: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct ErrorResponse {
+    error: AnthropicError,
+}
+
+#[derive(Debug, Deserialize)]
+struct AnthropicError {
+    #[serde(rename = "type")]
+    error_type: String,
+    message: String,
+}
+
+impl AnthropicClient {
+    /// Create new Anthropic client
+    pub fn new(api_key: &str, model: &str) -> Result<Self> {
+        let client = create_http_client(Duration::from_secs(60))?;
+        
+        Ok(Self {
+            api_key: api_key.to_string(),
+            model: model.to_string(),
+            client,
+        })
+    }
+
+    /// Set timeout
+    pub fn with_timeout(mut self, timeout: Duration) -> Result<Self> {
+        self.client = create_http_client(timeout)?;
+        Ok(self)
+    }
+
+    /// Validate API key
+    pub async fn validate_key(&self) -> Result<bool> {
+        let url = "https://api.anthropic.com/v1/messages";
+        
+        let request = MessagesRequest {
+            model: self.model.clone(),
+            max_tokens: 5,
+            temperature: Some(0.0),
+            messages: vec![AnthropicMessage {
+                role: "user".to_string(),
+                content: "Hi".to_string(),
+            }],
+            system: None,
+        };
+        
+        let response = self.client
+            .post(url)
+            .header("x-api-key", &self.api_key)
+            .header("anthropic-version", "2023-06-01")
+            .header("Content-Type", "application/json")
+            .json(&request)
+            .send()
+            .await;
+        
+        match response {
+            Ok(resp) => {
+                if resp.status().is_success() {
+                    Ok(true)
+                } else {
+                    let status = resp.status();
+                    if status.as_u16() == 401 {
+                        Ok(false)
+                    } else {
+                        let text = resp.text().await.unwrap_or_default();
+                        bail!("Anthropic API error: {} - {}", status, text)
+                    }
+                }
+            }
+            Err(e) => Err(e.into()),
+        }
+    }
+}
+
+#[async_trait]
+impl LlmProvider for AnthropicClient {
+    async fn generate(&self, prompt: &str) -> Result<String> {
+        let messages = vec![AnthropicMessage {
+            role: "user".to_string(),
+            content: prompt.to_string(),
+        }];
+        
+        self.messages_request(messages, None).await
+    }
+
+    async fn generate_with_system(&self, system: &str, user: &str) -> Result<String> {
+        let messages = vec![AnthropicMessage {
+            role: "user".to_string(),
+            content: user.to_string(),
+        }];
+        
+        let system = if system.is_empty() {
+            None
+        } else {
+            Some(system.to_string())
+        };
+        
+        self.messages_request(messages, system).await
+    }
+
+    async fn is_available(&self) -> bool {
+        self.validate_key().await.unwrap_or(false)
+    }
+
+    fn name(&self) -> &str {
+        "anthropic"
+    }
+}
+
+impl AnthropicClient {
+    async fn messages_request(
+        &self,
+        messages: Vec<AnthropicMessage>,
+        system: Option<String>,
+    ) -> Result<String> {
+        let url = "https://api.anthropic.com/v1/messages";
+        
+        let request = MessagesRequest {
+            model: self.model.clone(),
+            max_tokens: 500,
+            temperature: Some(0.7),
+            messages,
+            system,
+        };
+        
+        let response = self.client
+            .post(url)
+            .header("x-api-key", &self.api_key)
+            .header("anthropic-version", "2023-06-01")
+            .header("Content-Type", "application/json")
+            .json(&request)
+            .send()
+            .await
+            .context("Failed to send request to Anthropic")?;
+        
+        let status = response.status();
+        
+        if !status.is_success() {
+            let text = response.text().await.unwrap_or_default();
+            
+            // Try to parse error
+            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
+                bail!("Anthropic API error: {} ({})", error.error.message, error.error.error_type);
+            }
+            
+            bail!("Anthropic API error: {} - {}", status, text);
+        }
+        
+        let result: MessagesResponse = response
+            .json()
+            .await
+            .context("Failed to parse Anthropic response")?;
+        
+        result.content
+            .into_iter()
+            .find(|c| c.content_type == "text")
+            .map(|c| c.text.trim().to_string())
+            .ok_or_else(|| anyhow::anyhow!("No text response from Anthropic"))
+    }
+}
+
+/// Available Anthropic models
+pub const ANTHROPIC_MODELS: &[&str] = &[
+    "claude-3-opus-20240229",
+    "claude-3-sonnet-20240229",
+    "claude-3-haiku-20240307",
+    "claude-2.1",
+    "claude-2.0",
+    "claude-instant-1.2",
+];
+
+/// Check if a model name is valid
+pub fn is_valid_model(model: &str) -> bool {
+    ANTHROPIC_MODELS.contains(&model)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_model_validation() {
+        assert!(is_valid_model("claude-3-sonnet-20240229"));
+        assert!(!is_valid_model("invalid-model"));
+    }
+}