feat(aura-cli): display LLM reasoning output for coordinator and workers

Shows "Reasoning: ..." output both at the top-level of the output, for
the coordinator, and in-line with a given task for worker reasoning.

Ref: GH-114

Author: justintime4tea

crates/aura-cli/src/api/stream.rs

@@ -49,6 +49,7 @@ pub async fn process_stream(
     on_tool_start: impl FnMut(&str, &str),
     on_tool_complete: impl FnMut(&str, &str, Duration, Option<&str>),
     on_usage: impl FnMut(u64, u64),
+    on_reasoning: impl FnMut(&str, &str, &BTreeMap<String, serde_json::Value>),
     on_raw_event: impl FnMut(&str, &str),
     on_orchestrator_event: impl FnMut(&str, &serde_json::Value),
 ) -> Result<StreamResult> {
@@ -61,6 +62,7 @@ pub async fn process_stream(
         on_tool_start,
         on_tool_complete,
         on_usage,
+        on_reasoning,
         on_raw_event,
         on_orchestrator_event,
     )
@@ -78,6 +80,7 @@ pub async fn process_stream(
 /// - `on_tool_start`: called when a tool begins execution with (tool_id, tool_name)
 /// - `on_tool_complete`: called when a tool finishes with (tool_id, tool_name, duration, result)
 /// - `on_usage`: called with (prompt_tokens, completion_tokens) from aura.usage events
+/// - `on_reasoning`: called for `aura.reasoning` events with (content, agent_id)
 /// - `on_orchestrator_event`: called for `aura.orchestrator.*`, `aura.session_info`, and `aura.progress` events
 ///
 /// `tool_id` is the per-call identifier emitted by the server. Callers should
@@ -94,6 +97,7 @@ pub async fn process_sse_events<S, E>(
     mut on_tool_start: impl FnMut(&str, &str),
     mut on_tool_complete: impl FnMut(&str, &str, Duration, Option<&str>),
     mut on_usage: impl FnMut(u64, u64),
+    mut on_reasoning: impl FnMut(&str, &str, &BTreeMap<String, serde_json::Value>),
     mut on_raw_event: impl FnMut(&str, &str),
     mut on_orchestrator_event: impl FnMut(&str, &serde_json::Value),
 ) -> Result<StreamResult>
@@ -213,9 +217,34 @@ where
                 "aura.tool_usage" => {
                     // Silently skip — usage is tracked via aura.usage at stream end
                 }
+                "aura.reasoning" => {
+                    // Parse the raw payload into a BTreeMap so the consumer
+                    // can render every wire-level field (agent_id, content,
+                    // parent_agent_id, session_id, trace_id, ...) in /expand
+                    // without us having to enumerate them here. Separately
+                    // extract `content` and `agent_id` as named args because
+                    // every consumer wants those for the live block header
+                    // and body.
+                    if let Ok(serde_json::Value::Object(map)) =
+                        serde_json::from_str::<serde_json::Value>(&event.data)
+                    {
+                        let content = map
+                            .get("content")
+                            .and_then(|v| v.as_str())
+                            .unwrap_or("")
+                            .to_string();
+                        let agent_id = map
+                            .get("agent_id")
+                            .and_then(|v| v.as_str())
+                            .unwrap_or("")
+                            .to_string();
+                        let fields: BTreeMap<String, serde_json::Value> = map.into_iter().collect();
+                        on_reasoning(&content, &agent_id, &fields);
+                    }
+                }
                 _ => {
                     // aura.orchestrator.*, aura.session_info, aura.progress,
-                    // aura.reasoning, aura.worker_phase, and any future events
+                    // aura.worker_phase, and any future events
                     if let Ok(val) = serde_json::from_str::<serde_json::Value>(&event.data) {
                         on_orchestrator_event(event_name, &val);
                     }
@@ -362,6 +391,7 @@ mod tests {
         tools_started: Vec<(String, String)>,
         tools_completed: Vec<(String, String, Option<String>)>,
         usages: Vec<(u64, u64)>,
+        reasoning: Vec<(String, String)>,
         raw_events: Vec<(String, String)>,
         orchestrator_events: Vec<(String, serde_json::Value)>,
     }
@@ -384,6 +414,7 @@ mod tests {
             let tools_started = &mut caps.tools_started;
             let tools_completed = &mut caps.tools_completed;
             let usages = &mut caps.usages;
+            let reasoning = &mut caps.reasoning;
             let raw_events = &mut caps.raw_events;
             let orchestrator_events = &mut caps.orchestrator_events;
 
@@ -403,6 +434,9 @@ mod tests {
                     ))
                 },
                 |p, c| usages.push((p, c)),
+                |content, agent_id, _fields| {
+                    reasoning.push((content.to_string(), agent_id.to_string()))
+                },
                 |name, data| raw_events.push((name.to_string(), data.to_string())),
                 |name, val| orchestrator_events.push((name.to_string(), val.clone())),
             )
@@ -735,6 +769,65 @@ mod tests {
         assert_eq!(caps.orchestrator_events[0].0, "aura.session_info");
     }
 
+    #[tokio::test]
+    async fn aura_reasoning_callback_fires() {
+        let data = serde_json::json!({
+            "content": "Let me think about this problem step by step.",
+            "agent_id": "main",
+            "session_id": "s1"
+        });
+        let events = vec![sse("aura.reasoning", &data.to_string()), sse("", "[DONE]")];
+        let (_, caps) = run_stream(events).await;
+        assert_eq!(caps.reasoning.len(), 1);
+        assert_eq!(
+            caps.reasoning[0].0,
+            "Let me think about this problem step by step."
+        );
+        assert_eq!(caps.reasoning[0].1, "main");
+        // Reasoning should NOT have been routed to the orchestrator fallback
+        assert!(caps.orchestrator_events.is_empty());
+        // But it IS a named event, so raw_event should have captured it
+        assert!(caps.raw_events.iter().any(|(n, _)| n == "aura.reasoning"));
+    }
+
+    #[tokio::test]
+    async fn aura_reasoning_callback_carries_worker_agent_id() {
+        // In orchestration mode the server emits aura.reasoning with the
+        // worker's agent_id so the CLI can attribute reasoning to a worker.
+        let data = serde_json::json!({
+            "content": "Analyzing the logs.",
+            "agent_id": "log_worker",
+            "parent_agent_id": "coordinator",
+            "session_id": "s1"
+        });
+        let events = vec![sse("aura.reasoning", &data.to_string()), sse("", "[DONE]")];
+        let (_, caps) = run_stream(events).await;
+        assert_eq!(caps.reasoning.len(), 1);
+        assert_eq!(caps.reasoning[0].1, "log_worker");
+    }
+
+    #[tokio::test]
+    async fn aura_reasoning_chunks_accumulate() {
+        let chunk = |c: &str| {
+            serde_json::json!({
+                "content": c,
+                "agent_id": "main",
+                "session_id": "s1"
+            })
+            .to_string()
+        };
+        let events = vec![
+            sse("aura.reasoning", &chunk("First, ")),
+            sse("aura.reasoning", &chunk("I'll check ")),
+            sse("aura.reasoning", &chunk("the inputs.")),
+            sse("", "[DONE]"),
+        ];
+        let (_, caps) = run_stream(events).await;
+        assert_eq!(caps.reasoning.len(), 3);
+        let joined: String = caps.reasoning.iter().map(|(c, _)| c.as_str()).collect();
+        assert_eq!(joined, "First, I'll check the inputs.");
+    }
+
     #[tokio::test]
     async fn aura_progress_routed_to_orchestrator() {
         let data = serde_json::json!({"message": "Discovering tools"});
@@ -802,6 +895,7 @@ mod tests {
             |_, _| {},
             |_, _, _, _| {},
             |_, _| {},
+            |_, _, _| {},
             |_, _| {},
             |_, _| {},
         )

crates/aura-cli/src/api/types.rs

@@ -298,6 +298,19 @@ pub enum DisplayEvent {
         tokens_intercepted: u64,
         tokens_extracted: u64,
     },
+    /// LLM reasoning content (e.g. Anthropic extended thinking, Bedrock, etc...).
+    /// `agent_id` identifies which agent produced it — `"main"` for single-agent,
+    /// the worker name (e.g. `"log_worker"`) when emitted by an orchestration worker.
+    /// `content` holds the final accumulated text for the whole reasoning stretch
+    /// (one `DisplayEvent::Reasoning` per agent-contiguous stretch, not per delta).
+    /// `fields` carries the raw SSE payload (agent_id, content, parent_agent_id,
+    /// session_id, trace_id, ...) so /expand can render a complete fields tree.
+    Reasoning {
+        content: String,
+        agent_id: String,
+        #[serde(default)]
+        fields: BTreeMap<String, serde_json::Value>,
+    },
 }
 
 /// Convert a snake_case string to PascalCase. E.g. `get_me` → `GetMe`.

crates/aura-cli/src/backend/direct.rs

@@ -244,6 +244,7 @@ impl DirectBackend {
         on_tool_start: impl FnMut(&str, &str),
         on_tool_complete: impl FnMut(&str, &str, Duration, Option<&str>),
         on_usage: impl FnMut(u64, u64),
+        on_reasoning: impl FnMut(&str, &str, &BTreeMap<String, serde_json::Value>),
         on_raw_event: impl FnMut(&str, &str),
         on_orchestrator_event: impl FnMut(&str, &serde_json::Value),
     ) -> Result<StreamResult> {
@@ -291,6 +292,7 @@ impl DirectBackend {
             on_tool_start,
             on_tool_complete,
             on_usage,
+            on_reasoning,
             on_raw_event,
             on_orchestrator_event,
         )

crates/aura-cli/src/backend/http.rs

@@ -37,6 +37,7 @@ impl HttpBackend {
         on_tool_start: impl FnMut(&str, &str),
         on_tool_complete: impl FnMut(&str, &str, Duration, Option<&str>),
         on_usage: impl FnMut(u64, u64),
+        on_reasoning: impl FnMut(&str, &str, &BTreeMap<String, serde_json::Value>),
         on_raw_event: impl FnMut(&str, &str),
         on_orchestrator_event: impl FnMut(&str, &serde_json::Value),
     ) -> Result<StreamResult> {
@@ -52,6 +53,7 @@ impl HttpBackend {
             on_tool_start,
             on_tool_complete,
             on_usage,
+            on_reasoning,
             on_raw_event,
             on_orchestrator_event,
         )

crates/aura-cli/src/backend/mod.rs

@@ -67,6 +67,7 @@ impl Backend {
         on_tool_start: impl FnMut(&str, &str),
         on_tool_complete: impl FnMut(&str, &str, Duration, Option<&str>),
         on_usage: impl FnMut(u64, u64),
+        on_reasoning: impl FnMut(&str, &str, &BTreeMap<String, serde_json::Value>),
         on_raw_event: impl FnMut(&str, &str),
         on_orchestrator_event: impl FnMut(&str, &serde_json::Value),
     ) -> Result<StreamResult> {
@@ -82,6 +83,7 @@ impl Backend {
                     on_tool_start,
                     on_tool_complete,
                     on_usage,
+                    on_reasoning,
                     on_raw_event,
                     on_orchestrator_event,
                 )
@@ -100,6 +102,7 @@ impl Backend {
                         on_tool_start,
                         on_tool_complete,
                         on_usage,
+                        on_reasoning,
                         on_raw_event,
                         on_orchestrator_event,
                     )

crates/aura-cli/src/oneshot.rs

@@ -95,6 +95,11 @@ pub fn run_oneshot(
                     |_tool_id, _tool_name| {},
                     |_tool_id, _tool_name, _duration, _result: Option<&str>| {},
                     |_prompt_tokens, _completion_tokens| {},
+                    // on_reasoning — no-op in oneshot mode (reasoning chunks
+                    // would interleave with the rendered response; the user
+                    // asked for the answer, not the thought process)
+                    |_content, _agent_id, _fields| {},
+                    // on_raw_event — no-op in oneshot mode
                     |_event_name, _event_data| {},
                     |_event_name, _val| {},
                 )