Merge branch 'main' into rel-1.9.0

Author: malhotra5

openhands_cli/acp_impl/events/shared_event_handler.py

@@ -164,7 +164,11 @@ async def handle_observation(
     async def handle_action_event(self, ctx: _ACPContext, event: ActionEvent):
         content = None
         tool_kind = get_tool_kind(tool_name=event.tool_name, action=event.action)
-        title = get_tool_title(tool_name=event.tool_name, action=event.action)
+        # Use LLM-generated summary for the title when available
+        summary = str(event.summary) if event.summary else None
+        title = get_tool_title(
+            tool_name=event.tool_name, action=event.action, summary=summary
+        )
         if event.action:
             action_viz = _event_visualize_to_plain(event)
             content = format_content_blocks(action_viz)

openhands_cli/acp_impl/events/token_streamer.py

@@ -108,6 +108,40 @@ def _prune_tool_call_state(self, tool_call_id: str) -> None:
         for idx in indices_to_remove:
             del self._streaming_tool_calls[idx]
 
+    def _is_tool_call_started(self, tool_call_id: str) -> bool:
+        """Check if a tool call was already started during streaming."""
+        return any(
+            state.tool_call_id == tool_call_id and state.started
+            for state in self._streaming_tool_calls.values()
+        )
+
+    async def _update_tool_call_with_summary(self, event: ActionEvent) -> None:
+        """Update an existing tool call with the LLM-generated summary.
+
+        This is called when an ActionEvent arrives for a tool call that was
+        already started during streaming. We update the title to include
+        the summary for better context.
+        """
+        from openhands_cli.acp_impl.events.utils import get_tool_kind, get_tool_title
+
+        summary = str(event.summary) if event.summary else None
+        title = get_tool_title(
+            tool_name=event.tool_name, action=event.action, summary=summary
+        )
+        kind = get_tool_kind(tool_name=event.tool_name, action=event.action)
+
+        await self.conn.session_update(
+            session_id=self.session_id,
+            update=update_tool_call(
+                tool_call_id=event.tool_call_id,
+                title=title,
+                kind=kind,
+                status="in_progress",
+                content=format_content_blocks(str(event.visualize.plain)),
+            ),
+            field_meta=get_metadata(self.conversation),
+        )
+
     async def unstreamed_event_handler(self, event: Event):
         # Skip ConversationStateUpdateEvent (internal state management)
         if isinstance(event, ConversationStateUpdateEvent):
@@ -117,7 +151,13 @@ async def unstreamed_event_handler(self, event: Event):
         self.reset_header_state()
 
         if isinstance(event, ActionEvent):
-            await self.shared_events_handler.handle_action_event(self, event)
+            # Check if this tool call was already started during streaming
+            if self._is_tool_call_started(event.tool_call_id):
+                # Update the existing tool call with the summary
+                await self._update_tool_call_with_summary(event)
+            else:
+                # Start a new tool call (non-streaming case)
+                await self.shared_events_handler.handle_action_event(self, event)
         if isinstance(event, UserRejectObservation) or isinstance(
             event, AgentErrorEvent
         ):
@@ -257,7 +297,6 @@ def _handle_tool_call_streaming(self, tool_call) -> None:
             )
             self._schedule_update(tool_call_start)
 
-        # Emit progress updates after start
         if state.started and arguments_chunk:
             self._schedule_update(
                 update_tool_call(

openhands_cli/acp_impl/events/tool_state.py

@@ -29,6 +29,8 @@ def __init__(self, tool_call_id: str, tool_name: str):
         self._valid_skeleton_cached = False
         # Kind is cached once skeleton is valid (depends only on command, not path)
         self._cached_kind: ToolKind | None = None
+        # Incrementally streamed summary (from assistant content prior to tool call)
+        self.summary: str = ""
 
     def append_args(self, args_part: str) -> None:
         """Append new arguments part to the accumulated args and lexer."""
@@ -130,24 +132,36 @@ def _compute_title(self) -> str:
             return "Plan updated"
 
         args = self._parse_args()
+        clean_summary = self.summary.strip().replace("\n", " ") if self.summary else ""
+
+        # If no args yet, fall back to summary or tool name
         if not args:
-            return self.tool_name
+            return clean_summary or self.tool_name
 
         if self.tool_name == "file_editor":
             path = args.get("path")
             command = args.get("command")
             if isinstance(path, str) and path:
                 # Prefix match: streaming may yield "v", "vi", etc. before full "view"
                 if isinstance(command, str) and "view".startswith(command):
-                    return f"Reading {path}"
-                return f"Editing {path}"
+                    return (
+                        f"{clean_summary}: Reading {path}"
+                        if clean_summary
+                        else f"Reading {path}"
+                    )
+                return (
+                    f"{clean_summary}: Editing {path}"
+                    if clean_summary
+                    else f"Editing {path}"
+                )
 
         if self.tool_name == "terminal":
             command = args.get("command")
             if isinstance(command, str) and command:
-                return command
+                return f"{clean_summary}: $ {command}" if clean_summary else command
 
-        return self.tool_name
+        # Other tools: prefer summary if present
+        return clean_summary or self.tool_name
 
     def _parse_args(self) -> dict | None:
         """Parse current args using lexer's best-effort completion."""

openhands_cli/acp_impl/events/utils.py

@@ -11,7 +11,6 @@
 from openhands.tools.file_editor.definition import (
     FileEditorAction,
 )
-from openhands.tools.task_tracker import TaskTrackerAction
 from openhands.tools.terminal import TerminalAction
 from openhands_cli.utils import abbreviate_number, format_cost
 
@@ -160,23 +159,42 @@ def get_tool_kind(tool_name: str, *, action: Action | None = None) -> ToolKind:
     return TOOL_KIND_MAPPING.get(tool_name, "other")
 
 
-def get_tool_title(tool_name: str, *, action: Action | None = None) -> str:
-    """Get tool title from tool name and optional complete action.
+def get_tool_title(
+    tool_name: str, *, action: Action | None = None, summary: str | None = None
+) -> str:
+    """Get tool title from tool name, action, and optional LLM-generated summary.
+
+    When a summary is provided, it is used as the primary title with action
+    details appended for context. This matches the TUI behavior.
 
     For streaming tool calls, use ToolCallState.title instead.
+
+    Args:
+        tool_name: The name of the tool being called
+        action: Optional complete action object for extracting details
+        summary: Optional LLM-generated summary describing the action's purpose
+
+    Returns:
+        A descriptive title for the tool call
     """
-    if tool_name == "task_tracker":
-        return "Plan updated"
+    # Clean up summary if provided
+    clean_summary = summary.strip().replace("\n", " ") if summary else ""
 
     if isinstance(action, FileEditorAction):
-        if action.command == "view":
-            return f"Reading {action.path}"
-        return f"Editing {action.path}"
+        op = "Reading" if action.command == "view" else "Editing"
+        path = action.path or ""
+        if clean_summary:
+            return f"{clean_summary}: {op} {path}"
+        return f"{op} {path}"
 
     if isinstance(action, TerminalAction):
-        return f"{action.command}"
-
-    if isinstance(action, TaskTrackerAction):
-        return "Plan updated"
+        cmd = action.command.strip().replace("\n", " ") if action.command else ""
+        if clean_summary:
+            return f"{clean_summary}: $ {cmd}"
+        return f"$ {cmd}" if cmd else tool_name
+
+    # For other actions, use summary if available
+    if clean_summary:
+        return clean_summary
 
     return ""

tests/acp/events/test_event_subscriber.py

@@ -93,6 +93,7 @@ class MockEvent:
         action = MockAction()
         tool_call = MockToolCall()
         visualize = Text("Executing test action")
+        summary = "Running a test command"
 
     event = MockEvent()
 

tests/acp/events/test_event_utils.py

@@ -51,8 +51,8 @@ def test_file_editor_kind_from_action(self, command: str, expected: str):
 
 
 class TestGetToolTitle:
-    def test_task_tracker_title_constant(self):
-        assert get_tool_title("task_tracker") == "Plan updated"
+    def test_task_tracker_title_empty_without_action(self):
+        assert get_tool_title("task_tracker") == ""
 
     @pytest.mark.parametrize(
         "action,expected",
@@ -65,8 +65,8 @@ def test_task_tracker_title_constant(self):
                 FileEditorAction(command="str_replace", path="/src/main.py"),
                 "Editing /src/main.py",
             ),
-            (TerminalAction(command="git status"), "git status"),
-            (TaskTrackerAction(command="plan", task_list=[]), "Plan updated"),
+            (TerminalAction(command="git status"), "$ git status"),
+            (TaskTrackerAction(command="plan", task_list=[]), ""),
         ],
     )
     def test_title_from_action(self, action, expected: str):
@@ -83,6 +83,37 @@ def test_title_from_action(self, action, expected: str):
     def test_title_no_action_returns_empty(self, tool_name: str):
         assert get_tool_title(tool_name) == ""
 
+    def test_title_with_summary_terminal(self):
+        """Test that summary is included in terminal action title."""
+        action = TerminalAction(command="git status")
+        title = get_tool_title("terminal", action=action, summary="Check git status")
+        assert title == "Check git status: $ git status"
+
+    def test_title_with_summary_file_editor_view(self):
+        """Test that summary is included in file editor view title."""
+        action = FileEditorAction(command="view", path="/src/main.py")
+        title = get_tool_title("file_editor", action=action, summary="Read main file")
+        assert title == "Read main file: Reading /src/main.py"
+
+    def test_title_with_summary_file_editor_edit(self):
+        """Test that summary is included in file editor edit title."""
+        action = FileEditorAction(command="str_replace", path="/src/main.py")
+        title = get_tool_title("file_editor", action=action, summary="Fix bug in main")
+        assert title == "Fix bug in main: Editing /src/main.py"
+
+    def test_title_with_summary_only(self):
+        """Test that summary alone is used when no action details available."""
+        title = get_tool_title("unknown_tool", summary="Do something important")
+        assert title == "Do something important"
+
+    def test_title_with_summary_newlines_stripped(self):
+        """Test that newlines in summary are replaced with spaces."""
+        action = TerminalAction(command="ls")
+        title = get_tool_title(
+            "terminal", action=action, summary="List files\nin directory"
+        )
+        assert title == "List files in directory: $ ls"
+
 
 class TestFormatContentBlocks:
     @pytest.mark.parametrize(

tests/acp/events/test_token_streamer.py

@@ -671,14 +671,15 @@ def test_schedule_update_loop_running_uses_run_coroutine_threadsafe(
         loop.close()
 
 
-@pytest.mark.asyncio
-async def test_terminal_tool_lifecycle_stream_then_action_then_observation():
+def test_terminal_tool_lifecycle_stream_then_action_then_observation(
+    mock_connection, event_loop
+):
     """
     Lifecycle:
       1) on_token streams partial TerminalAction -> emits
          ToolCallStart(in_progress) then ToolCallProgress(in_progress)
       2) unstreamed ActionEvent arrives (same tool_call_id) -> may emit
-         another ToolCallStart(in_progress)
+         ToolCallProgress(in_progress) to update title with summary
       3) unstreamed ObservationEvent arrives (same tool_call_id) -> emits
          ToolCallProgress(completed)
 
@@ -687,12 +688,10 @@ async def test_terminal_tool_lifecycle_stream_then_action_then_observation():
       tool_call (in_progress) -> tool_call_update (in_progress) ->
       tool_call_update (completed)
     """
-    conn = AsyncMock()
-    loop = asyncio.get_running_loop()
     subscriber = TokenBasedEventSubscriber(
         session_id="test-session",
-        conn=conn,
-        loop=loop,
+        conn=mock_connection,
+        loop=event_loop,
     )
 
     tool_call_id = "call-123"
@@ -714,9 +713,10 @@ async def test_terminal_tool_lifecycle_stream_then_action_then_observation():
         arguments='and":"ls"}',
     )
 
-    # with patch.object(loop, "is_running", return_value=False):
-    subscriber.on_token(_chunk(tool_calls=[tc1]))
-    subscriber.on_token(_chunk(tool_calls=[tc2]))
+    # Patch is_running to False so updates are executed synchronously
+    with patch.object(event_loop, "is_running", return_value=False):
+        subscriber.on_token(_chunk(tool_calls=[tc1]))
+        subscriber.on_token(_chunk(tool_calls=[tc2]))
 
     # -----------------------
     # 2) Final ActionEvent arrives (same tool_call_id)
@@ -742,7 +742,8 @@ async def test_terminal_tool_lifecycle_stream_then_action_then_observation():
         llm_response_id="llm-1",
         tool_call=message_tool_call,
     )
-    await subscriber.unstreamed_event_handler(action_event)
+    with patch.object(event_loop, "is_running", return_value=False):
+        event_loop.run_until_complete(subscriber.unstreamed_event_handler(action_event))
 
     # -----------------------
     # 3) ObservationEvent arrives (same tool_call_id)
@@ -761,14 +762,15 @@ async def test_terminal_tool_lifecycle_stream_then_action_then_observation():
         action_id=action_id,  # REQUIRED linkage
     )
 
-    await subscriber.unstreamed_event_handler(obs_event)
+    with patch.object(event_loop, "is_running", return_value=False):
+        event_loop.run_until_complete(subscriber.unstreamed_event_handler(obs_event))
 
     # -----------------------
     # Assert: status progression
     # -----------------------
     # Gather ONLY the updates related to our tool_call_id.
     updates = []
-    for call in conn.session_update.call_args_list:
+    for call in mock_connection.session_update.call_args_list:
         update = call.kwargs["update"]
         # Filter only tool-call updates for this tool_call_id
         if getattr(update, "tool_call_id", None) == tool_call_id:
@@ -777,17 +779,18 @@ async def test_terminal_tool_lifecycle_stream_then_action_then_observation():
     assert updates, "Expected at least one ACP update for tool_call_id"
 
     # We want to see:
-    # - at least one ToolCallStart with status in_progress
-    # - at least one ToolCallProgress with status in_progress
+    # - at least one ToolCallStart with status in_progress (from streaming)
+    # - at least one ToolCallProgress with status in_progress (from streaming or
+    #   ActionEvent updating the title with summary)
     # - final ToolCallProgress with status completed
     starts = [u for u in updates if isinstance(u, ToolCallStart)]
     progresses = [u for u in updates if isinstance(u, ToolCallProgress)]
 
     assert any(isinstance(s, ToolCallStart) for s in starts), (
-        "Expected a ToolCallStart from streaming and/or ActionEvent"
+        "Expected a ToolCallStart from streaming"
     )
     assert any(isinstance(p, ToolCallProgress) for p in progresses), (
-        "Expected at least one ToolCallProgress during streaming"
+        "Expected at least one ToolCallProgress during streaming or from ActionEvent"
     )
 
     # The last tool-call-related update should be completion.

tests/tui/widgets/test_richlog_visualizer.py

@@ -338,8 +338,8 @@ def test_visualizer_handles_mistral_xml_function_call_syntax(self, visualizer):
 
         # Verify that the visualizer successfully created a collapsible widget
         title_str = str(collapsible.title)
-        # Title should show the tool name (new implementation uses clean titles)
-        assert "execute_bash" in title_str
+        # For non-terminal/file-editor actions without summary, title is just tool_name
+        assert "execute_bash" in title_str  # The function name should be present
         assert len(title_str) > 0  # Title should not be empty