Merge pull request #5 from dnacenta/release/v0.2.0

release: v0.2.0 — tool execution system

Author: dnacenta

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "echo-system"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 rust-version = "1.80"
 license = "AGPL-3.0-only"

src/llm/claude_api.rs

@@ -1,4 +1,6 @@
-use super::{LlmResponse, LlmResult, LmProvider, Message};
+use super::{
+    ContentBlock, LlmResponse, LlmResult, LmProvider, Message, MessageContent, StopReason,
+};
 
 pub struct ClaudeProvider {
     api_key: String,
@@ -17,30 +19,51 @@ impl ClaudeProvider {
 }
 
 impl LmProvider for ClaudeProvider {
-    fn invoke(&self, system_prompt: &str, messages: &[Message], max_tokens: u32) -> LlmResult<'_> {
+    fn invoke(
+        &self,
+        system_prompt: &str,
+        messages: &[Message],
+        max_tokens: u32,
+        tools: Option<&[serde_json::Value]>,
+    ) -> LlmResult<'_> {
         let system_prompt = system_prompt.to_string();
         let messages = messages.to_vec();
+        let tools = tools.map(|t| t.to_vec());
         Box::pin(async move {
             let api_messages: Vec<serde_json::Value> = messages
                 .iter()
                 .map(|m| {
+                    let role = match m.role {
+                        super::Role::User => "user",
+                        super::Role::Assistant => "assistant",
+                    };
+                    let content = match &m.content {
+                        MessageContent::Text(s) => serde_json::Value::String(s.clone()),
+                        MessageContent::Blocks(blocks) => {
+                            serde_json::to_value(blocks).unwrap_or(serde_json::Value::Null)
+                        }
+                    };
                     serde_json::json!({
-                        "role": match m.role {
-                            super::Role::User => "user",
-                            super::Role::Assistant => "assistant",
-                        },
-                        "content": m.content,
+                        "role": role,
+                        "content": content,
                     })
                 })
                 .collect();
 
-            let body = serde_json::json!({
+            let mut body = serde_json::json!({
                 "model": self.model,
                 "max_tokens": max_tokens,
                 "system": system_prompt,
                 "messages": api_messages,
             });
 
+            // Include tool definitions if provided
+            if let Some(ref tool_defs) = tools {
+                if !tool_defs.is_empty() {
+                    body["tools"] = serde_json::Value::Array(tool_defs.clone());
+                }
+            }
+
             let response = self
                 .client
                 .post("https://api.anthropic.com/v1/messages")
@@ -65,12 +88,18 @@ impl LmProvider for ClaudeProvider {
             let response_json: serde_json::Value = serde_json::from_str(&response_text)
                 .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?;
 
-            let content = response_json["content"]
-                .as_array()
-                .and_then(|arr| arr.first())
-                .and_then(|block| block["text"].as_str())
-                .unwrap_or("")
-                .to_string();
+            // Parse content blocks from the response
+            let content_blocks = parse_content_blocks(&response_json);
+
+            // Parse stop_reason
+            let stop_reason = match response_json["stop_reason"].as_str() {
+                Some("end_turn") => StopReason::EndTurn,
+                Some("tool_use") => StopReason::ToolUse,
+                Some("max_tokens") => StopReason::MaxTokens,
+                Some("stop_sequence") => StopReason::StopSequence,
+                Some(other) => StopReason::Other(other.to_string()),
+                None => StopReason::EndTurn,
+            };
 
             let model = response_json["model"]
                 .as_str()
@@ -85,7 +114,8 @@ impl LmProvider for ClaudeProvider {
                 .map(|v| v as u32);
 
             Ok(LlmResponse {
-                content,
+                content: content_blocks,
+                stop_reason,
                 model,
                 input_tokens,
                 output_tokens,
@@ -101,3 +131,30 @@ impl LmProvider for ClaudeProvider {
         true
     }
 }
+
+/// Parse the `content` array from a Claude API response into ContentBlock values.
+fn parse_content_blocks(response_json: &serde_json::Value) -> Vec<ContentBlock> {
+    let Some(content_array) = response_json["content"].as_array() else {
+        return vec![];
+    };
+
+    content_array
+        .iter()
+        .filter_map(|block| {
+            let block_type = block["type"].as_str()?;
+            match block_type {
+                "text" => {
+                    let text = block["text"].as_str().unwrap_or("").to_string();
+                    Some(ContentBlock::Text { text })
+                }
+                "tool_use" => {
+                    let id = block["id"].as_str()?.to_string();
+                    let name = block["name"].as_str()?.to_string();
+                    let input = block["input"].clone();
+                    Some(ContentBlock::ToolUse { id, name, input })
+                }
+                _ => None,
+            }
+        })
+        .collect()
+}

src/llm/mod.rs

@@ -12,19 +12,91 @@ pub type LlmResult<'a> = Pin<
     >,
 >;
 
+/// A content block in a message or response.
+/// Claude API uses tagged unions — each block has a "type" field.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(tag = "type")]
+pub enum ContentBlock {
+    #[serde(rename = "text")]
+    Text { text: String },
+
+    #[serde(rename = "tool_use")]
+    ToolUse {
+        id: String,
+        name: String,
+        input: serde_json::Value,
+    },
+
+    #[serde(rename = "tool_result")]
+    ToolResult {
+        tool_use_id: String,
+        content: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        is_error: Option<bool>,
+    },
+}
+
+/// Message content can be a simple string or structured content blocks.
+/// The Claude API accepts both formats.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(untagged)]
+pub enum MessageContent {
+    Text(String),
+    Blocks(Vec<ContentBlock>),
+}
+
+/// Why the model stopped generating.
+#[derive(Debug, Clone, PartialEq)]
+pub enum StopReason {
+    EndTurn,
+    ToolUse,
+    MaxTokens,
+    StopSequence,
+    Other(String),
+}
+
 /// Response from an LLM invocation
 #[derive(Debug, Clone)]
 pub struct LlmResponse {
-    pub content: String,
+    pub content: Vec<ContentBlock>,
+    pub stop_reason: StopReason,
     pub model: String,
     pub input_tokens: Option<u32>,
     pub output_tokens: Option<u32>,
 }
 
+impl LlmResponse {
+    /// Extract all text content from the response, concatenated.
+    pub fn text(&self) -> String {
+        self.content
+            .iter()
+            .filter_map(|block| match block {
+                ContentBlock::Text { text } => Some(text.as_str()),
+                _ => None,
+            })
+            .collect::<Vec<_>>()
+            .join("")
+    }
+
+    /// Check if the response contains any tool_use blocks.
+    pub fn has_tool_use(&self) -> bool {
+        self.content
+            .iter()
+            .any(|block| matches!(block, ContentBlock::ToolUse { .. }))
+    }
+}
+
 /// Trait for LLM providers — the core abstraction for model-agnostic design
 pub trait LmProvider: Send + Sync {
-    /// Send a message and get a response
-    fn invoke(&self, system_prompt: &str, messages: &[Message], max_tokens: u32) -> LlmResult<'_>;
+    /// Send a message and get a response.
+    /// `tools` is an optional slice of tool definitions (JSON objects).
+    fn invoke(
+        &self,
+        system_prompt: &str,
+        messages: &[Message],
+        max_tokens: u32,
+        tools: Option<&[serde_json::Value]>,
+    ) -> LlmResult<'_>;
 
     /// Provider name
     fn name(&self) -> &str;
@@ -39,7 +111,7 @@ pub trait LmProvider: Send + Sync {
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Message {
     pub role: Role,
-    pub content: String,
+    pub content: MessageContent,
 }
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]

src/main.rs

@@ -10,6 +10,7 @@ mod pipeline;
 mod plugins;
 mod scheduler;
 mod server;
+mod tools;
 
 #[derive(Parser)]
 #[command(name = "echo-system")]

src/scheduler/dynamic.rs

@@ -25,7 +25,8 @@ pub fn create_task_from_marker(
         .ok_or("Missing 'prompt' in schedule marker")?
         .to_string();
 
-    // Validate the cron expression
+    // Normalize and validate the cron expression
+    let cron = super::normalize_cron(&cron);
     CronSchedule::from_str(&cron)
         .map_err(|e| format!("Invalid cron expression '{}': {}", cron, e))?;
 

src/scheduler/mod.rs

@@ -170,3 +170,41 @@ pub async fn start(
 fn default_true() -> bool {
     true
 }
+
+/// Normalize a 6-field cron expression so that Sunday `0` becomes `7`.
+/// The `cron` crate requires day-of-week in 1-7 (Mon-Sun), but most users
+/// expect 0 = Sunday (the POSIX convention).
+pub fn normalize_cron(expr: &str) -> String {
+    let fields: Vec<&str> = expr.split_whitespace().collect();
+    if fields.len() == 6 {
+        let dow = fields[5];
+        if dow == "0" {
+            return format!(
+                "{} {} {} {} {} 7",
+                fields[0], fields[1], fields[2], fields[3], fields[4]
+            );
+        }
+    }
+    expr.to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn normalize_sunday_zero_to_seven() {
+        assert_eq!(normalize_cron("0 0 11 * * 0"), "0 0 11 * * 7");
+    }
+
+    #[test]
+    fn leave_other_days_unchanged() {
+        assert_eq!(normalize_cron("0 0 11 * * 1"), "0 0 11 * * 1");
+        assert_eq!(normalize_cron("0 0 11 * * 7"), "0 0 11 * * 7");
+    }
+
+    #[test]
+    fn leave_wildcard_unchanged() {
+        assert_eq!(normalize_cron("0 0 8 * * *"), "0 0 8 * * *");
+    }
+}

src/scheduler/runner.rs

@@ -7,7 +7,7 @@ use tokio::sync::RwLock;
 
 use super::output;
 use super::{Schedule, ScheduledTask};
-use crate::llm::{Message, Role};
+use crate::llm::{Message, MessageContent, Role};
 use crate::monitoring::signals;
 use crate::pipeline;
 use crate::pipeline::health as pipeline_health;
@@ -21,7 +21,8 @@ pub async fn run_task_loop(
     schedule: Arc<RwLock<Schedule>>,
     tz: chrono_tz::Tz,
 ) {
-    let cron_expr = match CronSchedule::from_str(&task.cron) {
+    let normalized_cron = super::normalize_cron(&task.cron);
+    let cron_expr = match CronSchedule::from_str(&normalized_cron) {
         Ok(c) => c,
         Err(e) => {
             tracing::error!("Invalid cron for task '{}': {} — {}", task.id, task.cron, e);
@@ -104,13 +105,13 @@ async fn execute_task(
     // Create a fresh conversation (no shared state with chat)
     let messages = vec![Message {
         role: Role::User,
-        content: user_message,
+        content: MessageContent::Text(user_message),
     }];
 
-    // Invoke LLM
+    // Invoke LLM (no tools for scheduled tasks)
     let result = match state
         .provider
-        .invoke(&system_prompt, &messages, state.config.llm.max_tokens)
+        .invoke(&system_prompt, &messages, state.config.llm.max_tokens, None)
         .await
     {
         Ok(r) => r,
@@ -128,7 +129,8 @@ async fn execute_task(
     );
 
     // Parse and route output
-    let parsed = output::parse_output(&result.content);
+    let response_text = result.text();
+    let parsed = output::parse_output(&response_text);
 
     // Handle [SCHEDULE:] markers — create new dynamic tasks
     for schedule_json in &parsed.schedule_requests {
@@ -166,7 +168,7 @@ async fn execute_task(
 
     // Post-execution: extract cognitive signals
     if state.config.monitoring.enabled {
-        let frame = signals::extract(&result.content, &task.id);
+        let frame = signals::extract(&response_text, &task.id);
         if let Err(e) = signals::record(&root_dir, frame, state.config.monitoring.window_size) {
             tracing::error!("Failed to record signals for task '{}': {}", task.id, e);
         }

src/scheduler/tasks.rs

@@ -82,7 +82,7 @@ pub fn default_tasks() -> Vec<ScheduledTask> {
         ScheduledTask {
             id: "weekly-synthesis".to_string(),
             name: "Weekly Synthesis".to_string(),
-            cron: "0 0 11 * * 0".to_string(),
+            cron: "0 0 11 * * 7".to_string(),
             channel: "system".to_string(),
             prompt: concat!(
                 "This is your weekly synthesis. Review the entire week: ",

src/server/auth.rs

@@ -63,6 +63,7 @@ mod tests {
         SchedulerConfig, SecurityConfig, ServerConfig, TrustConfig,
     };
     use crate::llm::Message;
+    use crate::tools::ToolRegistry;
 
     fn test_state(secret: Option<String>) -> Arc<AppState> {
         Arc::new(AppState {
@@ -96,6 +97,7 @@ mod tests {
             )),
             conversation: RwLock::new(Vec::<Message>::new()),
             system_prompt: RwLock::new(String::new()),
+            tools: ToolRegistry::new(),
         })
     }