use serde::{Deserialize, Serialize};
use crate::{Step, StepStatus};
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum DelegationState {
#[default]
Queued,
Running,
Done,
Failed,
Stopped,
}
impl DelegationState {
pub fn finished(self) -> bool {
matches!(self, Self::Done | Self::Failed | Self::Stopped)
}
pub fn label(self) -> &'static str {
match self {
Self::Queued => "queued",
Self::Running => "running",
Self::Done => "done",
Self::Failed => "failed",
Self::Stopped => "stopped",
}
}
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Delegation {
pub agent: String,
pub task: String,
#[serde(default)]
pub model: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub profile: Option<String>,
#[serde(default)]
pub state: DelegationState,
#[serde(default)]
pub content: String,
#[serde(default)]
pub reasoning: String,
#[serde(default)]
pub steps: Vec<Step>,
#[serde(default)]
pub prompt_tokens: u64,
#[serde(default)]
pub completion_tokens: u64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error: Option<String>,
}
impl Delegation {
pub fn status_line(&self) -> String {
let n = self.steps.len();
let tools = if n == 1 { "1 tool".to_owned() } else { format!("{n} tools") };
let state = if self.steps.iter().any(|s| s.status == StepStatus::Waiting) { "waiting for approval" } else { self.state.label() };
format!("{} · {tools} · {state}", self.agent)
}
pub fn apply(&mut self, update: &DelegationUpdate) {
match update {
DelegationUpdate::Delta { content, reasoning } => {
self.content.push_str(content);
self.reasoning.push_str(reasoning);
}
DelegationUpdate::Step(step) => match self.steps.iter_mut().find(|s| s.id == step.id) {
Some(existing) => *existing = (**step).clone(),
None => self.steps.push((**step).clone()),
},
DelegationUpdate::Status { state, prompt_tokens, completion_tokens, error } => {
self.state = *state;
self.prompt_tokens = *prompt_tokens;
self.completion_tokens = *completion_tokens;
self.error.clone_from(error);
}
DelegationUpdate::Other => {}
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum DelegationUpdate {
Delta { content: String, reasoning: String },
Step(Box<Step>),
Status {
state: DelegationState,
prompt_tokens: u64,
completion_tokens: u64,
#[serde(default, skip_serializing_if = "Option::is_none")]
error: Option<String>,
},
#[serde(other)]
Other,
}