feat: initial release — ZeroClaw v0.1.0

- 22 AI providers (OpenRouter, Anthropic, OpenAI, Mistral, etc.)
- 7 channels (CLI, Telegram, Discord, Slack, iMessage, Matrix, Webhook)
- 5-step onboarding wizard with Project Context personalization
- OpenClaw-aligned system prompt (SOUL.md, IDENTITY.md, USER.md, AGENTS.md, etc.)
- SQLite memory backend with auto-save
- Skills system with on-demand loading
- Security: autonomy levels, command allowlists, cost limits
- 532 tests passing, 0 clippy warnings

src/providers/anthropic.rs

@@ -0,0 +1,212 @@
+use crate::providers::traits::Provider;
+use async_trait::async_trait;
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+
+pub struct AnthropicProvider {
+    api_key: Option<String>,
+    client: Client,
+}
+
+#[derive(Debug, Serialize)]
+struct ChatRequest {
+    model: String,
+    max_tokens: u32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    system: Option<String>,
+    messages: Vec<Message>,
+    temperature: f64,
+}
+
+#[derive(Debug, Serialize)]
+struct Message {
+    role: String,
+    content: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct ChatResponse {
+    content: Vec<ContentBlock>,
+}
+
+#[derive(Debug, Deserialize)]
+struct ContentBlock {
+    text: String,
+}
+
+impl AnthropicProvider {
+    pub fn new(api_key: Option<&str>) -> Self {
+        Self {
+            api_key: api_key.map(ToString::to_string),
+            client: Client::new(),
+        }
+    }
+}
+
+#[async_trait]
+impl Provider for AnthropicProvider {
+    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!(
+                "Anthropic API key not set. Set ANTHROPIC_API_KEY or edit config.toml."
+            )
+        })?;
+
+        let request = ChatRequest {
+            model: model.to_string(),
+            max_tokens: 4096,
+            system: system_prompt.map(ToString::to_string),
+            messages: vec![Message {
+                role: "user".to_string(),
+                content: message.to_string(),
+            }],
+            temperature,
+        };
+
+        let response = self
+            .client
+            .post("https://api.anthropic.com/v1/messages")
+            .header("x-api-key", api_key)
+            .header("anthropic-version", "2023-06-01")
+            .header("content-type", "application/json")
+            .json(&request)
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            let error = response.text().await?;
+            anyhow::bail!("Anthropic API error: {error}");
+        }
+
+        let chat_response: ChatResponse = response.json().await?;
+
+        chat_response
+            .content
+            .into_iter()
+            .next()
+            .map(|c| c.text)
+            .ok_or_else(|| anyhow::anyhow!("No response from Anthropic"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn creates_with_key() {
+        let p = AnthropicProvider::new(Some("sk-ant-test123"));
+        assert!(p.api_key.is_some());
+        assert_eq!(p.api_key.as_deref(), Some("sk-ant-test123"));
+    }
+
+    #[test]
+    fn creates_without_key() {
+        let p = AnthropicProvider::new(None);
+        assert!(p.api_key.is_none());
+    }
+
+    #[test]
+    fn creates_with_empty_key() {
+        let p = AnthropicProvider::new(Some(""));
+        assert!(p.api_key.is_some());
+        assert_eq!(p.api_key.as_deref(), Some(""));
+    }
+
+    #[tokio::test]
+    async fn chat_fails_without_key() {
+        let p = AnthropicProvider::new(None);
+        let result = p.chat_with_system(None, "hello", "claude-3-opus", 0.7).await;
+        assert!(result.is_err());
+        let err = result.unwrap_err().to_string();
+        assert!(err.contains("API key not set"), "Expected key error, got: {err}");
+    }
+
+    #[tokio::test]
+    async fn chat_with_system_fails_without_key() {
+        let p = AnthropicProvider::new(None);
+        let result = p
+            .chat_with_system(Some("You are ZeroClaw"), "hello", "claude-3-opus", 0.7)
+            .await;
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn chat_request_serializes_without_system() {
+        let req = ChatRequest {
+            model: "claude-3-opus".to_string(),
+            max_tokens: 4096,
+            system: None,
+            messages: vec![Message {
+                role: "user".to_string(),
+                content: "hello".to_string(),
+            }],
+            temperature: 0.7,
+        };
+        let json = serde_json::to_string(&req).unwrap();
+        assert!(!json.contains("system"), "system field should be skipped when None");
+        assert!(json.contains("claude-3-opus"));
+        assert!(json.contains("hello"));
+    }
+
+    #[test]
+    fn chat_request_serializes_with_system() {
+        let req = ChatRequest {
+            model: "claude-3-opus".to_string(),
+            max_tokens: 4096,
+            system: Some("You are ZeroClaw".to_string()),
+            messages: vec![Message {
+                role: "user".to_string(),
+                content: "hello".to_string(),
+            }],
+            temperature: 0.7,
+        };
+        let json = serde_json::to_string(&req).unwrap();
+        assert!(json.contains("\"system\":\"You are ZeroClaw\""));
+    }
+
+    #[test]
+    fn chat_response_deserializes() {
+        let json = r#"{"content":[{"type":"text","text":"Hello there!"}]}"#;
+        let resp: ChatResponse = serde_json::from_str(json).unwrap();
+        assert_eq!(resp.content.len(), 1);
+        assert_eq!(resp.content[0].text, "Hello there!");
+    }
+
+    #[test]
+    fn chat_response_empty_content() {
+        let json = r#"{"content":[]}"#;
+        let resp: ChatResponse = serde_json::from_str(json).unwrap();
+        assert!(resp.content.is_empty());
+    }
+
+    #[test]
+    fn chat_response_multiple_blocks() {
+        let json = r#"{"content":[{"type":"text","text":"First"},{"type":"text","text":"Second"}]}"#;
+        let resp: ChatResponse = serde_json::from_str(json).unwrap();
+        assert_eq!(resp.content.len(), 2);
+        assert_eq!(resp.content[0].text, "First");
+        assert_eq!(resp.content[1].text, "Second");
+    }
+
+    #[test]
+    fn temperature_range_serializes() {
+        for temp in [0.0, 0.5, 1.0, 2.0] {
+            let req = ChatRequest {
+                model: "claude-3-opus".to_string(),
+                max_tokens: 4096,
+                system: None,
+                messages: vec![],
+                temperature: temp,
+            };
+            let json = serde_json::to_string(&req).unwrap();
+            assert!(json.contains(&format!("{temp}")));
+        }
+    }
+}