use std::pin::Pin;
use std::sync::Arc;
use crate::protocol::{
AssistantBlock, BackgroundTask, InboundMessage, InboundUserMessage, ResultMessage, TurnErrorKind,
UserMessage,
};
use crate::session::{Session, SessionError};
#[derive(Debug, Clone)]
pub enum AgentEvent {
Text(String),
Thinking(String),
RedactedThinking(String),
ToolUse { id: String, name: String, input: serde_json::Value, server: bool },
ToolResult {
tool_use_id: String,
content: serde_json::Value,
is_error: bool,
structured: Option<serde_json::Value>,
},
Subagent { parent_tool_use_id: String, event: Box<AgentEvent> },
BackgroundTasks(Vec<BackgroundTask>),
ModelFallback { from: String, to: String, trigger: String },
Compacted { trigger: String, pre_tokens: Option<u64>, post_tokens: Option<u64> },
System { subtype: String, data: serde_json::Value },
Other { kind: String, data: serde_json::Value },
Done(TurnResult),
Error(TurnError),
}
#[derive(Debug, Clone)]
pub struct TurnResult {
pub session_id: Option<String>,
pub result: Option<String>,
pub structured_output: Option<serde_json::Value>,
pub total_cost_usd: Option<f64>,
pub ttft_ms: Option<u64>,
pub duration_ms: Option<u64>,
pub duration_api_ms: Option<u64>,
pub num_turns: Option<u64>,
pub input_tokens: Option<u64>,
pub output_tokens: Option<u64>,
pub cache_read_input_tokens: Option<u64>,
pub cache_creation_input_tokens: Option<u64>,
pub model_usage: Option<serde_json::Value>,
pub stop_reason: Option<String>,
pub terminal_reason: Option<String>,
pub permission_denials: Vec<serde_json::Value>,
pub origin: Option<serde_json::Value>,
}
impl From<&ResultMessage> for TurnResult {
fn from(r: &ResultMessage) -> Self {
let usage = r.usage.as_ref();
TurnResult {
session_id: r.session_id.clone(),
result: r.result.clone(),
structured_output: r.structured_output.clone(),
total_cost_usd: r.total_cost_usd,
ttft_ms: r.ttft_ms,
duration_ms: r.duration_ms,
duration_api_ms: r.duration_api_ms,
num_turns: r.num_turns,
input_tokens: usage.map(|u| u.input_tokens),
output_tokens: usage.map(|u| u.output_tokens),
cache_read_input_tokens: usage.and_then(|u| u.cache_read_input_tokens),
cache_creation_input_tokens: usage.and_then(|u| u.cache_creation_input_tokens),
model_usage: r.model_usage.clone(),
stop_reason: r.stop_reason.clone(),
terminal_reason: r.terminal_reason.clone(),
permission_denials: r.permission_denials.clone(),
origin: r.origin.clone(),
}
}
}
#[derive(Debug, Clone, thiserror::Error)]
#[error("{message}")]
pub struct TurnError {
pub kind: TurnErrorKind,
pub message: String,
pub result: Option<TurnResult>,
}
impl From<&ResultMessage> for TurnError {
fn from(r: &ResultMessage) -> Self {
TurnError { kind: r.error_kind(), message: r.error_message(), result: Some(TurnResult::from(r)) }
}
}
impl TurnError {
fn cancelled() -> Self {
TurnError { kind: TurnErrorKind::Cancelled, message: "prompt cancelled before it ran".into(), result: None }
}
fn session_closed() -> Self {
TurnError {
kind: TurnErrorKind::SessionClosed,
message: "session closed before the turn finished".into(),
result: None,
}
}
}
#[derive(Debug, thiserror::Error)]
pub enum AgentError {
#[error("session error: {0}")]
Session(#[from] SessionError),
#[error("json: {0}")]
Json(#[from] serde_json::Error),
}
pub type AgentStream = Pin<Box<dyn tokio_stream::Stream<Item = AgentEvent> + Send + 'static>>;
pub struct Agent {
session: Session,
}
impl Agent {
pub fn new(session: Session) -> Self {
Self { session }
}
pub fn session(&self) -> &Session {
&self.session
}
pub async fn prompt(&self, text: impl Into<String>) -> Result<AgentStream, AgentError> {
self.prompt_message(UserMessage::text(text.into())).await
}
pub async fn prompt_message(&self, message: UserMessage) -> Result<AgentStream, AgentError> {
let mut rx = self.session.subscribe();
let uuid = message.uuid.clone();
self.session.send_prompt(&message).await?;
let partial = self.session.include_partial();
let span = tracing::info_span!(
"claude.turn",
session_id = self.session.session_id().unwrap_or_default(),
cost_usd = tracing::field::Empty,
input_tokens = tracing::field::Empty,
output_tokens = tracing::field::Empty,
ttft_ms = tracing::field::Empty,
error = tracing::field::Empty,
);
let mut guard = CancelOnDrop { session: self.session.clone(), uuid: uuid.clone(), armed: true };
let stream = async_stream::stream! {
let mut started = false;
let mut held: Vec<Arc<InboundMessage>> = vec![];
loop {
let Some(msg) = rx.recv().await else {
guard.disarm();
yield AgentEvent::Error(TurnError::session_closed());
break;
};
if let InboundMessage::Other(frame) = msg.as_ref()
&& is_cancelled(frame, &uuid)
{
guard.disarm();
yield AgentEvent::Error(TurnError::cancelled());
break;
}
if !started {
match msg.as_ref() {
InboundMessage::User(u) if u.uuid.as_deref() == Some(uuid.as_str()) => {
started = true;
for m in held.drain(..) {
for ev in to_events(&m, partial) {
yield ev;
}
}
}
InboundMessage::Result(r) if r.answers(&uuid) => {
started = true;
for m in held.drain(..) {
for ev in to_events(&m, partial) {
yield ev;
}
}
}
InboundMessage::Result(_) => {
held.clear();
continue;
}
_ => {
held.push(msg);
continue;
}
}
if !matches!(msg.as_ref(), InboundMessage::Result(_)) {
continue;
}
}
if let InboundMessage::Result(r) = msg.as_ref() {
guard.disarm();
let t = TurnResult::from(r);
if let Some(v) = t.total_cost_usd { span.record("cost_usd", v); }
if let Some(v) = t.input_tokens { span.record("input_tokens", v); }
if let Some(v) = t.output_tokens { span.record("output_tokens", v); }
if let Some(v) = t.ttft_ms { span.record("ttft_ms", v); }
if !r.is_success() { span.record("error", r.subtype.as_str()); }
}
let done = matches!(msg.as_ref(), InboundMessage::Result(_));
for ev in to_events(&msg, partial) {
yield ev;
}
if done {
break;
}
}
};
Ok(Box::pin(stream))
}
pub fn watch(&self) -> AgentStream {
let mut rx = self.session.subscribe();
let partial = self.session.include_partial();
Box::pin(async_stream::stream! {
while let Some(msg) = rx.recv().await {
for ev in to_events(&msg, partial) {
yield ev;
}
}
})
}
}
struct CancelOnDrop {
session: Session,
uuid: String,
armed: bool,
}
impl CancelOnDrop {
fn disarm(&mut self) {
self.armed = false;
}
}
impl Drop for CancelOnDrop {
fn drop(&mut self) {
if !self.armed || !self.session.is_alive() {
return;
}
let Ok(rt) = tokio::runtime::Handle::try_current() else {
tracing::warn!("turn stream dropped outside a Tokio runtime; the turn keeps running");
return;
};
let session = self.session.clone();
let uuid = std::mem::take(&mut self.uuid);
rt.spawn(async move {
if let Err(e) = session.cancel_prompt(&uuid).await {
tracing::debug!(error = %e, "cancelling a dropped turn failed");
}
});
}
}
fn to_events(msg: &InboundMessage, partial: bool) -> Vec<AgentEvent> {
match msg {
InboundMessage::Assistant(a) => {
let sub = a.parent_tool_use_id.is_some();
let events = a.message.content.iter().filter_map(|block| match block {
AssistantBlock::Text { text } if sub || !partial => Some(AgentEvent::Text(text.clone())),
AssistantBlock::Thinking { thinking } if sub || !partial => {
Some(AgentEvent::Thinking(thinking.clone()))
}
AssistantBlock::RedactedThinking { data } => Some(AgentEvent::RedactedThinking(data.clone())),
AssistantBlock::ToolUse { id, name, input } => Some(AgentEvent::ToolUse {
id: id.clone(),
name: name.clone(),
input: input.clone(),
server: false,
}),
AssistantBlock::ServerToolUse { id, name, input } => Some(AgentEvent::ToolUse {
id: id.clone(),
name: name.clone(),
input: input.clone(),
server: true,
}),
AssistantBlock::WebSearchToolResult { tool_use_id, content } => Some(AgentEvent::ToolResult {
tool_use_id: tool_use_id.clone(),
content: content.clone(),
is_error: false,
structured: None,
}),
_ => None,
});
in_thread(a.parent_tool_use_id.as_deref(), events.collect())
}
InboundMessage::User(u) => in_thread(u.parent_tool_use_id.as_deref(), tool_results(u)),
InboundMessage::StreamEvent(se) if se.parent_tool_use_id.is_none() => {
let delta = se.event.get("delta");
let text = delta.and_then(|d| d.get("text")).and_then(|t| t.as_str());
let thinking = delta.and_then(|d| d.get("thinking")).and_then(|t| t.as_str());
text.map(|t| AgentEvent::Text(t.to_string()))
.into_iter()
.chain(thinking.map(|t| AgentEvent::Thinking(t.to_string())))
.collect()
}
InboundMessage::System(s) => match s.subtype.as_str() {
"background_tasks_changed" => {
let tasks = s.extra.get("tasks").cloned().unwrap_or_default();
match serde_json::from_value::<Vec<BackgroundTask>>(tasks) {
Ok(tasks) => vec![AgentEvent::BackgroundTasks(tasks)],
Err(e) => {
tracing::debug!(error = %e, "undecodable background_tasks_changed");
vec![]
}
}
}
"model_fallback" => {
let field = |k: &str| s.extra.get(k).and_then(|v| v.as_str()).unwrap_or("").to_string();
vec![AgentEvent::ModelFallback {
from: field("original_model"),
to: field("fallback_model"),
trigger: field("trigger"),
}]
}
"compact_boundary" => {
let meta = s.extra.get("compact_metadata");
let num = |k: &str| meta.and_then(|m| m.get(k)).and_then(|v| v.as_u64());
vec![AgentEvent::Compacted {
trigger: meta.and_then(|m| m.get("trigger")).and_then(|v| v.as_str()).unwrap_or("").to_string(),
pre_tokens: num("pre_tokens"),
post_tokens: num("post_tokens"),
}]
}
other => vec![AgentEvent::System {
subtype: other.to_string(),
data: serde_json::to_value(s).unwrap_or_default(),
}],
},
InboundMessage::Other(data) => vec![AgentEvent::Other {
kind: data.get("type").and_then(|t| t.as_str()).unwrap_or("").to_string(),
data: data.clone(),
}],
InboundMessage::Result(r) if r.is_success() => vec![AgentEvent::Done(TurnResult::from(r))],
InboundMessage::Result(r) => vec![AgentEvent::Error(TurnError::from(r))],
_ => vec![],
}
}
fn tool_results(u: &InboundUserMessage) -> Vec<AgentEvent> {
let results = u.tool_results();
let structured = if results.len() == 1 { u.tool_use_result.clone() } else { None };
results
.into_iter()
.map(|r| AgentEvent::ToolResult {
tool_use_id: r.tool_use_id,
content: r.content,
is_error: r.is_error,
structured: structured.clone(),
})
.collect()
}
fn is_cancelled(frame: &serde_json::Value, uuid: &str) -> bool {
let field = |k: &str| frame.get(k).and_then(|v| v.as_str());
field("type") == Some("command_lifecycle")
&& field("state") == Some("cancelled")
&& field("command_uuid").is_some_and(|u| u.eq_ignore_ascii_case(uuid))
}
fn in_thread(parent: Option<&str>, events: Vec<AgentEvent>) -> Vec<AgentEvent> {
match parent {
None => events,
Some(p) => events
.into_iter()
.map(|event| AgentEvent::Subagent { parent_tool_use_id: p.to_string(), event: Box::new(event) })
.collect(),
}
}