use crate::commands::api::ApiClient;
use crate::contract;
use crate::events::{DELTA_EVENTS, EventStream};
use crate::output::OutputFormat;
use anyhow::Result;
use serde_json::json;
use std::time::{Duration, Instant};
#[allow(clippy::too_many_arguments)]
pub async fn run(
client: ApiClient<'_>,
output: OutputFormat,
quiet: bool,
message: String,
session_id: String,
timeout_secs: Option<u64>,
no_stream: bool,
) -> Result<()> {
let snapshot_id: Option<String> = if no_stream {
None
} else {
let latest = contract::execute(
&client,
"list_events",
json!({ "session_id": session_id, "limit": 1, "order_desc": true }),
)
.await?;
latest["data"][0]["id"].as_str().map(ToOwned::to_owned)
};
contract::execute(
&client,
"create_message",
json!({
"session_id": session_id,
"message": { "role": "user", "content": [{ "type": "text", "text": message }] },
}),
)
.await?;
if !quiet && output.is_text() {
println!("You: {}\n", message);
}
if no_stream {
return Ok(());
}
let mut stream = EventStream::new(client, &session_id, snapshot_id)
.excluding(DELTA_EVENTS)
.with_max_retries(10);
let start = Instant::now();
let timeout = timeout_secs.map(Duration::from_secs);
let mut agent_content = String::new();
loop {
if let Some(timeout) = timeout
&& start.elapsed() > timeout
{
if output.is_text() {
eprintln!("\nTimeout waiting for response");
}
anyhow::bail!("Timeout waiting for response");
}
let next = if let Some(t) = timeout {
let remaining = t.saturating_sub(start.elapsed());
tokio::time::timeout(remaining, stream.next()).await
} else {
Ok(stream.next().await)
};
let item = match next {
Ok(Some(item)) => item,
Ok(None) => {
if output.is_text() && !agent_content.is_empty() {
println!("Agent: {}", agent_content);
}
anyhow::bail!("Event stream ended before turn completed");
}
Err(_) => {
if output.is_text() {
eprintln!("\nTimeout waiting for response");
}
anyhow::bail!("Timeout waiting for response");
}
};
let event = match item {
Ok(event) => event,
Err(e) => {
anyhow::bail!("Event stream failed: {e}");
}
};
if output.is_text() {
if event.event_type == "output.message.completed" {
let content = event
.data
.get("content")
.or_else(|| event.data.get("message").and_then(|m| m.get("content")));
if let Some(content) = content
&& let Some(parts) = content.as_array()
{
for part in parts {
if let Some(text) = part.get("text").and_then(|t| t.as_str()) {
agent_content.push_str(text);
}
}
}
}
if event.event_type == "tool.progress"
&& let Some(message) = event.data.get("message").and_then(|m| m.as_str())
{
let tool = event
.data
.get("display_name")
.or_else(|| event.data.get("tool_name"))
.and_then(|t| t.as_str())
.unwrap_or("tool");
eprintln!(" [{tool}] {message}");
}
if event.event_type == "tool.output.delta"
&& let Some(delta) = event.data.get("delta").and_then(|d| d.as_str())
{
let stream_name = event
.data
.get("stream")
.and_then(|s| s.as_str())
.unwrap_or("stdout");
let tool = event
.data
.get("tool_name")
.and_then(|t| t.as_str())
.unwrap_or("tool");
let trimmed = delta.trim_end_matches('\n');
if stream_name == "stderr" {
eprintln!(" [{tool}:stderr] {trimmed}");
} else {
eprintln!(" [{tool}] {trimmed}");
}
}
if event.event_type == "turn.completed" {
if !agent_content.is_empty() {
println!("Agent: {}", agent_content);
}
return Ok(());
}
if event.event_type == "turn.failed" {
let error = event
.data
.get("error")
.and_then(|e| e.as_str())
.unwrap_or("Unknown error");
eprintln!("\nTurn failed: {}", error);
anyhow::bail!("Turn failed: {}", error);
}
} else {
output.print_value(&event.to_json());
if event.event_type == "turn.completed" {
return Ok(());
}
if event.event_type == "turn.failed" {
anyhow::bail!("Turn failed");
}
}
}
}