feat: add reasoning event support to Gemini CLI bridge

components/runners/ambient-runner/ag_ui_gemini_cli/adapter.py

@@ -28,9 +28,18 @@
     MessagesSnapshotEvent,
 )
 
+from ag_ui_claude_sdk.reasoning_events import (
+    ReasoningStartEvent,
+    ReasoningEndEvent,
+    ReasoningMessageStartEvent,
+    ReasoningMessageContentEvent,
+    ReasoningMessageEndEvent,
+)
+
 from .types import (
     InitEvent,
     MessageEvent,
+    ThinkingEvent,
     ToolUseEvent,
     ToolResultEvent,
     ErrorEvent,
@@ -65,6 +74,9 @@ def _summarize_event(event: object) -> str:
         return f"severity={event.severity} msg={event.message[:80]}"
     if isinstance(event, ResultEvent):
         return f"status={event.status} stats={event.stats}"
+    if isinstance(event, ThinkingEvent):
+        preview = (event.content or "")[:80]
+        return f"delta={event.delta} content={preview!r}"
     return ""
 
 
@@ -100,6 +112,10 @@ async def run(
         accumulated_text = ""
         message_timestamp_ms: int | None = None
 
+        # Reasoning/thinking state
+        reasoning_open = False
+        reasoning_message_id: str | None = None
+
         # Tool tracking
         current_tool_call_id: str | None = None
 
@@ -142,12 +158,67 @@ async def run(
                     )
                     continue
 
+                # ── thinking ──
+                if isinstance(event, ThinkingEvent):
+                    if not reasoning_open:
+                        reasoning_message_id = str(uuid.uuid4())
+                        yield ReasoningStartEvent(
+                            threadId=thread_id,
+                            runId=run_id,
+                            messageId=reasoning_message_id,
+                        )
+                        yield ReasoningMessageStartEvent(
+                            threadId=thread_id,
+                            runId=run_id,
+                            messageId=reasoning_message_id,
+                        )
+                        reasoning_open = True
+
+                    if event.content:
+                        yield ReasoningMessageContentEvent(
+                            threadId=thread_id,
+                            runId=run_id,
+                            messageId=reasoning_message_id,
+                            delta=event.content,
+                        )
+
+                    # Non-delta thinking: close immediately
+                    if not event.delta and reasoning_open:
+                        yield ReasoningMessageEndEvent(
+                            threadId=thread_id,
+                            runId=run_id,
+                            messageId=reasoning_message_id,
+                        )
+                        yield ReasoningEndEvent(
+                            threadId=thread_id,
+                            runId=run_id,
+                            messageId=reasoning_message_id,
+                        )
+                        reasoning_open = False
+                        reasoning_message_id = None
+                    continue
+
                 # ── message (assistant, delta) ──
                 if isinstance(event, MessageEvent):
                     # Skip user messages (already in input)
                     if event.role == "user":
                         continue
 
+                    # Close open reasoning block before text output
+                    if reasoning_open and reasoning_message_id:
+                        yield ReasoningMessageEndEvent(
+                            threadId=thread_id,
+                            runId=run_id,
+                            messageId=reasoning_message_id,
+                        )
+                        yield ReasoningEndEvent(
+                            threadId=thread_id,
+                            runId=run_id,
+                            messageId=reasoning_message_id,
+                        )
+                        reasoning_open = False
+                        reasoning_message_id = None
+
                     if event.role == "assistant" and event.delta:
                         # First text chunk: open a text message
                         if not text_message_open:
@@ -218,6 +289,21 @@ async def run(
 
                 # ── tool_use ──
                 if isinstance(event, ToolUseEvent):
+                    # Close open reasoning block before tool call
+                    if reasoning_open and reasoning_message_id:
+                        yield ReasoningMessageEndEvent(
+                            threadId=thread_id,
+                            runId=run_id,
+                            messageId=reasoning_message_id,
+                        )
+                        yield ReasoningEndEvent(
+                            threadId=thread_id,
+                            runId=run_id,
+                            messageId=reasoning_message_id,
+                        )
+                        reasoning_open = False
+                        reasoning_message_id = None
+
                     # Close any open text message before tool call
                     if text_message_open and current_message_id:
                         yield TextMessageEndEvent(
@@ -356,6 +442,19 @@ async def run(
 
         except Exception as exc:
             logger.error("Error in Gemini CLI adapter run: %s", exc)
+            # Clean up open reasoning block
+            if reasoning_open and reasoning_message_id:
+                try:
+                    yield ReasoningMessageEndEvent(
+                        threadId=thread_id, runId=run_id, messageId=reasoning_message_id,
+                    )
+                    yield ReasoningEndEvent(
+                        threadId=thread_id, runId=run_id, messageId=reasoning_message_id,
+                    )
+                except Exception:
+                    pass
+                reasoning_open = False
+
             # Clean up open text message
             if text_message_open and current_message_id:
                 try:
@@ -374,6 +473,18 @@ async def run(
                 message=str(exc),
             )
         finally:
+            # Safety: close any hanging reasoning block
+            if reasoning_open and reasoning_message_id:
+                try:
+                    yield ReasoningMessageEndEvent(
+                        threadId=thread_id, runId=run_id, messageId=reasoning_message_id,
+                    )
+                    yield ReasoningEndEvent(
+                        threadId=thread_id, runId=run_id, messageId=reasoning_message_id,
+                    )
+                except Exception:
+                    pass
+
             # Safety: close any hanging text message
             if text_message_open and current_message_id:
                 try:

components/runners/ambient-runner/ag_ui_gemini_cli/types.py

@@ -1,4 +1,4 @@
-"""Dataclasses for the 6 Gemini CLI JSONL event types."""
+"""Dataclasses for Gemini CLI JSONL event types."""
 
 import json
 import logging
@@ -8,7 +8,7 @@
 
 # Type tag used to dispatch parsed events.
 _EVENT_TYPES = frozenset(
-    {"init", "message", "tool_use", "tool_result", "error", "result"}
+    {"init", "message", "tool_use", "tool_result", "error", "result", "thinking"}
 )
 
 
@@ -65,19 +65,36 @@ class ResultEvent:
     stats: dict | None = None
 
 
+@dataclass
+class ThinkingEvent:
+    """Gemini CLI thinking/reasoning event.
+
+    Emitted when the model produces reasoning traces (requires the CLI to
+    expose ``thinking`` events in its ``stream-json`` output).  The Gemini
+    CLI internally tracks thinking via a ``ThoughtSummary`` structure with
+    ``subject`` and ``description`` fields.
+    """
+
+    type: str  # "thinking"
+    timestamp: str
+    content: str = ""
+    delta: bool = False
+
+
 _TYPE_MAP = {
     "init": InitEvent,
     "message": MessageEvent,
     "tool_use": ToolUseEvent,
     "tool_result": ToolResultEvent,
     "error": ErrorEvent,
     "result": ResultEvent,
+    "thinking": ThinkingEvent,
 }
 
 
 def parse_event(
     line: str,
-) -> InitEvent | MessageEvent | ToolUseEvent | ToolResultEvent | ErrorEvent | ResultEvent | None:
+) -> InitEvent | MessageEvent | ToolUseEvent | ToolResultEvent | ErrorEvent | ResultEvent | ThinkingEvent | None:
     """Parse a JSON line into the appropriate event dataclass.
 
     Returns ``None`` when the line cannot be parsed or has an unknown type.