deepagents-cli 0.0.54__tar.gz → 0.0.55__tar.gz

{deepagents_cli-0.0.54 → deepagents_cli-0.0.55}/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Deep Agents CLI Changelog
 
+## [0.0.55](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.54...deepagents-cli==0.0.55) (2026-05-11)
+
+### Bug Fixes
+
+* Keep Thinking spinner during `edit_file` approval ([#3310](https://github.com/langchain-ai/deepagents/issues/3310)) ([d06133f](https://github.com/langchain-ai/deepagents/commit/d06133f8dd7cb924c82e46ece3e165d561ef7d9e))
+
 ## [0.0.54](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.53...deepagents-cli==0.0.54) (2026-05-11)
 
 ### Features

{deepagents_cli-0.0.54 → deepagents_cli-0.0.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-cli
-Version: 0.0.54
+Version: 0.0.55
 Summary: Terminal interface for Deep Agents - interactive AI agent with file operations, shell access, and sub-agent capabilities.
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
 Project-URL: Documentation, https://reference.langchain.com/python/deepagents/

{deepagents_cli-0.0.54 → deepagents_cli-0.0.55}/deepagents_cli/_version.py

@@ -1,6 +1,6 @@
 """Version information and lightweight constants for `deepagents-cli`."""
 
-__version__ = "0.0.54"  # x-release-please-version
+__version__ = "0.0.55"  # x-release-please-version
 
 DOCS_URL = "https://docs.langchain.com/oss/python/deepagents/cli"
 """URL for `deepagents-cli` documentation."""

{deepagents_cli-0.0.54 → deepagents_cli-0.0.55}/deepagents_cli/textual_adapter.py

@@ -77,6 +77,9 @@ _hitl_adapter_cache: TypeAdapter | None = None
 
 _ASK_USER_UNSUPPORTED_ERROR = "ask_user not supported by this UI"
 
+_TOOL_CALLS_KEEP_THINKING_SPINNER = frozenset({"edit_file"})
+"""Tool calls whose argument/approval phase can be long enough to need feedback."""
+
 
 def _get_hitl_request_adapter(hitl_request_type: type) -> TypeAdapter:
     """Return a cached `TypeAdapter(HITLRequest)`.
@@ -929,8 +932,16 @@ async def execute_task_textual(
                                     buffer_name, parsed_args, buffer_id
                                 )
 
-                                # Hide spinner before showing tool call
-                                if adapter._set_spinner:
+                                keep_thinking_spinner = (
+                                    buffer_name in _TOOL_CALLS_KEEP_THINKING_SPINNER
+                                )
+
+                                # Hide spinner before showing most tool calls.
+                                # `edit_file` can spend noticeable time between
+                                # argument streaming, HITL interrupt delivery, and
+                                # approval handling, so re-anchor Thinking below
+                                # the row instead of leaving the UI visually idle.
+                                if adapter._set_spinner and not keep_thinking_spinner:
                                     await adapter._set_spinner(None)
 
                                 # Mount tool call message
@@ -942,6 +953,8 @@ async def execute_task_textual(
                                 tool_msg = ToolCallMessage(buffer_name, parsed_args)
                                 await adapter._mount_message(tool_msg)
                                 adapter._current_tool_messages[buffer_id] = tool_msg
+                                if adapter._set_spinner and keep_thinking_spinner:
+                                    await adapter._set_spinner("Thinking")
 
                             tool_call_buffers.pop(buffer_key, None)
 

{deepagents_cli-0.0.54 → deepagents_cli-0.0.55}/deepagents_cli/widgets/messages.py

@@ -6,6 +6,7 @@ import ast
 import json
 import logging
 import re
+import textwrap
 from dataclasses import dataclass
 from pathlib import Path
 from time import time
@@ -15,6 +16,7 @@ from textual import on
 from textual.containers import Vertical
 from textual.content import Content
 from textual.events import Click
+from textual.message_pump import NoActiveAppError
 from textual.reactive import var
 from textual.widgets import Static
 
@@ -123,6 +125,8 @@ _MAX_INLINE_ARGS = 3
 
 # Truncation limits for display
 _MAX_TODO_CONTENT_LEN = 70
+_DEFAULT_TODO_WRAP_WIDTH = 80
+_TODO_WRAP_GUARD_COLUMNS = 4
 _MAX_WEB_CONTENT_LEN = 100
 
 # Tools that have their key info already in the header (no need for args line)
@@ -1063,6 +1067,8 @@ class ToolCallMessage(Vertical):
         """Toggle expansion of the tool's preview/full output."""
         if not self._output:
             return
+        if not self._expanded and not self._has_expandable_output():
+            return
         self._expanded = not self._expanded
         self._update_output_display()
 
@@ -1135,6 +1141,21 @@ class ToolCallMessage(Vertical):
         # Default: plain text (Content treats input as literal)
         return FormattedOutput(content=Content(output))
 
+    def _has_expandable_output(self) -> bool:
+        """Return whether collapsed output has hidden content to expand."""
+        output = self._output.strip()
+        if not output:
+            return False
+
+        lines = output.split("\n")
+        if len(lines) > self._PREVIEW_LINES or len(output) > self._PREVIEW_CHARS:
+            return True
+
+        if self._tool_name == "write_todos":
+            return self._format_output(output, is_preview=True).truncation is not None
+
+        return False
+
     def _prefix_output(self, content: Content) -> Content:  # noqa: PLR6301  # Grouped as method for widget cohesion
         """Prefix output with output marker and indent continuation lines.
 
@@ -1177,14 +1198,38 @@ class ToolCallMessage(Vertical):
             lines.extend([Content.assemble("    ", stats), Content("")])
 
         # Format each item
-        lines.extend(self._format_single_todo(item) for item in items[:max_items])
+        lines.extend(
+            self._format_single_todo(item, is_preview=is_preview)
+            for item in items[:max_items]
+        )
 
         truncation = None
-        if is_preview and len(items) > max_items:
-            truncation = f"{len(items) - max_items} more"
+        if is_preview:
+            hidden_items = len(items) - max_items
+            if hidden_items > 0:
+                truncation = f"{hidden_items} more"
+            elif any(
+                len(self._todo_text(item)) > _MAX_TODO_CONTENT_LEN
+                for item in items[:max_items]
+            ):
+                truncation = "full todo text"
 
         return FormattedOutput(content=Content("\n").join(lines), truncation=truncation)
 
+    @staticmethod
+    def _todo_text(item: dict | str) -> str:
+        """Return display text for a todo item.
+
+        Args:
+            item: Todo item dictionary or plain string.
+
+        Returns:
+            Todo content text.
+        """
+        if isinstance(item, dict):
+            return str(item.get("content", str(item)))
+        return str(item)
+
     def _parse_todo_items(self, output: str) -> list | None:  # noqa: PLR6301  # Grouped as method for widget cohesion
         """Parse todo items from output.
 
@@ -1227,37 +1272,113 @@ class ToolCallMessage(Vertical):
             parts.append(Content.styled(f"{completed} done", colors.success))
         return Content.styled(" | ", "dim").join(parts) if parts else Content("")
 
-    def _format_single_todo(self, item: dict | str) -> Content:
+    def _todo_content_width(self, indent_width: int) -> int:
+        """Return the todo content wrap width for the current widget size.
+
+        Args:
+            indent_width: Display width before todo content starts.
+
+        Returns:
+            Width available for todo content wrapping.
+        """
+        display_width = 0
+        for widget in (self._full_widget, self._preview_widget, self):
+            if widget and widget.is_mounted and widget.size.width > 0:
+                display_width = widget.size.width
+                break
+
+        if not display_width:
+            try:
+                display_width = self.app.size.width
+            except NoActiveAppError:
+                display_width = _DEFAULT_TODO_WRAP_WIDTH
+
+        output_prefix_width = len(get_glyphs().output_prefix) + 1
+        available = (
+            display_width
+            - output_prefix_width
+            - indent_width
+            - _TODO_WRAP_GUARD_COLUMNS
+        )
+        return max(20, available)
+
+    def _format_todo_line(
+        self,
+        prefix: Content,
+        text: str,
+        *,
+        is_preview: bool,
+        text_style: str | None = None,
+    ) -> Content:
+        """Format a todo row, wrapping expanded content under the text column.
+
+        Args:
+            prefix: Styled status prefix before todo content.
+            text: Todo text to render.
+            is_preview: Whether the compact preview is being rendered.
+            text_style: Optional style for todo content.
+
+        Returns:
+            Styled `Content` for one todo row.
+        """
+        if is_preview and len(text) > _MAX_TODO_CONTENT_LEN:
+            text = text[: _MAX_TODO_CONTENT_LEN - 3] + "..."
+
+        if is_preview:
+            content = Content.styled(text, text_style) if text_style else Content(text)
+            return Content.assemble(prefix, content)
+
+        indent = " " * len(prefix.plain)
+        wrapped = textwrap.wrap(
+            text,
+            width=self._todo_content_width(len(prefix.plain)),
+            break_long_words=True,
+            break_on_hyphens=False,
+        ) or [""]
+        parts: list[Content] = [prefix]
+        for index, line in enumerate(wrapped):
+            if index:
+                parts.append(Content("\n" + indent))
+            content = Content.styled(line, text_style) if text_style else Content(line)
+            parts.append(content)
+        return Content.assemble(*parts)
+
+    def _format_single_todo(self, item: dict | str, *, is_preview: bool) -> Content:
         """Format a single todo item.
 
+        Args:
+            item: Todo item dictionary or plain string.
+            is_preview: Whether the compact preview is being rendered.
+
         Returns:
             Styled `Content` with checkbox and status styling.
         """
         colors = theme.get_theme_colors(self)
         if isinstance(item, dict):
-            text = item.get("content", str(item))
+            text = self._todo_text(item)
             status = item.get("status", "pending")
         else:
-            text = str(item)
+            text = self._todo_text(item)
             status = "pending"
 
-        if len(text) > _MAX_TODO_CONTENT_LEN:
-            text = text[: _MAX_TODO_CONTENT_LEN - 3] + "..."
-
         glyphs = get_glyphs()
         if status == "completed":
-            return Content.assemble(
-                Content.styled(f"    {glyphs.checkmark} done", colors.success),
-                Content.styled(f"   {text}", "dim"),
+            return self._format_todo_line(
+                Content.styled(f"    {glyphs.checkmark} done   ", colors.success),
+                text,
+                is_preview=is_preview,
+                text_style="dim",
             )
         if status == "in_progress":
-            return Content.assemble(
-                Content.styled(f"    {glyphs.circle_filled} active", colors.warning),
-                f" {text}",
+            return self._format_todo_line(
+                Content.styled(f"    {glyphs.circle_filled} active ", colors.warning),
+                text,
+                is_preview=is_preview,
             )
-        return Content.assemble(
-            Content.styled(f"    {glyphs.circle_empty} todo", "dim"),
-            f"   {text}",
+        return self._format_todo_line(
+            Content.styled(f"    {glyphs.circle_empty} todo   ", "dim"),
+            text,
+            is_preview=is_preview,
         )
 
     def _format_ls_output(  # noqa: PLR6301  # Grouped as method for widget cohesion
@@ -1574,11 +1695,24 @@ class ToolCallMessage(Vertical):
                 self._hint_widget.display = True
             elif output_stripped:
                 # Output fits in preview, show formatted
-                result = self._format_output(output_stripped, is_preview=False)
+                is_tool_preview = self._tool_name == "write_todos"
+                result = self._format_output(
+                    output_stripped,
+                    is_preview=is_tool_preview,
+                )
                 prefixed = self._prefix_output(result.content)
                 self._preview_widget.update(prefixed)
                 self._preview_widget.display = True
-                self._hint_widget.display = False
+                if result.truncation:
+                    ellipsis = get_glyphs().ellipsis
+                    hint = Content.styled(
+                        f"{ellipsis} {result.truncation} — click or Ctrl+O to expand",
+                        "dim",
+                    )
+                    self._hint_widget.update(hint)
+                    self._hint_widget.display = True
+                else:
+                    self._hint_widget.display = False
             else:
                 self._preview_widget.display = False
                 self._hint_widget.display = False

{deepagents_cli-0.0.54 → deepagents_cli-0.0.55}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "deepagents-cli"
-version = "0.0.54"
+version = "0.0.55"
 description = "Terminal interface for Deep Agents - interactive AI agent with file operations, shell access, and sub-agent capabilities."
 readme = "README.md"
 license = { text = "MIT" }

{deepagents_cli-0.0.54 → deepagents_cli-0.0.55}/tests/unit_tests/test_messages.py

@@ -394,6 +394,122 @@ class TestToolCallMessageMarkupSafety:
         assert msg.has_expandable_args is True
 
 
+class TestToolCallMessageTodos:
+    """Tests for `write_todos` output formatting."""
+
+    def test_todo_preview_truncates_long_content(self) -> None:
+        """Collapsed todo preview should keep the compact character limit."""
+        long = "Implement " + "very detailed authentication flow " * 4
+        msg = ToolCallMessage("write_todos")
+
+        result = msg._format_todos_output(
+            repr([{"content": long, "status": "in_progress"}]),
+            is_preview=True,
+        )
+
+        assert result.content.plain.endswith("...")
+        assert long not in result.content.plain
+        assert result.truncation == "full todo text"
+
+    async def test_todo_collapsed_short_output_uses_preview_formatting(self) -> None:
+        """Collapsed todos should truncate even when raw output fits generically."""
+        from textual.app import App, ComposeResult
+
+        long = "Implement " + "very detailed authentication flow " * 3
+        assert len(long) > 70
+        output = repr([{"content": long, "status": "pending"}])
+        assert len(output) < ToolCallMessage._PREVIEW_CHARS
+
+        class _Harness(App[None]):
+            def __init__(self) -> None:
+                super().__init__()
+                self.msg = ToolCallMessage("write_todos")
+
+            def compose(self) -> ComposeResult:
+                yield self.msg
+
+        app = _Harness()
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            app.msg.set_success(output)
+            await pilot.pause()
+
+            assert app.msg._preview_widget is not None
+            assert app.msg._hint_widget is not None
+            content = app.msg._preview_widget._Static__content  # type: ignore[attr-defined]
+            assert isinstance(content, Content)
+            assert "..." in content.plain
+            assert long not in content.plain
+            assert app.msg._hint_widget.display is True
+
+    async def test_todo_short_fully_visible_output_does_not_expand(self) -> None:
+        """Clicking fully visible todo output should not show a collapse hint."""
+        from textual.app import App, ComposeResult
+
+        output = repr([{"content": "Write tests", "status": "pending"}])
+
+        class _Harness(App[None]):
+            def __init__(self) -> None:
+                super().__init__()
+                self.msg = ToolCallMessage("write_todos")
+
+            def compose(self) -> ComposeResult:
+                yield self.msg
+
+        app = _Harness()
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            app.msg.set_success(output)
+            await pilot.pause()
+
+            assert app.msg._hint_widget is not None
+            assert app.msg._hint_widget.display is False
+
+            app.msg.toggle_output()
+            await pilot.pause()
+
+            assert app.msg._expanded is False
+            assert app.msg._hint_widget.display is False
+
+    def test_todo_expanded_shows_full_wrapped_content(self) -> None:
+        """Expanded todo output should wrap long content without truncating."""
+        long = (
+            "Implement the new authentication flow using OAuth2 with PKCE for "
+            "the CLI login command and preserve readable todo output"
+        )
+        msg = ToolCallMessage("write_todos")
+
+        result = msg._format_todos_output(
+            repr([{"content": long, "status": "in_progress"}]),
+            is_preview=False,
+        )
+        plain = result.content.plain
+
+        assert "..." not in plain
+        assert long.replace(" ", "") == plain.split("active ", 1)[1].replace(
+            "\n             ",
+            "",
+        ).replace(" ", "")
+        assert "\n             " in plain
+
+    def test_todo_expanded_continuation_aligns_content_column(self) -> None:
+        """Wrapped continuation lines should align under the todo text."""
+        long = "Write integration tests for " + "token refresh revocation " * 4
+        msg = ToolCallMessage("write_todos")
+
+        result = msg._format_todos_output(
+            repr([{"content": long, "status": "pending"}]),
+            is_preview=False,
+        )
+        lines = result.content.plain.splitlines()
+        todo_start = next(
+            index for index, line in enumerate(lines) if "todo   " in line
+        )
+
+        assert len(lines) > todo_start + 1
+        assert lines[todo_start + 1].startswith("             ")
+
+
 class TestToolCallMessageExpandableArgs:
     """Tests for the `ask_user` expandable-arguments toggle."""
 

{deepagents_cli-0.0.54 → deepagents_cli-0.0.55}/tests/unit_tests/test_textual_adapter.py

@@ -789,6 +789,59 @@ class TestExecuteTaskTextualParallelToolSpinner:
 
         assert statuses[-1] == "Thinking"
 
+    async def test_edit_file_tool_keeps_thinking_spinner_while_pending(self) -> None:
+        """`edit_file` should not leave a visual gap before approval/execution."""
+        statuses: list[str | None] = []
+
+        async def record_spinner(status: str | None) -> None:
+            await asyncio.sleep(0)
+            statuses.append(status)
+
+        chunks = [
+            (
+                (),
+                "messages",
+                (
+                    _tool_call_message(
+                        "edit_file",
+                        {
+                            "file_path": "example.py",
+                            "old_string": "old",
+                            "new_string": "new",
+                        },
+                        "tool-1",
+                    ),
+                    {},
+                ),
+            ),
+            (
+                (),
+                "messages",
+                (
+                    ToolMessage(content="edited", tool_call_id="tool-1"),
+                    {},
+                ),
+            ),
+        ]
+
+        adapter = TextualUIAdapter(
+            mount_message=_mock_mount,
+            update_status=_noop_status,
+            request_approval=_mock_approval,
+            set_spinner=record_spinner,
+        )
+
+        await execute_task_textual(
+            user_input="edit the file",
+            agent=_FakeAgent(chunks),
+            assistant_id="assistant",
+            session_state=SimpleNamespace(thread_id="thread-1", auto_approve=True),
+            adapter=adapter,
+        )
+
+        assert statuses[:2] == ["Thinking", "Thinking"]
+        assert None not in statuses
+
     async def test_spinner_with_three_parallel_tools_out_of_order(self) -> None:
         """Three parallel tools completed out of order; Thinking after all."""
         statuses: list[str | None] = []

{deepagents_cli-0.0.54 → deepagents_cli-0.0.55}/uv.lock

@@ -1023,7 +1023,7 @@ wheels = [
 
 [[package]]
 name = "deepagents-cli"
-version = "0.0.54"
+version = "0.0.55"
 source = { editable = "." }
 dependencies = [
     { name = "aiosqlite" },