deepagents-cli 0.0.31__tar.gz → 0.0.32__tar.gz

{deepagents_cli-0.0.31 → deepagents_cli-0.0.32}/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.0.32](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.31...deepagents-cli==0.0.32) (2026-03-11)
+
+### Features
+
+* Add token breakdown to `/tokens` and simplify `/compact` messages ([#1782](https://github.com/langchain-ai/deepagents/issues/1782)) ([2f37bff](https://github.com/langchain-ai/deepagents/commit/2f37bffa9d7a9ced6945abe4ab6bc3409bfb97b1))
+* `--json` flag for machine-readable output ([#1768](https://github.com/langchain-ai/deepagents/issues/1768)) ([6f62496](https://github.com/langchain-ai/deepagents/commit/6f62496bb699dfa6086ee1850b83f38d3b1242fa))
+
+### Bug Fixes
+
+* Work around VS Code 1.110 space key regression ([#1748](https://github.com/langchain-ai/deepagents/issues/1748)) ([f5fe431](https://github.com/langchain-ai/deepagents/commit/f5fe4315143bf5b636cf42fc98cbfe3d99918cfc))
+
 ## [0.0.31](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.30...deepagents-cli==0.0.31) (2026-03-09)
 
 ### Features

{deepagents_cli-0.0.31 → deepagents_cli-0.0.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-cli
-Version: 0.0.31
+Version: 0.0.32
 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/
@@ -26,7 +26,7 @@ Requires-Python: <4.0,>=3.11
 Requires-Dist: aiosqlite<1.0.0,>=0.19.0
 Requires-Dist: daytona<1.0.0,>=0.113.0
 Requires-Dist: deepagents-acp>=0.0.4
-Requires-Dist: deepagents==0.4.7
+Requires-Dist: deepagents==0.4.10
 Requires-Dist: langchain-mcp-adapters<1.0.0,>=0.2.0
 Requires-Dist: langchain-openai<2.0.0,>=1.1.8
 Requires-Dist: langchain<2.0.0,>=1.2.10
@@ -114,12 +114,12 @@ Description-Content-Type: text/markdown
 ## Quick Install
 
 ```bash
-curl -LsSf https://raw.githubusercontent.com/langchain-ai/deepagents/main/scripts/install.sh | bash
+curl -LsSf https://raw.githubusercontent.com/langchain-ai/deepagents/main/libs/cli/scripts/install.sh | bash
 ```
 
 ```bash
 # With model provider extras (OpenAI is included by default)
-DEEPAGENTS_EXTRAS="anthropic,groq" curl -LsSf https://raw.githubusercontent.com/langchain-ai/deepagents/main/scripts/install.sh | bash
+DEEPAGENTS_EXTRAS="anthropic,groq" curl -LsSf https://raw.githubusercontent.com/langchain-ai/deepagents/main/libs/cli/scripts/install.sh | bash
 ```
 
 Or install directly with `uv`:

{deepagents_cli-0.0.31 → deepagents_cli-0.0.32}/README.md

@@ -12,12 +12,12 @@
 ## Quick Install
 
 ```bash
-curl -LsSf https://raw.githubusercontent.com/langchain-ai/deepagents/main/scripts/install.sh | bash
+curl -LsSf https://raw.githubusercontent.com/langchain-ai/deepagents/main/libs/cli/scripts/install.sh | bash
 ```
 
 ```bash
 # With model provider extras (OpenAI is included by default)
-DEEPAGENTS_EXTRAS="anthropic,groq" curl -LsSf https://raw.githubusercontent.com/langchain-ai/deepagents/main/scripts/install.sh | bash
+DEEPAGENTS_EXTRAS="anthropic,groq" curl -LsSf https://raw.githubusercontent.com/langchain-ai/deepagents/main/libs/cli/scripts/install.sh | bash
 ```
 
 Or install directly with `uv`:

deepagents_cli-0.0.32/deepagents_cli/_version.py

@@ -0,0 +1,3 @@
+"""Version information for `deepagents-cli`."""
+
+__version__ = "0.0.32"  # x-release-please-version

{deepagents_cli-0.0.31 → deepagents_cli-0.0.32}/deepagents_cli/agent.py

@@ -31,6 +31,7 @@ if TYPE_CHECKING:
     from langgraph.runtime import Runtime
 
     from deepagents_cli.mcp_tools import MCPServerInfo
+    from deepagents_cli.output import OutputFormat
 
 from deepagents_cli.config import (
     COLORS,
@@ -61,11 +62,20 @@ REQUIRE_COMPACT_TOOL_APPROVAL: bool = True
 """When `True`, `compact_conversation` requires HITL approval like other gated tools."""
 
 
-def list_agents() -> None:
-    """List all available agents."""
+def list_agents(*, output_format: OutputFormat = "text") -> None:
+    """List all available agents.
+
+    Args:
+        output_format: Output format — `'text'` (Rich) or `'json'`.
+    """
     agents_dir = settings.user_deepagents_dir
 
     if not agents_dir.exists() or not any(agents_dir.iterdir()):
+        if output_format == "json":
+            from deepagents_cli.output import write_json
+
+            write_json("list", [])
+            return
         console.print("[yellow]No agents found.[/yellow]")
         console.print(
             "[dim]Agents will be created in ~/.deepagents/ "
@@ -74,6 +84,24 @@ def list_agents() -> None:
         )
         return
 
+    if output_format == "json":
+        from deepagents_cli.output import write_json
+
+        agents = []
+        for agent_path in sorted(agents_dir.iterdir()):
+            if agent_path.is_dir():
+                agent_name = agent_path.name
+                agents.append(
+                    {
+                        "name": agent_name,
+                        "path": str(agent_path),
+                        "has_agents_md": (agent_path / "AGENTS.md").exists(),
+                        "is_default": agent_name == DEFAULT_AGENT_NAME,
+                    }
+                )
+        write_json("list", agents)
+        return
+
     console.print("\n[bold]Available Agents:[/bold]\n", style=COLORS["primary"])
 
     for agent_path in sorted(agents_dir.iterdir()):
@@ -101,8 +129,19 @@ def list_agents() -> None:
     console.print()
 
 
-def reset_agent(agent_name: str, source_agent: str | None = None) -> None:
-    """Reset an agent to default or copy from another agent."""
+def reset_agent(
+    agent_name: str,
+    source_agent: str | None = None,
+    *,
+    output_format: OutputFormat = "text",
+) -> None:
+    """Reset an agent to default or copy from another agent.
+
+    Args:
+        agent_name: Name of the agent to reset.
+        source_agent: Copy AGENTS.md from this agent instead of default.
+        output_format: Output format — `'text'` (Rich) or `'json'`.
+    """
     agents_dir = settings.user_deepagents_dir
     agent_dir = agents_dir / agent_name
 
@@ -125,14 +164,28 @@ def reset_agent(agent_name: str, source_agent: str | None = None) -> None:
 
     if agent_dir.exists():
         shutil.rmtree(agent_dir)
-        console.print(
-            f"Removed existing agent directory: {agent_dir}", style=COLORS["tool"]
-        )
+        if output_format != "json":
+            console.print(
+                f"Removed existing agent directory: {agent_dir}", style=COLORS["tool"]
+            )
 
     agent_dir.mkdir(parents=True, exist_ok=True)
     agent_md = agent_dir / "AGENTS.md"
     agent_md.write_text(source_content)
 
+    if output_format == "json":
+        from deepagents_cli.output import write_json
+
+        write_json(
+            "reset",
+            {
+                "agent": agent_name,
+                "reset_to": source_agent or "default",
+                "path": str(agent_dir),
+            },
+        )
+        return
+
     console.print(
         f"{get_glyphs().checkmark} Agent '{agent_name}' reset to {action_desc}",
         style=COLORS["primary"],
@@ -713,15 +766,10 @@ def create_cli_agent(
 
     model = resolve_model(model)
 
-    from deepagents.middleware.summarization import (
-        SummarizationToolMiddleware,
-        create_summarization_middleware,
-    )
+    from deepagents.middleware.summarization import create_summarization_tool_middleware
 
     agent_middleware.append(
-        SummarizationToolMiddleware(
-            create_summarization_middleware(model, composite_backend)
-        )
+        create_summarization_tool_middleware(model, composite_backend)
     )
 
     # Create the agent

{deepagents_cli-0.0.31 → deepagents_cli-0.0.32}/deepagents_cli/app.py

@@ -148,10 +148,7 @@ def _format_compact_limit(
         percent = float(keep_value) * 100
         if context_limit is not None:
             token_limit = max(1, int(context_limit * float(keep_value)))
-            return (
-                f"{format_token_count(token_limit)} tokens "
-                f"({percent:.0f}% of {format_token_count(context_limit)})"
-            )
+            return f"{format_token_count(token_limit)} tokens"
         return f"{percent:.0f}% of context window"
 
     return "current retention threshold"
@@ -1588,19 +1585,25 @@ class DeepAgentsApp(App):
                 if context_limit is not None:
                     limit_str = format_token_count(context_limit)
                     pct = count / context_limit * 100
-                    usage = (
-                        f"{formatted} / {limit_str} tokens "
-                        f"({pct:.0f}%, includes system prompt + tools)"
-                    )
+                    usage = f"{formatted} / {limit_str} tokens ({pct:.0f}%)"
                 else:
-                    usage = f"{formatted} tokens used (includes system prompt + tools)"
+                    usage = f"{formatted} tokens used"
+
+                msg = f"{usage} \u00b7 {model_name}" if model_name else usage
 
-                msg = f"{usage} · {model_name}" if model_name else usage
+                conv_tokens = await self._get_conversation_token_count()
+                if conv_tokens is not None:
+                    overhead = max(0, count - conv_tokens)
+                    overhead_str = format_token_count(overhead)
+                    conv_str = format_token_count(conv_tokens)
 
-                # Append conversation-only token count when available
-                conv_line = await self._get_conversation_token_line()
-                if conv_line:
-                    msg = f"{msg}\n{conv_line}"
+                    overhead_unit = " tokens" if overhead < 1000 else ""  # noqa: PLR2004  # not bothersome, cosmetic
+                    conv_unit = " tokens" if conv_tokens < 1000 else ""  # noqa: PLR2004  # not bothersome, cosmetic
+
+                    msg += (
+                        f"\n\u251c System prompt + tools: ~{overhead_str}{overhead_unit} (fixed)"  # noqa: E501
+                        f"\n\u2514 Conversation: ~{conv_str}{conv_unit}"
+                    )
 
                 await self._mount_message(AppMessage(msg))
             else:
@@ -1610,7 +1613,7 @@ class DeepAgentsApp(App):
                 parts: list[str] = ["No token usage yet"]
                 if context_limit is not None:
                     limit_str = format_token_count(context_limit)
-                    parts.append(f"{limit_str} context window")
+                    parts.append(f"{limit_str} token context window")
                 if model_name:
                     parts.append(model_name)
 
@@ -1723,12 +1726,11 @@ class DeepAgentsApp(App):
 
         self.call_after_refresh(_scroll_after_command)
 
-    async def _get_conversation_token_line(self) -> str | None:
-        """Return a short string with the conversation-only token count.
+    async def _get_conversation_token_count(self) -> int | None:
+        """Return the approximate conversation-only token count.
 
         Returns:
-            Formatted line like `"Conversation only: ~18 tokens"`, or
-            `None` if state is unavailable.
+            Token count as an integer, or `None` if state is unavailable.
         """
         if not self._agent:
             return None
@@ -1746,9 +1748,38 @@ class DeepAgentsApp(App):
             messages = state.values.get("messages", [])
             if not messages:
                 return None
-            conv_tokens = count_tokens_approximately(messages)
-            return f"Conversation only: ~{format_token_count(conv_tokens)} tokens"
-        except Exception:  # noqa: BLE001
+            return count_tokens_approximately(messages)
+        except Exception:  # best-effort for /tokens display
+            logger.debug("Failed to retrieve conversation token count", exc_info=True)
+            return None
+
+    def _resolve_compact_budget_str(self) -> str | None:
+        """Resolve the compaction retention budget as a human-readable string.
+
+        Instantiates a model and computes summarization defaults, so this is
+        not a trivial accessor.
+
+        Returns:
+            A string like `"20.0K (10% of 200.0K)"` or
+            `"last 6 messages"`, or `None` if the budget cannot be determined.
+        """
+        try:
+            from deepagents.middleware.summarization import (
+                compute_summarization_defaults,
+            )
+
+            model_spec = f"{settings.model_provider}:{settings.model_name}"
+            result = create_model(
+                model_spec,
+                profile_overrides=self._profile_override,
+            )
+            defaults = compute_summarization_defaults(result.model)
+            return _format_compact_limit(
+                defaults["keep"],
+                settings.model_context_limit,
+            )
+        except Exception:  # best-effort for /tokens display
+            logger.debug("Failed to compute compaction budget string", exc_info=True)
             return None
 
     async def _handle_compact(self) -> None:
@@ -1760,9 +1791,9 @@ class DeepAgentsApp(App):
         instead of the full history.
 
         Compaction is a no-op when the conversation's total token count is
-        within the `keep` budget (by default 10% of the model's
-        `max_input_tokens`). Until that threshold is exceeded the user sees
-        "Nothing to compact yet" plus the active compact limit.
+        within the `keep` budget. Until that threshold is exceeded the user
+        sees "Nothing to compact" with the retention budget and a pointer to
+        `/tokens` for a full breakdown.
         """
         if not self._agent or not self._lc_thread_id or not self._backend:
             await self._mount_message(
@@ -1876,27 +1907,29 @@ class DeepAgentsApp(App):
                     and context_limit is not None
                     and total_context > context_limit
                 ):
-                    # Case A: overhead-dominated — total context exceeds
-                    # limit but conversation itself is small
+                    # Case A: total context exceeds model limit but
+                    # conversation is within keep budget — excess is
+                    # system prompt + tool overhead that compaction
+                    # cannot reduce
                     total_str = format_token_count(total_context)
                     await self._mount_message(
                         AppMessage(
                             f"Nothing to compact \u2014 conversation is only "
-                            f"~{conv_str} tokens.\n"
-                            f"Total context ({total_str}) is mostly system "
-                            f"prompt and tool overhead, which compaction "
-                            f"cannot reduce.\n"
-                            f"Retention budget: {compact_limit}"
+                            f"~{conv_str} tokens.\n\n"
+                            f"Total context ({total_str} tokens) is mostly "
+                            f"system prompt and tool overhead, which "
+                            f"compaction cannot reduce.\n\n"
+                            f"Use /tokens for a full breakdown."
                         )
                     )
                 else:
                     # Case B: genuinely within budget
                     await self._mount_message(
                         AppMessage(
-                            "Nothing to compact yet \u2014 conversation is "
-                            "within the retention budget.\n"
-                            f"Conversation: ~{conv_str} tokens \u00b7 "
-                            f"Retention budget: {compact_limit}"
+                            f"Nothing to compact \u2014 conversation "
+                            f"(~{conv_str} tokens) is within the "
+                            f"retention budget ({compact_limit}).\n\n"
+                            f"Use /tokens for a full breakdown."
                         )
                     )
                 return

{deepagents_cli-0.0.31 → deepagents_cli-0.0.32}/deepagents_cli/main.py

@@ -141,6 +141,7 @@ def parse_args() -> argparse.Namespace:
     Returns:
         Parsed arguments namespace.
     """
+    from deepagents_cli.output import add_json_output_arg
     from deepagents_cli.skills import setup_skills_parser
     from deepagents_cli.ui import (
         build_help_parent,
@@ -226,6 +227,7 @@ def parse_args() -> argparse.Namespace:
         add_help=False,
         parents=help_parent(show_list_help),
     )
+    add_json_output_arg(subparsers.choices["list"])
 
     reset_parser = subparsers.add_parser(
         "reset",
@@ -233,12 +235,17 @@ def parse_args() -> argparse.Namespace:
         add_help=False,
         parents=help_parent(show_reset_help),
     )
+    add_json_output_arg(reset_parser)
     reset_parser.add_argument("--agent", required=True, help="Name of agent to reset")
     reset_parser.add_argument(
         "--target", dest="source_agent", help="Copy prompt from another agent"
     )
 
-    setup_skills_parser(subparsers, make_help_action=_make_help_action)
+    setup_skills_parser(
+        subparsers,
+        make_help_action=_make_help_action,
+        add_output_args=add_json_output_arg,
+    )
 
     threads_parser = subparsers.add_parser(
         "threads",
@@ -246,6 +253,7 @@ def parse_args() -> argparse.Namespace:
         add_help=False,
         parents=help_parent(show_threads_help),
     )
+    add_json_output_arg(threads_parser)
     threads_sub = threads_parser.add_subparsers(dest="threads_command")
 
     threads_list = threads_sub.add_parser(
@@ -255,6 +263,7 @@ def parse_args() -> argparse.Namespace:
         add_help=False,
         parents=help_parent(show_threads_list_help),
     )
+    add_json_output_arg(threads_list)
     threads_list.add_argument(
         "--agent", default=None, help="Filter by agent name (default: show all)"
     )
@@ -296,6 +305,7 @@ def parse_args() -> argparse.Namespace:
         add_help=False,
         parents=help_parent(show_threads_delete_help),
     )
+    add_json_output_arg(threads_delete)
     threads_delete.add_argument("thread_id", help="Thread ID to delete")
 
     # Default interactive mode — argument order here determines the
@@ -395,6 +405,8 @@ def parse_args() -> argparse.Namespace:
         "instead of streaming token-by-token. Requires -n or piped stdin.",
     )
 
+    add_json_output_arg(parser, default="text")
+
     parser.add_argument(
         "--auto-approve",
         action="store_true",
@@ -1204,6 +1216,8 @@ def cli_main() -> None:
                 sys.exit(1)
             sys.exit(0)
 
+        output_format = getattr(args, "output_format", "text")
+
         if args.command == "help":
             from deepagents_cli.ui import show_help
 
@@ -1211,11 +1225,11 @@ def cli_main() -> None:
         elif args.command == "list":
             from deepagents_cli.agent import list_agents
 
-            list_agents()
+            list_agents(output_format=output_format)
         elif args.command == "reset":
             from deepagents_cli.agent import reset_agent
 
-            reset_agent(args.agent, args.source_agent)
+            reset_agent(args.agent, args.source_agent, output_format=output_format)
         elif args.command == "skills":
             from deepagents_cli.skills import execute_skills_command
 
@@ -1238,10 +1252,13 @@ def cli_main() -> None:
                         branch=getattr(args, "branch", None),
                         verbose=getattr(args, "verbose", False),
                         relative=getattr(args, "relative", None),
+                        output_format=output_format,
                     )
                 )
             elif args.threads_command == "delete":
-                asyncio.run(delete_thread_command(args.thread_id))
+                asyncio.run(
+                    delete_thread_command(args.thread_id, output_format=output_format)
+                )
             else:
                 # No subcommand provided, show threads help screen
                 show_threads_help()

{deepagents_cli-0.0.31 → deepagents_cli-0.0.32}/deepagents_cli/non_interactive.py

@@ -773,10 +773,9 @@ async def run_non_interactive(
     thread_url_lookup: ThreadUrlLookupState | None = None
     if not quiet:
         thread_url_lookup = _start_langsmith_thread_url_lookup(thread_id)
-        console.print("[dim]Running task non-interactively...[/dim]")
+        console.print("[dim]Running task non-interactively...[/dim]", highlight=False)
         header = _build_non_interactive_header(assistant_id, thread_id)
         console.print(header)
-        console.print()
 
     sandbox_backend = None
     exit_stack = contextlib.ExitStack()
@@ -869,6 +868,9 @@ async def run_non_interactive(
                 assistant_id=assistant_id, backend=composite_backend
             )
 
+            if not quiet:
+                console.print()
+
             await _run_agent_loop(
                 agent,
                 message,

deepagents_cli-0.0.32/deepagents_cli/output.py

@@ -0,0 +1,69 @@
+"""Machine-readable JSON output helpers for CLI subcommands.
+
+This module deliberately stays stdlib-only so it can be imported from CLI
+startup paths without pulling in unnecessary dependency trees.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import Literal
+
+OutputFormat = Literal["text", "json"]
+"""Accepted internal output modes for CLI subcommands."""
+
+
+def add_json_output_arg(
+    parser: argparse.ArgumentParser, *, default: OutputFormat | None = None
+) -> None:
+    """Add a `--json` flag to an argparse parser.
+
+    Args:
+        parser: Parser to update.
+        default: Default output format for this parser.
+
+            Pass `None` for subparsers so parent parser values are preserved.
+    """
+    if default is None:
+        parser.add_argument(
+            "--json",
+            dest="output_format",
+            action="store_const",
+            const="json",
+            default=argparse.SUPPRESS,
+            help="Emit machine-readable JSON for this command",
+        )
+    else:
+        parser.add_argument(
+            "--json",
+            dest="output_format",
+            action="store_const",
+            const="json",
+            default=default,
+            help="Emit machine-readable JSON for this command",
+        )
+
+
+def write_json(command: str, data: list | dict) -> None:
+    """Write a JSON envelope to stdout and flush.
+
+    The envelope is a single-line JSON object with a stable schema:
+
+    ```json
+    {"schema_version": 1, "command": "...", "data": ...}
+    ```
+
+    Args:
+        command: Self-documenting command name (e.g. `'list'`,
+            `'threads list'`).
+        data: Payload — typically a list for listing commands or a dict
+            for action/info commands.
+
+            `default=str` is used so that `Path` and `datetime` objects
+            serialize without error.
+    """
+    envelope = {"schema_version": 1, "command": command, "data": data}
+    sys.stdout.write(json.dumps(envelope, default=str) + "\n")
+    sys.stdout.flush()

{deepagents_cli-0.0.31 → deepagents_cli-0.0.32}/deepagents_cli/sessions.py

@@ -18,6 +18,8 @@ if TYPE_CHECKING:
     from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
     from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
 
+    from deepagents_cli.output import OutputFormat
+
 logger = logging.getLogger(__name__)
 
 _aiosqlite_patched = False
@@ -964,6 +966,8 @@ async def list_threads_command(
     branch: str | None = None,
     verbose: bool = False,
     relative: bool | None = None,
+    *,
+    output_format: OutputFormat = "text",
 ) -> None:
     """CLI handler for `deepagents threads list`.
 
@@ -986,10 +990,8 @@ async def list_threads_command(
         relative: Show timestamps as relative time (e.g., '5m ago').
 
             When `None`, reads from config (`~/.deepagents/config.toml`).
+        output_format: Output format — `'text'` (Rich) or `'json'`.
     """
-    from rich.table import Table
-
-    from deepagents_cli.config import COLORS, console
     from deepagents_cli.model_config import (
         load_thread_relative_time,
         load_thread_sort_order,
@@ -1018,6 +1020,16 @@ async def list_threads_command(
             threads, include_message_count=False, include_initial_prompt=True
         )
 
+    if output_format == "json":
+        from deepagents_cli.output import write_json
+
+        write_json("threads list", list(threads))
+        return
+
+    from rich.table import Table
+
+    from deepagents_cli.config import COLORS, console
+
     if not threads:
         filters = []
         if agent_name:
@@ -1090,12 +1102,25 @@ async def list_threads_command(
     console.print()
 
 
-async def delete_thread_command(thread_id: str) -> None:
-    """CLI handler for: deepagents threads delete."""
-    from deepagents_cli.config import console
+async def delete_thread_command(
+    thread_id: str, *, output_format: OutputFormat = "text"
+) -> None:
+    """CLI handler for: deepagents threads delete.
 
+    Args:
+        thread_id: ID of the thread to delete.
+        output_format: Output format — `'text'` (Rich) or `'json'`.
+    """
     deleted = await delete_thread(thread_id)
 
+    if output_format == "json":
+        from deepagents_cli.output import write_json
+
+        write_json("threads delete", {"thread_id": thread_id, "deleted": deleted})
+        return
+
+    from deepagents_cli.config import console
+
     if deleted:
         console.print(f"[green]Thread '{thread_id}' deleted.[/green]")
     else: