zarz 0.3.4-alpha → 0.3.5-alpha

package/src/mcp/types.rs

@@ -1,170 +0,0 @@
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use std::collections::HashMap;
-
-/// MCP JSON-RPC request
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct JsonRpcRequest {
-    pub jsonrpc: String,
-    pub id: u64,
-    pub method: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub params: Option<Value>,
-}
-
-/// MCP JSON-RPC response
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct JsonRpcResponse {
-    pub jsonrpc: String,
-    pub id: u64,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub result: Option<Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub error: Option<JsonRpcError>,
-}
-
-/// MCP JSON-RPC error
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct JsonRpcError {
-    pub code: i32,
-    pub message: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub data: Option<Value>,
-}
-
-/// MCP Tool definition
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct McpTool {
-    pub name: String,
-    pub description: Option<String>,
-    #[serde(rename = "inputSchema")]
-    pub input_schema: Value,
-}
-
-/// MCP Resource definition
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct McpResource {
-    pub uri: String,
-    pub name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub description: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub mime_type: Option<String>,
-}
-
-/// MCP Prompt definition
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct McpPrompt {
-    pub name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub description: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub arguments: Option<Vec<PromptArgument>>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct PromptArgument {
-    pub name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub description: Option<String>,
-    pub required: bool,
-}
-
-/// MCP Initialize result
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct InitializeResult {
-    #[serde(rename = "protocolVersion")]
-    pub protocol_version: String,
-    pub capabilities: ServerCapabilities,
-    #[serde(rename = "serverInfo")]
-    pub server_info: ServerInfo,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ServerCapabilities {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tools: Option<ToolsCapability>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub resources: Option<ResourcesCapability>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub prompts: Option<PromptsCapability>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ToolsCapability {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub list_changed: Option<bool>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ResourcesCapability {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub subscribe: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub list_changed: Option<bool>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct PromptsCapability {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub list_changed: Option<bool>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ServerInfo {
-    pub name: String,
-    pub version: String,
-}
-
-/// Tools list response
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ToolsListResult {
-    pub tools: Vec<McpTool>,
-}
-
-/// Tool call request
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct CallToolParams {
-    pub name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub arguments: Option<HashMap<String, Value>>,
-}
-
-/// Tool call result
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct CallToolResult {
-    pub content: Vec<ToolContent>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub is_error: Option<bool>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "type")]
-#[allow(dead_code)]
-pub enum ToolContent {
-    #[serde(rename = "text")]
-    Text { text: String },
-    #[serde(rename = "image")]
-    Image { data: String, mime_type: String },
-    #[serde(rename = "resource")]
-    Resource { resource: McpResource },
-}
-
-/// Resources list response
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct ResourcesListResult {
-    pub resources: Vec<McpResource>,
-}
-
-/// Prompts list response
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[allow(dead_code)]
-pub struct PromptsListResult {
-    pub prompts: Vec<McpPrompt>,
-}

package/src/providers/anthropic.rs

@@ -1,242 +0,0 @@
-use anyhow::{Context, Result};
-use bytes::Bytes;
-use futures::stream::StreamExt;
-use reqwest::Client;
-use serde::Deserialize;
-use serde_json::json;
-
-use super::{CompletionRequest, CompletionResponse, CompletionStream};
-
-const DEFAULT_ENDPOINT: &str = "https://api.anthropic.com/v1/messages";
-const DEFAULT_VERSION: &str = "2023-06-01";
-
-pub struct AnthropicClient {
-    http: Client,
-    endpoint: String,
-    api_key: String,
-    version: String,
-}
-
-impl AnthropicClient {
-    pub fn from_env(
-        api_key_override: Option<String>,
-        endpoint_override: Option<String>,
-        timeout_override: Option<u64>,
-    ) -> Result<Self> {
-        let api_key = api_key_override
-            .or_else(|| std::env::var("ANTHROPIC_API_KEY").ok())
-            .ok_or_else(|| anyhow::anyhow!("ANTHROPIC_API_KEY is required. Please set it in ~/.zarz/config.toml or as an environment variable"))?;
-        let endpoint = endpoint_override
-            .or_else(|| std::env::var("ANTHROPIC_API_URL").ok())
-            .unwrap_or_else(|| DEFAULT_ENDPOINT.to_string());
-        let version = std::env::var("ANTHROPIC_API_VERSION")
-            .ok()
-            .filter(|v| !v.trim().is_empty())
-            .unwrap_or_else(|| DEFAULT_VERSION.to_string());
-
-        let timeout_secs = timeout_override
-            .or_else(|| {
-                std::env::var("ANTHROPIC_TIMEOUT_SECS")
-                    .ok()
-                    .and_then(|raw| raw.parse::<u64>().ok())
-            })
-            .unwrap_or(120);
-
-        let http = Client::builder()
-            .user_agent("zarz-cli/0.1")
-            .timeout(std::time::Duration::from_secs(timeout_secs))
-            .build()
-            .context("Failed to build HTTP client for Anthropic")?;
-
-        Ok(Self {
-            http,
-            endpoint,
-            api_key,
-            version,
-        })
-    }
-
-    pub async fn complete(&self, request: &CompletionRequest) -> Result<CompletionResponse> {
-        let mut payload = serde_json::Map::new();
-        payload.insert("model".to_string(), serde_json::Value::String(request.model.clone()));
-        payload.insert(
-            "max_tokens".to_string(),
-            serde_json::Value::Number(serde_json::Number::from(request.max_output_tokens)),
-        );
-        payload.insert("temperature".to_string(), json!(request.temperature));
-        if let Some(system_prompt) = &request.system_prompt {
-            payload.insert(
-                "system".to_string(),
-                serde_json::Value::String(system_prompt.clone()),
-            );
-        }
-
-        if let Some(tools) = &request.tools {
-            payload.insert("tools".to_string(), serde_json::Value::Array(tools.clone()));
-        }
-
-        if let Some(messages) = &request.messages {
-            payload.insert("messages".to_string(), serde_json::Value::Array(messages.clone()));
-        } else {
-            payload.insert(
-                "messages".to_string(),
-                json!([{
-                    "role": "user",
-                    "content": [{
-                        "type": "text",
-                        "text": request.user_prompt
-                    }]
-                }]),
-            );
-        }
-
-        let response = self
-            .http
-            .post(&self.endpoint)
-            .header("x-api-key", &self.api_key)
-            .header("anthropic-version", &self.version)
-            .json(&payload)
-            .send()
-            .await
-            .context("Anthropic request failed")?;
-
-        let response = response.error_for_status().context("Anthropic returned an error status")?;
-        let parsed: AnthropicResponse = response
-            .json()
-            .await
-            .context("Failed to decode Anthropic response")?;
-
-        let mut text = String::new();
-        let mut tool_calls = Vec::new();
-
-        for block in parsed.content {
-            match block {
-                AnthropicResponseBlock::Text { text: t } => {
-                    text.push_str(&t);
-                }
-                AnthropicResponseBlock::ToolUse { id, name, input } => {
-                    tool_calls.push(super::ToolCall { id, name, input });
-                }
-            }
-        }
-
-        Ok(CompletionResponse {
-            text,
-            tool_calls,
-            stop_reason: parsed.stop_reason,
-        })
-    }
-
-    #[allow(dead_code)]
-    pub async fn complete_stream(&self, request: &CompletionRequest) -> Result<CompletionStream> {
-        let mut payload = serde_json::Map::new();
-        payload.insert("model".to_string(), serde_json::Value::String(request.model.clone()));
-        payload.insert(
-            "max_tokens".to_string(),
-            serde_json::Value::Number(serde_json::Number::from(request.max_output_tokens)),
-        );
-        payload.insert("temperature".to_string(), json!(request.temperature));
-        payload.insert("stream".to_string(), json!(true));
-
-        if let Some(system_prompt) = &request.system_prompt {
-            payload.insert(
-                "system".to_string(),
-                serde_json::Value::String(system_prompt.clone()),
-            );
-        }
-        payload.insert(
-            "messages".to_string(),
-            json!([{
-                "role": "user",
-                "content": [{
-                    "type": "text",
-                    "text": request.user_prompt
-                }]
-            }]),
-        );
-
-        let response = self
-            .http
-            .post(&self.endpoint)
-            .header("x-api-key", &self.api_key)
-            .header("anthropic-version", &self.version)
-            .json(&payload)
-            .send()
-            .await
-            .context("Anthropic streaming request failed")?;
-
-        let response = response
-            .error_for_status()
-            .context("Anthropic returned an error status")?;
-
-        let stream = response.bytes_stream();
-        let text_stream = stream.map(|result| {
-            let bytes = result?;
-            parse_anthropic_sse_chunk(&bytes)
-        });
-
-        Ok(Box::pin(text_stream))
-    }
-}
-
-#[allow(dead_code)]
-fn parse_anthropic_sse_chunk(bytes: &Bytes) -> Result<String> {
-    let text = String::from_utf8_lossy(bytes);
-    let mut result = String::new();
-
-    for line in text.lines() {
-        if let Some(data) = line.strip_prefix("data: ") {
-            if data == "[DONE]" {
-                break;
-            }
-
-            if let Ok(event) = serde_json::from_str::<StreamEvent>(data) {
-                match event.event_type.as_str() {
-                    "content_block_delta" => {
-                        if let Some(delta) = event.delta {
-                            if let Some(text) = delta.text {
-                                result.push_str(&text);
-                            }
-                        }
-                    }
-                    _ => {}
-                }
-            }
-        }
-    }
-
-    Ok(result)
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Deserialize)]
-struct StreamEvent {
-    #[serde(rename = "type")]
-    event_type: String,
-    delta: Option<StreamDelta>,
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Deserialize)]
-struct StreamDelta {
-    text: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct AnthropicResponse {
-    content: Vec<AnthropicResponseBlock>,
-    stop_reason: Option<String>,
-}
-
-#[derive(Debug, Deserialize, Clone)]
-#[serde(tag = "type")]
-pub enum AnthropicResponseBlock {
-    #[serde(rename = "text")]
-    Text { text: String },
-    #[serde(rename = "tool_use")]
-    ToolUse {
-        id: String,
-        name: String,
-        input: serde_json::Value,
-    },
-}

package/src/providers/glm.rs

@@ -1,259 +0,0 @@
-use anyhow::{anyhow, Context, Result};
-use bytes::Bytes;
-use futures::stream::StreamExt;
-use reqwest::Client;
-use serde::Deserialize;
-use serde_json::json;
-
-use super::{CompletionRequest, CompletionResponse, CompletionStream};
-
-// GLM Coding Plan endpoint (base URL only, no /chat/completions)
-const DEFAULT_ENDPOINT: &str = "https://api.z.ai/api/coding/paas/v4";
-
-pub struct GlmClient {
-    http: Client,
-    endpoint: String,
-    api_key: String,
-}
-
-impl GlmClient {
-    pub fn from_env(
-        api_key_override: Option<String>,
-        endpoint_override: Option<String>,
-        timeout_override: Option<u64>,
-    ) -> Result<Self> {
-        let api_key = api_key_override
-            .or_else(|| std::env::var("GLM_API_KEY").ok())
-            .ok_or_else(|| anyhow::anyhow!("GLM_API_KEY is required. Please set it in ~/.zarz/config.toml or as an environment variable"))?;
-        let endpoint = endpoint_override
-            .or_else(|| std::env::var("GLM_API_URL").ok())
-            .unwrap_or_else(|| DEFAULT_ENDPOINT.to_string());
-
-        let timeout_secs = timeout_override
-            .or_else(|| {
-                std::env::var("GLM_TIMEOUT_SECS")
-                    .ok()
-                    .and_then(|raw| raw.parse::<u64>().ok())
-            })
-            .unwrap_or(120);
-
-        let http = Client::builder()
-            .user_agent("zarz-cli/0.1")
-            .timeout(std::time::Duration::from_secs(timeout_secs))
-            .build()
-            .context("Failed to build HTTP client for GLM")?;
-
-        Ok(Self {
-            http,
-            endpoint,
-            api_key,
-        })
-    }
-
-    pub async fn complete(&self, request: &CompletionRequest) -> Result<CompletionResponse> {
-        let messages = if let Some(msgs) = &request.messages {
-            msgs.clone()
-        } else {
-            let mut messages = Vec::new();
-            if let Some(system) = &request.system_prompt {
-                messages.push(json!({
-                    "role": "system",
-                    "content": system,
-                }));
-            }
-            messages.push(json!({
-                "role": "user",
-                "content": request.user_prompt,
-            }));
-            messages
-        };
-
-        let mut payload = json!({
-            "model": request.model,
-            "max_tokens": request.max_output_tokens,
-            "messages": messages,
-        });
-
-        if let Some(tools) = &request.tools {
-            let glm_tools: Vec<_> = tools.iter().map(|tool| {
-                json!({
-                    "type": "function",
-                    "function": {
-                        "name": tool["name"],
-                        "description": tool["description"],
-                        "parameters": tool["input_schema"]
-                    }
-                })
-            }).collect();
-            payload["tools"] = json!(glm_tools);
-        }
-
-        // Construct full endpoint URL
-        let full_url = format!("{}/chat/completions", self.endpoint);
-
-        let response = self
-            .http
-            .post(&full_url)
-            .bearer_auth(&self.api_key)
-            .json(&payload)
-            .send()
-            .await
-            .context("GLM request failed")?;
-
-        // Check status and get error details if failed
-        let status = response.status();
-        if !status.is_success() {
-            let error_body = response.text().await.unwrap_or_else(|_| "Unable to read error body".to_string());
-            return Err(anyhow!("GLM API error ({}): {}", status, error_body));
-        }
-
-        let response = response;
-
-        let parsed: GlmResponse = response
-            .json()
-            .await
-            .context("Failed to decode GLM response")?;
-
-        let first_choice = parsed.choices.into_iter().next()
-            .ok_or_else(|| anyhow!("GLM response did not include any choices"))?;
-
-        let text = first_choice.message.content.unwrap_or_default();
-        let mut tool_calls = Vec::new();
-
-        if let Some(calls) = first_choice.message.tool_calls {
-            for call in calls {
-                tool_calls.push(super::ToolCall {
-                    id: call.id,
-                    name: call.function.name,
-                    input: call.function.arguments,
-                });
-            }
-        }
-
-        Ok(CompletionResponse {
-            text,
-            tool_calls,
-            stop_reason: first_choice.finish_reason,
-        })
-    }
-
-    #[allow(dead_code)]
-    pub async fn complete_stream(&self, request: &CompletionRequest) -> Result<CompletionStream> {
-        let mut messages = Vec::new();
-        if let Some(system) = &request.system_prompt {
-            messages.push(json!({
-                "role": "system",
-                "content": system,
-            }));
-        }
-        messages.push(json!({
-            "role": "user",
-            "content": request.user_prompt,
-        }));
-
-        let payload = json!({
-            "model": request.model,
-            "max_tokens": request.max_output_tokens,
-            "messages": messages,
-            "stream": true,
-        });
-
-        // Construct full endpoint URL
-        let full_url = format!("{}/chat/completions", self.endpoint);
-
-        let response = self
-            .http
-            .post(&full_url)
-            .bearer_auth(&self.api_key)
-            .json(&payload)
-            .send()
-            .await
-            .context("GLM streaming request failed")?;
-
-        let response = response
-            .error_for_status()
-            .context("GLM returned an error status")?;
-
-        let stream = response.bytes_stream();
-        let text_stream = stream.map(|result| {
-            let bytes = result?;
-            parse_glm_sse_chunk(&bytes)
-        });
-
-        Ok(Box::pin(text_stream))
-    }
-}
-
-#[allow(dead_code)]
-fn parse_glm_sse_chunk(bytes: &Bytes) -> Result<String> {
-    let text = String::from_utf8_lossy(bytes);
-    let mut result = String::new();
-
-    for line in text.lines() {
-        if let Some(data) = line.strip_prefix("data: ") {
-            if data == "[DONE]" {
-                break;
-            }
-
-            if let Ok(chunk) = serde_json::from_str::<StreamChunk>(data) {
-                if let Some(choice) = chunk.choices.first() {
-                    if let Some(content) = &choice.delta.content {
-                        result.push_str(content);
-                    }
-                }
-            }
-        }
-    }
-
-    Ok(result)
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Deserialize)]
-struct StreamChunk {
-    choices: Vec<StreamChoice>,
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Deserialize)]
-struct StreamChoice {
-    delta: StreamDelta,
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Deserialize)]
-struct StreamDelta {
-    content: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct GlmResponse {
-    choices: Vec<GlmChoice>,
-}
-
-#[derive(Debug, Deserialize)]
-struct GlmChoice {
-    message: GlmMessage,
-    finish_reason: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct GlmMessage {
-    content: Option<String>,
-    tool_calls: Option<Vec<GlmToolCall>>,
-}
-
-#[derive(Debug, Deserialize)]
-struct GlmToolCall {
-    id: String,
-    #[serde(rename = "type")]
-    #[allow(dead_code)]
-    call_type: String,
-    function: GlmFunction,
-}
-
-#[derive(Debug, Deserialize)]
-struct GlmFunction {
-    name: String,
-    arguments: serde_json::Value,
-}