use serde_json::Value;
#[derive(Debug, Clone)]
pub struct AgentStatus {
pub execution_id: String,
pub is_complete: bool,
pub is_running: bool,
pub is_waiting: bool,
pub output: Value,
pub status: String,
pub reason: Option<String>,
pub pending_tool: Option<Value>,
}
impl AgentStatus {
pub fn from_response(execution_id: impl Into<String>, data: &Value) -> Self {
Self {
execution_id: execution_id.into(),
is_complete: data
.get("isComplete")
.and_then(Value::as_bool)
.unwrap_or(false),
is_running: data
.get("isRunning")
.and_then(Value::as_bool)
.unwrap_or(false),
is_waiting: data
.get("isWaiting")
.and_then(Value::as_bool)
.unwrap_or(false),
output: data.get("output").cloned().unwrap_or(Value::Null),
status: data
.get("status")
.and_then(Value::as_str)
.unwrap_or("UNKNOWN")
.to_owned(),
reason: data
.get("reasonForIncompletion")
.and_then(Value::as_str)
.map(str::to_owned),
pending_tool: data.get("pendingTool").cloned(),
}
}
#[must_use]
pub fn is_terminal(&self) -> bool {
self.is_complete
}
}
#[derive(Debug, Clone, PartialEq, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolCallRecord {
pub name: String,
pub args: Value,
pub result: Option<Value>,
}
#[derive(Debug, Clone, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AgentResult {
pub execution_id: String,
pub output: Value,
pub status: String,
pub error: Option<String>,
#[serde(default)]
pub tool_calls: Vec<ToolCallRecord>,
}
impl AgentResult {
#[must_use]
pub fn from_status(status: AgentStatus) -> Self {
let error = match status.status.as_str() {
"FAILED" | "TERMINATED" => status.reason,
_ => None,
};
Self {
execution_id: status.execution_id,
output: status.output,
status: status.status,
error,
tool_calls: Vec::new(),
}
}
#[must_use]
pub fn is_success(&self) -> bool {
self.status == "COMPLETED"
}
#[must_use]
pub fn is_failed(&self) -> bool {
matches!(self.status.as_str(), "FAILED" | "TERMINATED" | "TIMED_OUT")
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn test_from_response_reads_running_status() {
let data = json!({
"status": "RUNNING",
"isRunning": true,
});
let status = AgentStatus::from_response("exec-1", &data);
assert_eq!(status.execution_id, "exec-1");
assert_eq!(status.status, "RUNNING");
assert!(status.is_running);
assert!(!status.is_complete);
assert!(!status.is_waiting);
assert_eq!(status.output, Value::Null);
assert!(status.reason.is_none());
assert!(!status.is_terminal());
}
#[test]
fn test_from_response_reads_waiting_status_with_pending_tool() {
let data = json!({
"status": "RUNNING",
"isWaiting": true,
"pendingTool": {"name": "send_email", "args": {"to": "a@example.com"}},
});
let status = AgentStatus::from_response("exec-2", &data);
assert!(status.is_waiting);
assert!(!status.is_terminal());
assert_eq!(
status.pending_tool,
Some(json!({"name": "send_email", "args": {"to": "a@example.com"}}))
);
}
#[test]
fn test_from_response_reads_completed_status_with_output() {
let data = json!({
"status": "COMPLETED",
"isComplete": true,
"output": {"result": "PROBE OK"},
});
let status = AgentStatus::from_response("exec-3", &data);
assert!(status.is_terminal());
assert_eq!(status.output, json!({"result": "PROBE OK"}));
}
#[test]
fn test_from_response_reads_failed_status_with_reason() {
let data = json!({
"status": "FAILED",
"isComplete": true,
"reasonForIncompletion": "tool call exceeded retry budget",
});
let status = AgentStatus::from_response("exec-4", &data);
assert!(status.is_terminal());
assert_eq!(
status.reason.as_deref(),
Some("tool call exceeded retry budget")
);
}
#[test]
fn test_from_response_defaults_missing_status_to_unknown() {
let status = AgentStatus::from_response("exec-5", &json!({}));
assert_eq!(status.status, "UNKNOWN");
assert!(!status.is_terminal());
}
#[test]
fn test_from_response_does_not_read_execution_id_from_body() {
let status =
AgentStatus::from_response("exec-caller-supplied", &json!({"executionId": "other"}));
assert_eq!(status.execution_id, "exec-caller-supplied");
}
#[test]
fn test_agent_result_from_completed_status() {
let status = AgentStatus::from_response(
"exec-6",
&json!({"status": "COMPLETED", "isComplete": true, "output": {"result": "done"}}),
);
let result = AgentResult::from_status(status);
assert_eq!(result.execution_id, "exec-6");
assert_eq!(result.output, json!({"result": "done"}));
assert_eq!(result.status, "COMPLETED");
assert!(result.error.is_none());
assert!(result.is_success());
assert!(!result.is_failed());
}
#[test]
fn test_agent_result_surfaces_error_for_failed_status() {
let status = AgentStatus::from_response(
"exec-7",
&json!({"status": "FAILED", "isComplete": true, "reasonForIncompletion": "boom"}),
);
let result = AgentResult::from_status(status);
assert_eq!(result.error.as_deref(), Some("boom"));
assert!(!result.is_success());
assert!(result.is_failed());
}
#[test]
fn test_agent_result_surfaces_error_for_terminated_status() {
let status = AgentStatus::from_response(
"exec-8",
&json!({"status": "TERMINATED", "isComplete": true, "reasonForIncompletion": "cancelled by user"}),
);
let result = AgentResult::from_status(status);
assert_eq!(result.error.as_deref(), Some("cancelled by user"));
assert!(result.is_failed());
}
#[test]
fn test_agent_result_does_not_surface_error_for_timed_out_status() {
let status = AgentStatus::from_response(
"exec-9",
&json!({"status": "TIMED_OUT", "isComplete": true, "reasonForIncompletion": "exceeded timeoutSeconds"}),
);
let result = AgentResult::from_status(status);
assert!(result.error.is_none());
assert!(result.is_failed());
}
}