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/compatible.rs

@@ -0,0 +1,245 @@
+//! Generic OpenAI-compatible provider.
+//! Most LLM APIs follow the same `/v1/chat/completions` format.
+//! This module provides a single implementation that works for all of them.
+
+use crate::providers::traits::Provider;
+use async_trait::async_trait;
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+
+/// A provider that speaks the OpenAI-compatible chat completions API.
+/// Used by: Venice, Vercel AI Gateway, Cloudflare AI Gateway, Moonshot,
+/// Synthetic, `OpenCode` Zen, `Z.AI`, `GLM`, `MiniMax`, Bedrock, Qianfan, Groq, Mistral, `xAI`, etc.
+pub struct OpenAiCompatibleProvider {
+    pub(crate) name: String,
+    pub(crate) base_url: String,
+    pub(crate) api_key: Option<String>,
+    pub(crate) auth_header: AuthStyle,
+    client: Client,
+}
+
+/// How the provider expects the API key to be sent.
+#[derive(Debug, Clone)]
+pub enum AuthStyle {
+    /// `Authorization: Bearer <key>`
+    Bearer,
+    /// `x-api-key: <key>` (used by some Chinese providers)
+    XApiKey,
+    /// Custom header name
+    Custom(String),
+}
+
+impl OpenAiCompatibleProvider {
+    pub fn new(name: &str, base_url: &str, api_key: Option<&str>, auth_style: AuthStyle) -> Self {
+        Self {
+            name: name.to_string(),
+            base_url: base_url.trim_end_matches('/').to_string(),
+            api_key: api_key.map(ToString::to_string),
+            auth_header: auth_style,
+            client: Client::new(),
+        }
+    }
+}
+
+#[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,
+}
+
+#[async_trait]
+impl Provider for OpenAiCompatibleProvider {
+    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!(
+                "{} API key not set. Run `zeroclaw onboard` or set the appropriate env var.",
+                self.name
+            )
+        })?;
+
+        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 url = format!("{}/v1/chat/completions", self.base_url);
+
+        let mut req = self.client.post(&url).json(&request);
+
+        match &self.auth_header {
+            AuthStyle::Bearer => {
+                req = req.header("Authorization", format!("Bearer {api_key}"));
+            }
+            AuthStyle::XApiKey => {
+                req = req.header("x-api-key", api_key.as_str());
+            }
+            AuthStyle::Custom(header) => {
+                req = req.header(header.as_str(), api_key.as_str());
+            }
+        }
+
+        let response = req.send().await?;
+
+        if !response.status().is_success() {
+            let error = response.text().await?;
+            anyhow::bail!("{} API error: {error}", self.name);
+        }
+
+        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 {}", self.name))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_provider(name: &str, url: &str, key: Option<&str>) -> OpenAiCompatibleProvider {
+        OpenAiCompatibleProvider::new(name, url, key, AuthStyle::Bearer)
+    }
+
+    #[test]
+    fn creates_with_key() {
+        let p = make_provider("venice", "https://api.venice.ai", Some("vn-key"));
+        assert_eq!(p.name, "venice");
+        assert_eq!(p.base_url, "https://api.venice.ai");
+        assert_eq!(p.api_key.as_deref(), Some("vn-key"));
+    }
+
+    #[test]
+    fn creates_without_key() {
+        let p = make_provider("test", "https://example.com", None);
+        assert!(p.api_key.is_none());
+    }
+
+    #[test]
+    fn strips_trailing_slash() {
+        let p = make_provider("test", "https://example.com/", None);
+        assert_eq!(p.base_url, "https://example.com");
+    }
+
+    #[tokio::test]
+    async fn chat_fails_without_key() {
+        let p = make_provider("Venice", "https://api.venice.ai", None);
+        let result = p.chat_with_system(None, "hello", "llama-3.3-70b", 0.7).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().to_string().contains("Venice API key not set"));
+    }
+
+    #[test]
+    fn request_serializes_correctly() {
+        let req = ChatRequest {
+            model: "llama-3.3-70b".to_string(),
+            messages: vec![
+                Message { role: "system".to_string(), content: "You are ZeroClaw".to_string() },
+                Message { role: "user".to_string(), content: "hello".to_string() },
+            ],
+            temperature: 0.7,
+        };
+        let json = serde_json::to_string(&req).unwrap();
+        assert!(json.contains("llama-3.3-70b"));
+        assert!(json.contains("system"));
+        assert!(json.contains("user"));
+    }
+
+    #[test]
+    fn response_deserializes() {
+        let json = r#"{"choices":[{"message":{"content":"Hello from Venice!"}}]}"#;
+        let resp: ChatResponse = serde_json::from_str(json).unwrap();
+        assert_eq!(resp.choices[0].message.content, "Hello from Venice!");
+    }
+
+    #[test]
+    fn response_empty_choices() {
+        let json = r#"{"choices":[]}"#;
+        let resp: ChatResponse = serde_json::from_str(json).unwrap();
+        assert!(resp.choices.is_empty());
+    }
+
+    #[test]
+    fn x_api_key_auth_style() {
+        let p = OpenAiCompatibleProvider::new(
+            "moonshot", "https://api.moonshot.cn", Some("ms-key"), AuthStyle::XApiKey,
+        );
+        assert!(matches!(p.auth_header, AuthStyle::XApiKey));
+    }
+
+    #[test]
+    fn custom_auth_style() {
+        let p = OpenAiCompatibleProvider::new(
+            "custom", "https://api.example.com", Some("key"), AuthStyle::Custom("X-Custom-Key".into()),
+        );
+        assert!(matches!(p.auth_header, AuthStyle::Custom(_)));
+    }
+
+    #[tokio::test]
+    async fn all_compatible_providers_fail_without_key() {
+        let providers = vec![
+            make_provider("Venice", "https://api.venice.ai", None),
+            make_provider("Moonshot", "https://api.moonshot.cn", None),
+            make_provider("GLM", "https://open.bigmodel.cn", None),
+            make_provider("MiniMax", "https://api.minimax.chat", None),
+            make_provider("Groq", "https://api.groq.com/openai", None),
+            make_provider("Mistral", "https://api.mistral.ai", None),
+            make_provider("xAI", "https://api.x.ai", None),
+        ];
+
+        for p in providers {
+            let result = p.chat_with_system(None, "test", "model", 0.7).await;
+            assert!(result.is_err(), "{} should fail without key", p.name);
+            assert!(
+                result.unwrap_err().to_string().contains("API key not set"),
+                "{} error should mention key", p.name
+            );
+        }
+    }
+}