hanzo-agents 1.1.21

Specialized AI agents for development workflows - architect, CTO, code reviewer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

//! Scientist Agent - Research, analysis, and evidence-based reasoning

use crate::prompts::SCIENTIST_PROMPT;
use crate::tools::ToolRegistry;
use crate::traits::{
    AgentConfig, AgentError, AgentOutput, Result, SpecializedAgent, ToolDefinition, Usage,
};
use async_trait::async_trait;
use std::sync::Arc;

/// Scientist Agent for research and analysis
pub struct ScientistAgent {
    #[allow(dead_code)] // Reserved for tool execution integration
    tool_registry: Arc<ToolRegistry>,
}

impl ScientistAgent {
    pub fn new(tool_registry: Arc<ToolRegistry>) -> Self {
        Self { tool_registry }
    }

    pub fn default_agent() -> Self {
        Self::new(Arc::new(ToolRegistry::with_defaults()))
    }
}

#[async_trait]
impl SpecializedAgent for ScientistAgent {
    fn name(&self) -> &str {
        "scientist"
    }

    fn description(&self) -> &str {
        "Research scientist for analysis, experimentation, and evidence-based reasoning"
    }

    fn system_prompt(&self) -> &str {
        SCIENTIST_PROMPT
    }

    fn tools(&self) -> Vec<ToolDefinition> {
        vec![
            ToolDefinition::new("web_search", "Search the web for information").with_parameters(
                serde_json::json!({
                    "type": "object",
                    "properties": {
                        "query": { "type": "string" },
                        "num_results": { "type": "integer", "default": 5 }
                    },
                    "required": ["query"]
                }),
            ),
            ToolDefinition::new("read_url", "Read content from a URL").with_parameters(
                serde_json::json!({
                    "type": "object",
                    "properties": {
                        "url": { "type": "string" }
                    },
                    "required": ["url"]
                }),
            ),
            ToolDefinition::new("read_file", "Read a local file").with_parameters(
                serde_json::json!({
                    "type": "object",
                    "properties": {
                        "path": { "type": "string" }
                    },
                    "required": ["path"]
                }),
            ),
            ToolDefinition::new("analyze_data", "Analyze data with statistics").with_parameters(
                serde_json::json!({
                    "type": "object",
                    "properties": {
                        "data": { "type": "array", "items": { "type": "number" } },
                        "operations": {
                            "type": "array",
                            "items": {
                                "type": "string",
                                "enum": ["mean", "median", "std", "min", "max", "correlation"]
                            }
                        }
                    },
                    "required": ["data"]
                }),
            ),
            ToolDefinition::new("create_hypothesis", "Document a hypothesis").with_parameters(
                serde_json::json!({
                    "type": "object",
                    "properties": {
                        "hypothesis": { "type": "string" },
                        "evidence_for": { "type": "array", "items": { "type": "string" } },
                        "evidence_against": { "type": "array", "items": { "type": "string" } },
                        "confidence": { "type": "number", "minimum": 0, "maximum": 1 }
                    },
                    "required": ["hypothesis"]
                }),
            ),
        ]
    }

    async fn run(&self, input: &str, _config: &AgentConfig) -> Result<AgentOutput> {
        tracing::info!("Scientist agent processing: {}", input);

        Ok(AgentOutput {
            output: format!(
                "Research analysis for: {}\n\n[This is a placeholder - implement LLM integration]",
                input
            ),
            data: None,
            tool_calls: vec![],
            usage: Usage::default(),
            metadata: [("agent".to_string(), "scientist".to_string())]
                .into_iter()
                .collect(),
        })
    }

    async fn run_streaming(
        &self,
        _input: &str,
        _config: &AgentConfig,
    ) -> Result<Box<dyn futures::Stream<Item = Result<String>> + Send + Unpin>> {
        Err(AgentError::Other(
            "Streaming not yet implemented".to_string(),
        ))
    }
}