Skip to main content

agent_sdk/agent/
events.rs

1use serde::Serialize;
2
3use crate::error::{AgentId, TaskId};
4
5#[derive(Debug, Clone, Serialize)]
6#[serde(tag = "type", rename_all = "snake_case")]
7pub enum AgentEvent {
8    // --- Team lifecycle ---
9    TeamSpawned {
10        teammate_count: usize,
11    },
12    TeammateSpawned {
13        agent_id: AgentId,
14        name: String,
15    },
16
17    // --- Task lifecycle ---
18    TaskStarted {
19        agent_id: AgentId,
20        name: String,
21        task_id: TaskId,
22        title: String,
23    },
24    Thinking {
25        agent_id: AgentId,
26        name: String,
27        content: String,
28        iteration: usize,
29    },
30    ToolCall {
31        agent_id: AgentId,
32        name: String,
33        tool_name: String,
34        arguments: String,
35        iteration: usize,
36    },
37    ToolResult {
38        agent_id: AgentId,
39        name: String,
40        tool_name: String,
41        result_preview: String,
42        iteration: usize,
43    },
44    TaskCompleted {
45        agent_id: AgentId,
46        name: String,
47        task_id: TaskId,
48        tokens_used: u64,
49        iterations: usize,
50        tool_calls: usize,
51    },
52    TaskFailed {
53        agent_id: AgentId,
54        name: String,
55        task_id: TaskId,
56        error: String,
57    },
58
59    // --- Plan mode ---
60    PlanSubmitted {
61        agent_id: AgentId,
62        name: String,
63        task_id: TaskId,
64        plan_preview: String,
65    },
66    PlanApproved {
67        agent_id: AgentId,
68        name: String,
69        task_id: TaskId,
70    },
71    PlanRejected {
72        agent_id: AgentId,
73        name: String,
74        task_id: TaskId,
75        feedback: String,
76    },
77
78    // --- Communication ---
79    TeammateMessage {
80        from: AgentId,
81        from_name: String,
82        to: AgentId,
83        content_preview: String,
84    },
85    TeammateIdle {
86        agent_id: AgentId,
87        name: String,
88        tasks_completed: usize,
89    },
90
91    // --- Shutdown ---
92    ShutdownRequested {
93        agent_id: AgentId,
94        name: String,
95    },
96    ShutdownAccepted {
97        agent_id: AgentId,
98        name: String,
99    },
100    ShutdownRejected {
101        agent_id: AgentId,
102        name: String,
103        reason: String,
104    },
105    AgentShutdown {
106        agent_id: AgentId,
107        name: String,
108    },
109
110    // --- Hooks ---
111    HookRejected {
112        event_name: String,
113        feedback: String,
114    },
115
116    // --- Subagent lifecycle ---
117    SubAgentSpawned {
118        agent_id: AgentId,
119        name: String,
120        description: String,
121    },
122    SubAgentCompleted {
123        agent_id: AgentId,
124        name: String,
125        tokens_used: u64,
126        iterations: usize,
127        tool_calls: usize,
128        /// The final content returned by the subagent (for display and result delivery).
129        final_content: String,
130    },
131    SubAgentFailed {
132        agent_id: AgentId,
133        name: String,
134        error: String,
135    },
136
137    /// Domain-specific custom event
138    Custom {
139        name: String,
140        data: serde_json::Value,
141    },
142}
143
144impl AgentEvent {
145    pub fn agent_id(&self) -> Option<AgentId> {
146        match self {
147            Self::TaskStarted { agent_id, .. }
148            | Self::Thinking { agent_id, .. }
149            | Self::ToolCall { agent_id, .. }
150            | Self::ToolResult { agent_id, .. }
151            | Self::TaskCompleted { agent_id, .. }
152            | Self::TaskFailed { agent_id, .. }
153            | Self::PlanSubmitted { agent_id, .. }
154            | Self::PlanApproved { agent_id, .. }
155            | Self::PlanRejected { agent_id, .. }
156            | Self::TeammateIdle { agent_id, .. }
157            | Self::ShutdownRequested { agent_id, .. }
158            | Self::ShutdownAccepted { agent_id, .. }
159            | Self::ShutdownRejected { agent_id, .. }
160            | Self::TeammateSpawned { agent_id, .. }
161            | Self::AgentShutdown { agent_id, .. } => Some(*agent_id),
162            Self::TeammateMessage { from, .. } => Some(*from),
163            Self::SubAgentSpawned { agent_id, .. }
164            | Self::SubAgentCompleted { agent_id, .. }
165            | Self::SubAgentFailed { agent_id, .. } => Some(*agent_id),
166            Self::TeamSpawned { .. }
167            | Self::HookRejected { .. }
168            | Self::Custom { .. } => None,
169        }
170    }
171
172    /// Get the human-readable teammate name, if present.
173    pub fn agent_name(&self) -> Option<&str> {
174        match self {
175            Self::TeammateSpawned { name, .. }
176            | Self::TaskStarted { name, .. }
177            | Self::Thinking { name, .. }
178            | Self::ToolCall { name, .. }
179            | Self::ToolResult { name, .. }
180            | Self::TaskCompleted { name, .. }
181            | Self::TaskFailed { name, .. }
182            | Self::PlanSubmitted { name, .. }
183            | Self::PlanApproved { name, .. }
184            | Self::PlanRejected { name, .. }
185            | Self::TeammateIdle { name, .. }
186            | Self::ShutdownRequested { name, .. }
187            | Self::ShutdownAccepted { name, .. }
188            | Self::ShutdownRejected { name, .. }
189            | Self::AgentShutdown { name, .. } => Some(name),
190            Self::TeammateMessage { from_name, .. } => Some(from_name),
191            Self::SubAgentSpawned { name, .. }
192            | Self::SubAgentCompleted { name, .. }
193            | Self::SubAgentFailed { name, .. } => Some(name),
194            Self::TeamSpawned { .. }
195            | Self::HookRejected { .. }
196            | Self::Custom { .. } => None,
197        }
198    }
199}