zarz 0.3.1-alpha → 0.3.4-alpha

package/Cargo.lock

@@ -2706,7 +2706,7 @@ dependencies = [
 
 [[package]]
 name = "zarzcli"
-version = "0.3.1-ALPHA"
+version = "0.3.4-ALPHA"
 dependencies = [
  "anyhow",
  "async-trait",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "zarzcli"
-version = "0.3.1-ALPHA"
+version = "0.3.4-ALPHA"
 edition = "2024"
 
 [dependencies]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zarz",
-  "version": "0.3.1-alpha",
+  "version": "0.3.4-alpha",
   "description": "Fast AI coding assistant for terminal built with Rust",
   "main": "bin/zarz.js",
   "bin": {

package/src/executor.rs

@@ -5,6 +5,7 @@ use tokio::process::Command;
 
 pub struct CommandExecutor;
 
+#[allow(dead_code)]
 #[derive(Debug)]
 pub struct CommandResult {
     pub stdout: String,
@@ -14,6 +15,7 @@ pub struct CommandResult {
 }
 
 impl CommandExecutor {
+    #[allow(dead_code)]
     pub async fn execute(command: &str) -> Result<CommandResult> {
         let (shell, flag) = if cfg!(target_os = "windows") {
             ("cmd", "/C")

package/src/main.rs

@@ -2,12 +2,12 @@ mod cli;
 mod config;
 mod mcp;
 mod providers;
-mod executor;
-mod fs_ops;
-mod intelligence;
-mod repl;
-mod session;
-mod conversation_store;
+mod executor;
+mod fs_ops;
+mod intelligence;
+mod repl;
+mod session;
+mod conversation_store;
 
 use std::{
     collections::HashMap,
@@ -109,7 +109,7 @@ async fn run(cli: Cli) -> Result<()> {
             }
         }
 
-        let tagline_lines = ["v0.3.0-Alpha", "Type /help for available commands, /exit to exit"];
+        let tagline_lines = ["v0.3.4-Alpha", "Type /help for available commands, /exit to exit"];
 
         for (index, line) in tagline_lines.iter().enumerate() {
             if index > 0 {
@@ -233,6 +233,8 @@ async fn handle_quick_ask(
         user_prompt,
         max_output_tokens: resolve_max_tokens(),
         temperature: resolve_temperature(),
+        messages: None,
+        tools: None,
     };
 
     let response = provider.complete(&request).await?;
@@ -305,6 +307,8 @@ async fn handle_ask(args: AskArgs, config: &config::Config) -> Result<()> {
         user_prompt,
         max_output_tokens: resolve_max_tokens(),
         temperature: resolve_temperature(),
+        messages: None,
+        tools: None,
     };
 
     let response = provider.complete(&request).await?;
@@ -378,6 +382,8 @@ async fn handle_rewrite(args: RewriteArgs, config: &config::Config) -> Result<()
         user_prompt,
         max_output_tokens: resolve_max_tokens(),
         temperature: resolve_rewrite_temperature(),
+        messages: None,
+        tools: None,
     };
 
     let response = provider.complete(&request).await?;

package/src/providers/anthropic.rs

@@ -1,4 +1,4 @@
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result};
 use bytes::Bytes;
 use futures::stream::StreamExt;
 use reqwest::Client;
@@ -70,16 +70,25 @@ impl AnthropicClient {
                 serde_json::Value::String(system_prompt.clone()),
             );
         }
-        payload.insert(
-            "messages".to_string(),
-            json!([{
-                "role": "user",
-                "content": [{
-                    "type": "text",
-                    "text": request.user_prompt
-                }]
-            }]),
-        );
+
+        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
@@ -96,14 +105,26 @@ impl AnthropicClient {
             .json()
             .await
             .context("Failed to decode Anthropic response")?;
-        let text = parsed
-            .content
-            .into_iter()
-            .find_map(|block| match block {
-                AnthropicResponseBlock::Text { text, .. } => Some(text),
-            })
-            .ok_or_else(|| anyhow!("Anthropic response did not include text content"))?;
-        Ok(CompletionResponse { text })
+
+        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)]
@@ -204,11 +225,18 @@ struct StreamDelta {
 #[derive(Debug, Deserialize)]
 struct AnthropicResponse {
     content: Vec<AnthropicResponseBlock>,
+    stop_reason: Option<String>,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Deserialize, Clone)]
 #[serde(tag = "type")]
-enum AnthropicResponseBlock {
+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

@@ -51,24 +51,43 @@ impl GlmClient {
     }
 
     pub async fn complete(&self, request: &CompletionRequest) -> Result<CompletionResponse> {
-        let mut messages = Vec::new();
-        if let Some(system) = &request.system_prompt {
+        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": "system",
-                "content": system,
+                "role": "user",
+                "content": request.user_prompt,
             }));
-        }
-        messages.push(json!({
-            "role": "user",
-            "content": request.user_prompt,
-        }));
+            messages
+        };
 
-        let payload = json!({
+        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);
 
@@ -95,13 +114,27 @@ impl GlmClient {
             .await
             .context("Failed to decode GLM response")?;
 
-        let text = parsed
-            .choices
-            .into_iter()
-            .find_map(|choice| choice.message.content)
-            .ok_or_else(|| anyhow!("GLM response did not include content"))?;
+        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();
 
-        Ok(CompletionResponse { text })
+        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)]
@@ -201,9 +234,26 @@ struct GlmResponse {
 #[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,
 }

package/src/providers/mod.rs

@@ -2,6 +2,7 @@ use anyhow::Result;
 use async_trait::async_trait;
 use futures::Stream;
 use std::pin::Pin;
+use serde_json::Value;
 
 use crate::cli::Provider;
 
@@ -16,11 +17,23 @@ pub struct CompletionRequest {
     pub user_prompt: String,
     pub max_output_tokens: u32,
     pub temperature: f32,
+    pub messages: Option<Vec<Value>>,
+    pub tools: Option<Vec<Value>>,
 }
 
 #[derive(Debug, Clone)]
 pub struct CompletionResponse {
     pub text: String,
+    pub tool_calls: Vec<ToolCall>,
+    #[allow(dead_code)]
+    pub stop_reason: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ToolCall {
+    pub id: String,
+    pub name: String,
+    pub input: serde_json::Value,
 }
 
 #[allow(dead_code)]

package/src/providers/openai.rs

@@ -50,25 +50,44 @@ impl OpenAiClient {
     }
 
     pub async fn complete(&self, request: &CompletionRequest) -> Result<CompletionResponse> {
-        let mut messages = Vec::new();
-        if let Some(system) = &request.system_prompt {
+        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": "system",
-                "content": system,
+                "role": "user",
+                "content": request.user_prompt,
             }));
-        }
-        messages.push(json!({
-            "role": "user",
-            "content": request.user_prompt,
-        }));
+            messages
+        };
 
-        let payload = json!({
+        let mut payload = json!({
             "model": request.model,
             "max_tokens": request.max_output_tokens,
             "temperature": request.temperature,
             "messages": messages,
         });
 
+        if let Some(tools) = &request.tools {
+            let openai_tools: Vec<_> = tools.iter().map(|tool| {
+                json!({
+                    "type": "function",
+                    "function": {
+                        "name": tool["name"],
+                        "description": tool["description"],
+                        "parameters": tool["input_schema"]
+                    }
+                })
+            }).collect();
+            payload["tools"] = json!(openai_tools);
+        }
+
         let response = self
             .http
             .post(&self.endpoint)
@@ -85,13 +104,27 @@ impl OpenAiClient {
             .await
             .context("Failed to decode OpenAI response")?;
 
-        let text = parsed
-            .choices
-            .into_iter()
-            .find_map(|choice| choice.message.content)
-            .ok_or_else(|| anyhow!("OpenAI response did not include content"))?;
+        let first_choice = parsed.choices.into_iter().next()
+            .ok_or_else(|| anyhow!("OpenAI response did not include any choices"))?;
+
+        let text = first_choice.message.content.unwrap_or_default();
+        let mut tool_calls = Vec::new();
 
-        Ok(CompletionResponse { text })
+        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)]
@@ -189,9 +222,26 @@ struct OpenAiResponse {
 #[derive(Debug, Deserialize)]
 struct OpenAiChoice {
     message: OpenAiMessage,
+    finish_reason: Option<String>,
 }
 
 #[derive(Debug, Deserialize)]
 struct OpenAiMessage {
     content: Option<String>,
+    tool_calls: Option<Vec<OpenAiToolCall>>,
+}
+
+#[derive(Debug, Deserialize)]
+struct OpenAiToolCall {
+    id: String,
+    #[serde(rename = "type")]
+    #[allow(dead_code)]
+    call_type: String,
+    function: OpenAiFunction,
+}
+
+#[derive(Debug, Deserialize)]
+struct OpenAiFunction {
+    name: String,
+    arguments: serde_json::Value,
 }