hanzo-agent 1.1.21

Agent framework with tool calling capabilities for Hanzo AI
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Core types for agent framework

use serde::{Deserialize, Serialize};

/// Input item for the agent
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum InputItem {
    #[serde(rename = "message")]
    Message { role: String, content: String },

    #[serde(rename = "tool_result")]
    ToolResult {
        tool_call_id: String,
        content: String,
    },
}

impl InputItem {
    /// Create a user message
    pub fn user_message(content: impl Into<String>) -> Self {
        InputItem::Message {
            role: "user".to_string(),
            content: content.into(),
        }
    }

    /// Create an assistant message
    pub fn assistant_message(content: impl Into<String>) -> Self {
        InputItem::Message {
            role: "assistant".to_string(),
            content: content.into(),
        }
    }

    /// Create a system message
    pub fn system_message(content: impl Into<String>) -> Self {
        InputItem::Message {
            role: "system".to_string(),
            content: content.into(),
        }
    }
}

/// Item generated during agent run
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum RunItem {
    #[serde(rename = "message")]
    Message { role: String, content: String },

    #[serde(rename = "tool_call")]
    ToolCall {
        id: String,
        name: String,
        arguments: String,
    },

    #[serde(rename = "tool_result")]
    ToolResult {
        tool_call_id: String,
        content: String,
    },
}

impl RunItem {
    /// Convert to input item for next turn
    pub fn to_input_item(&self) -> InputItem {
        match self {
            RunItem::Message { role, content } => InputItem::Message {
                role: role.clone(),
                content: content.clone(),
            },
            RunItem::ToolResult {
                tool_call_id,
                content,
            } => InputItem::ToolResult {
                tool_call_id: tool_call_id.clone(),
                content: content.clone(),
            },
            RunItem::ToolCall { .. } => {
                // Tool calls are converted to messages in the context
                InputItem::assistant_message("")
            }
        }
    }
}

/// Model response from LLM
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelResponse {
    /// The output items (messages, tool calls, etc.)
    pub output: Vec<RunItem>,

    /// Usage statistics
    pub usage: Usage,

    /// Response ID for reference
    pub id: Option<String>,
}

/// Usage statistics
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct Usage {
    pub requests: usize,
    pub input_tokens: usize,
    pub output_tokens: usize,
    pub total_tokens: usize,
}

impl Usage {
    /// Add usage from another instance
    pub fn add(&mut self, other: &Usage) {
        self.requests += other.requests;
        self.input_tokens += other.input_tokens;
        self.output_tokens += other.output_tokens;
        self.total_tokens += other.total_tokens;
    }
}

/// Model settings for tuning
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelSettings {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub temperature: Option<f32>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub top_p: Option<f32>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_tokens: Option<usize>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub stop: Option<Vec<String>>,
}

impl Default for ModelSettings {
    fn default() -> Self {
        Self {
            temperature: None,
            top_p: None,
            max_tokens: None,
            stop: None,
        }
    }
}