deepagents-cli 0.0.33__tar.gz → 0.0.34__tar.gz

{deepagents_cli-0.0.33 → deepagents_cli-0.0.34}/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.0.34](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.33...deepagents-cli==0.0.34) (2026-03-17)
+
+### Features
+
+* External editor support via `ctrl+x` and `/editor` ([#1861](https://github.com/langchain-ai/deepagents/issues/1861)) ([bf5d088](https://github.com/langchain-ai/deepagents/commit/bf5d088d4b3cee6c7e44c3abe3736f9972897896))
+* Defer HITL approval menu while user is typing ([#1833](https://github.com/langchain-ai/deepagents/issues/1833)) ([1d1572e](https://github.com/langchain-ai/deepagents/commit/1d1572e40cc9f87b97832cbe2b9152c281f8ec92))
+
+### Bug Fixes
+
+* Resolve config-defined providers during runtime model swaps ([#1941](https://github.com/langchain-ai/deepagents/issues/1941)) ([aebc660](https://github.com/langchain-ai/deepagents/commit/aebc660321895909f6b6eb71e72a99ca7754bcf1))
+
 ## [0.0.33](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.32...deepagents-cli==0.0.33) (2026-03-16)
 
 ### Highlights

{deepagents_cli-0.0.33 → deepagents_cli-0.0.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-cli
-Version: 0.0.33
+Version: 0.0.34
 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.34/deepagents_cli/_version.py

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

{deepagents_cli-0.0.33 → deepagents_cli-0.0.34}/deepagents_cli/agent.py

@@ -7,6 +7,7 @@ import os
 import re
 import shutil
 import tempfile
+import tomllib
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
@@ -19,6 +20,7 @@ if TYPE_CHECKING:
     from collections.abc import Callable, Sequence
 
     from deepagents.backends.sandbox import SandboxBackendProtocol
+    from deepagents.middleware.async_subagents import AsyncSubAgent
     from deepagents.middleware.subagents import CompiledSubAgent, SubAgent
     from langchain.agents.middleware import InterruptOnConfig
     from langchain.agents.middleware.types import AgentState
@@ -63,6 +65,74 @@ REQUIRE_COMPACT_TOOL_APPROVAL: bool = True
 """When `True`, `compact_conversation` requires HITL approval like other gated tools."""
 
 
+def load_async_subagents(config_path: Path | None = None) -> list[AsyncSubAgent]:
+    """Load async subagent definitions from `config.toml`.
+
+    Reads the `[async_subagents]` section where each sub-table defines a remote
+    LangGraph deployment:
+
+    ```toml
+    [async_subagents.researcher]
+    description = "Research agent"
+    url = "https://my-deployment.langsmith.dev"
+    graph_id = "agent"
+    ```
+
+    Args:
+        config_path: Path to config file.
+
+            Defaults to `~/.deepagents/config.toml`.
+
+    Returns:
+        List of `AsyncSubAgent` specs (empty if section is absent or invalid).
+    """
+    if config_path is None:
+        config_path = Path.home() / ".deepagents" / "config.toml"
+
+    if not config_path.exists():
+        return []
+
+    try:
+        with config_path.open("rb") as f:
+            data = tomllib.load(f)
+    except (tomllib.TOMLDecodeError, PermissionError, OSError) as e:
+        logger.warning("Could not read async subagents from %s: %s", config_path, e)
+        console.print(
+            f"[bold yellow]Warning:[/bold yellow] Could not read async subagents "
+            f"from {config_path}: {e}",
+        )
+        return []
+
+    section = data.get("async_subagents")
+    if not isinstance(section, dict):
+        return []
+
+    required = {"description", "graph_id"}
+    agents: list[AsyncSubAgent] = []
+    for name, spec in section.items():
+        if not isinstance(spec, dict):
+            logger.warning("Skipping async subagent '%s': expected a table", name)
+            continue
+        missing = required - spec.keys()
+        if missing:
+            logger.warning(
+                "Skipping async subagent '%s': missing fields %s", name, missing
+            )
+            continue
+        agent: AsyncSubAgent = {
+            "name": name,
+            "description": spec["description"],
+            "graph_id": spec["graph_id"],
+        }
+        if "url" in spec and isinstance(spec["url"], str):
+            agent["url"] = spec["url"]
+        if "headers" in spec and isinstance(spec["headers"], dict):
+            agent["headers"] = spec["headers"]
+        agents.append(agent)
+
+    return agents
+
+
 def list_agents(*, output_format: OutputFormat = "text") -> None:
     """List all available agents.
 
@@ -537,6 +607,11 @@ def _add_interrupt_on() -> dict[str, InterruptOnConfig]:
         "description": _format_task_description,  # type: ignore[typeddict-item]  # Callable description narrower than TypedDict expects
     }
 
+    async_subagent_interrupt_config: InterruptOnConfig = {
+        "allowed_decisions": ["approve", "reject"],
+        "description": "Launch, update, or cancel a remote async subagent.",
+    }
+
     interrupt_map: dict[str, InterruptOnConfig] = {
         "execute": execute_interrupt_config,
         "write_file": write_file_interrupt_config,
@@ -544,6 +619,9 @@ def _add_interrupt_on() -> dict[str, InterruptOnConfig]:
         "web_search": web_search_interrupt_config,
         "fetch_url": fetch_url_interrupt_config,
         "task": task_interrupt_config,
+        "launch_async_subagent": async_subagent_interrupt_config,
+        "update_async_subagent": async_subagent_interrupt_config,
+        "cancel_async_subagent": async_subagent_interrupt_config,
     }
 
     if REQUIRE_COMPACT_TOOL_APPROVAL:
@@ -577,6 +655,7 @@ def create_cli_agent(
     mcp_server_info: list[MCPServerInfo] | None = None,
     cwd: str | Path | None = None,
     project_context: ProjectContext | None = None,
+    async_subagents: list[AsyncSubAgent] | None = None,
 ) -> tuple[Pregel, CompositeBackend]:
     """Create a CLI-configured agent with flexible options.
 
@@ -619,6 +698,9 @@ def create_cli_agent(
         project_context: Explicit project path context for project-sensitive
             behavior such as project `AGENTS.md` files, skills, subagents, and
             MCP trust.
+        async_subagents: Remote LangGraph deployments to expose as async subagent tools.
+
+            Loaded from `[async_subagents]` in `config.toml` or passed directly.
 
     Returns:
         2-tuple of `(agent_graph, backend)`
@@ -817,14 +899,23 @@ def create_cli_agent(
     )
 
     # Create the agent
-    agent = create_deep_agent(
-        model=model,
-        system_prompt=system_prompt,
-        tools=tools,
-        backend=composite_backend,
-        middleware=agent_middleware,
-        interrupt_on=interrupt_on,
-        checkpointer=checkpointer,
-        subagents=custom_subagents or None,
-    ).with_config(config)
+    #
+    # TODO: revert to direct keyword arguments once the CLI pins SDK >=0.5.0.
+    # We use **kwargs here because `async_subagents` was added in SDK 0.5.0 but
+    # the CLI still pins 0.4.x. Passing an unknown kwarg — even as None — raises
+    # TypeError, so we must omit it from the dict entirely when unused.
+    agent_kwargs: dict[str, Any] = {
+        "model": model,
+        "system_prompt": system_prompt,
+        "tools": tools,
+        "backend": composite_backend,
+        "middleware": agent_middleware,
+        "interrupt_on": interrupt_on,
+        "checkpointer": checkpointer,
+        "subagents": custom_subagents or None,
+    }
+    if async_subagents:
+        agent_kwargs["async_subagents"] = async_subagents
+
+    agent = create_deep_agent(**agent_kwargs).with_config(config)
     return agent, composite_backend

{deepagents_cli-0.0.33 → deepagents_cli-0.0.34}/deepagents_cli/app.py

@@ -26,6 +26,7 @@ from textual.css.query import NoMatches
 from textual.message import Message
 from textual.screen import ModalScreen
 from textual.style import Style as TStyle
+from textual.widgets import Static
 
 from deepagents_cli.clipboard import copy_selection_to_clipboard
 from deepagents_cli.config import (
@@ -90,7 +91,6 @@ if TYPE_CHECKING:
     from textual.events import Click, MouseUp, Paste
     from textual.scrollbar import ScrollUp
     from textual.widget import Widget
-    from textual.widgets import Static
     from textual.worker import Worker
 
     from deepagents_cli.ask_user import AskUserWidgetResult, Question
@@ -255,6 +255,18 @@ def _extract_model_params_flag(raw_arg: str) -> tuple[str, dict[str, Any] | None
 
 InputMode = Literal["normal", "shell", "command"]
 
+_TYPING_IDLE_THRESHOLD_SECONDS: float = 2.0
+"""Seconds since the last keystroke after which the user is considered idle and
+a pending approval widget can be shown.
+
+Two seconds balances responsiveness with avoiding accidental approval
+key presses.
+"""
+
+_DEFERRED_APPROVAL_TIMEOUT_SECONDS: float = 30.0
+"""Maximum seconds the deferred-approval worker will wait for the user to stop
+typing before showing the approval widget regardless."""
+
 
 @dataclass(frozen=True, slots=True)
 class QueuedMessage:
@@ -503,6 +515,13 @@ class DeepAgentsApp(App):
             show=False,
             priority=True,
         ),
+        Binding(
+            "ctrl+x",
+            "open_editor",
+            "Open Editor",
+            show=False,
+            priority=True,
+        ),
         # Approval menu keys (handled at App level for reliability)
         Binding("up", "approval_up", "Up", show=False),
         Binding("k", "approval_up", "Up", show=False),
@@ -621,6 +640,9 @@ class DeepAgentsApp(App):
         self._shell_running = False
         self._loading_widget: LoadingWidget | None = None
         self._token_tracker: TextualTokenTracker | None = None
+        # Typing-aware approval deferral state
+        self._last_typed_at: float | None = None
+        self._approval_placeholder: Static | None = None
         # Cumulative usage stats across all turns in this session
         self._session_stats: SessionStats = SessionStats()
         # User message queue for sequential processing
@@ -1220,27 +1242,114 @@ class DeepAgentsApp(App):
         menu = ApprovalMenu(action_requests, assistant_id, id=unique_id)
         menu.set_future(result_future)
 
-        # Store reference
         self._pending_approval_widget = menu
 
-        # Mount approval inline in messages area (not replacing ChatInput)
+        if self._is_user_typing():
+            # Show a placeholder until the user stops typing, then swap in the
+            # real ApprovalMenu.  This prevents accidental key presses (e.g.
+            # 'y', 'n') from triggering approval decisions mid-sentence.
+            placeholder = Static(
+                "Waiting for typing to finish...",
+                classes="approval-placeholder",
+            )
+            self._approval_placeholder = placeholder
+            try:
+                messages = self.query_one("#messages", Container)
+                await self._mount_before_queued(messages, placeholder)
+                self.call_after_refresh(placeholder.scroll_visible)
+            except Exception:
+                logger.exception("Failed to mount approval placeholder")
+                # Placeholder failed — fall back to showing the menu directly
+                # so the future is always resolvable.
+                self._approval_placeholder = None
+                await self._mount_approval_widget(menu, result_future)
+                return result_future
+
+            self.run_worker(
+                self._deferred_show_approval(placeholder, menu, result_future),
+                exclusive=False,
+            )
+        else:
+            await self._mount_approval_widget(menu, result_future)
+
+        return result_future
+
+    async def _mount_approval_widget(
+        self,
+        menu: ApprovalMenu,
+        result_future: asyncio.Future[dict[str, str]],
+    ) -> None:
+        """Mount the approval menu widget inline in the messages area.
+
+        If mounting fails, clears `_pending_approval_widget` and propagates
+        the exception via `result_future`.
+
+        Args:
+            menu: The `ApprovalMenu` instance to mount.
+            result_future: The future to resolve/reject for the caller.
+        """
         try:
             messages = self.query_one("#messages", Container)
             await self._mount_before_queued(messages, menu)
-            # Scroll to make approval visible (but don't re-anchor)
             self.call_after_refresh(menu.scroll_visible)
-            # Focus approval menu
             self.call_after_refresh(menu.focus)
         except Exception as e:
             logger.exception(
                 "Failed to mount approval menu (id=%s) in messages container",
-                unique_id,
+                menu.id,
             )
             self._pending_approval_widget = None
             if not result_future.done():
                 result_future.set_exception(e)
 
-        return result_future
+    async def _deferred_show_approval(
+        self,
+        placeholder: Static,
+        menu: ApprovalMenu,
+        result_future: asyncio.Future[dict[str, str]],
+    ) -> None:
+        """Wait until the user is idle, then swap the placeholder for the real menu.
+
+        Exits early if the placeholder has already been detached (e.g. the
+        approval was cancelled while waiting).  In that case the future is
+        cancelled so the caller is not left hanging.
+
+        Args:
+            placeholder: The temporary placeholder widget currently mounted.
+            menu: The `ApprovalMenu` to show once the user stops typing.
+            result_future: The future backing this approval flow.
+        """
+        deadline = _monotonic() + _DEFERRED_APPROVAL_TIMEOUT_SECONDS
+        while self._is_user_typing():  # Simple polling
+            if _monotonic() > deadline:
+                logger.warning(
+                    "Timed out waiting for user to stop typing; showing approval now"
+                )
+                break
+            await asyncio.sleep(0.2)
+
+        # Guard: if the placeholder was already removed (e.g. agent cancelled
+        # the approval while we were waiting), clean up and cancel the future.
+        if not placeholder.is_attached:
+            logger.warning(
+                "Approval placeholder detached before menu shown (id=%s)",
+                menu.id,
+            )
+            self._approval_placeholder = None
+            self._pending_approval_widget = None
+            if not result_future.done():
+                result_future.cancel()
+            return
+
+        self._approval_placeholder = None
+        try:
+            await placeholder.remove()
+        except Exception:
+            logger.warning(
+                "Failed to remove approval placeholder during swap",
+                exc_info=True,
+            )
+        await self._mount_approval_widget(menu, result_future)
 
     def _on_auto_approve_enabled(self) -> None:
         """Handle auto-approve being enabled via the HITL approval menu.
@@ -1414,11 +1523,42 @@ class DeepAgentsApp(App):
         if self._status_bar:
             self._status_bar.set_mode(event.mode)
 
+    def on_chat_input_typing(
+        self,
+        event: ChatInput.Typing,  # noqa: ARG002  # Textual event handler signature
+    ) -> None:
+        """Record the most recent keystroke time for typing-aware approval deferral."""
+        self._last_typed_at = _monotonic()
+
+    def _is_user_typing(self) -> bool:
+        """Return whether the user typed recently (within the idle threshold).
+
+        Returns:
+            `True` if the last recorded typing event occurred within the last
+                `_TYPING_IDLE_THRESHOLD_SECONDS` seconds, `False` otherwise.
+        """
+        if self._last_typed_at is None:
+            return False
+        return (_monotonic() - self._last_typed_at) < _TYPING_IDLE_THRESHOLD_SECONDS
+
     async def on_approval_menu_decided(
         self,
         event: Any,  # noqa: ARG002, ANN401  # Textual event handler signature
     ) -> None:
         """Handle approval menu decision - remove from messages and refocus input."""
+        # Defensively remove any lingering placeholder (should already be gone
+        # once the deferred worker swaps it, but guard against edge cases).
+        if self._approval_placeholder is not None:
+            if self._approval_placeholder.is_attached:
+                try:
+                    await self._approval_placeholder.remove()
+                except Exception:
+                    logger.warning(
+                        "Failed to remove approval placeholder during cleanup",
+                        exc_info=True,
+                    )
+            self._approval_placeholder = None
+
         # Remove ApprovalMenu using stored reference
         if self._pending_approval_widget:
             await self._pending_approval_widget.remove()
@@ -1659,12 +1799,13 @@ class DeepAgentsApp(App):
         elif cmd == "/help":
             await self._mount_message(UserMessage(command))
             help_body = (
-                "Commands: /quit, /clear, /offload, /mcp, "
+                "Commands: /quit, /clear, /offload, /editor, /mcp, "
                 "/model [--model-params JSON] [--default], /reload, /remember, "
                 "/tokens, /threads, /trace, /changelog, /docs, /feedback, /help\n\n"
                 "Interactive Features:\n"
                 "  Enter           Submit your message\n"
                 f"  {newline_shortcut():<15} Insert newline\n"
+                "  Ctrl+X          Open prompt in external editor\n"
                 "  Shift+Tab       Toggle auto-approve mode\n"
                 "  @filename       Auto-complete files and inject content\n"
                 "  /command        Slash commands (/help, /clear, /quit)\n"
@@ -1728,6 +1869,8 @@ class DeepAgentsApp(App):
                 await self._mount_message(
                     AppMessage(f"Started new thread: {new_thread_id}")
                 )
+        elif cmd == "/editor":
+            await self.action_open_editor()
         elif cmd in {"/offload", "/compact"}:
             await self._mount_message(UserMessage(command))
             await self._handle_offload()
@@ -2950,6 +3093,36 @@ class DeepAgentsApp(App):
         if self._pending_approval_widget:
             self._pending_approval_widget.action_select_reject()
 
+    async def action_open_editor(self) -> None:
+        """Open the current prompt text in an external editor ($VISUAL/$EDITOR)."""
+        from deepagents_cli.editor import open_in_editor
+
+        chat_input = self._chat_input
+        if not chat_input or not chat_input._text_area:
+            return
+
+        current_text = chat_input._text_area.text or ""
+
+        edited: str | None = None
+        try:
+            with self.suspend():
+                edited = open_in_editor(current_text)
+        except Exception:
+            logger.warning("External editor failed", exc_info=True)
+            self.notify(
+                "External editor failed. Check $VISUAL/$EDITOR.",
+                severity="error",
+                timeout=5,
+            )
+            chat_input.focus_input()
+            return
+
+        if edited is not None:
+            chat_input._text_area.text = edited
+            lines = edited.split("\n")
+            chat_input._text_area.move_cursor((len(lines) - 1, len(lines[-1])))
+        chat_input.focus_input()
+
     def on_paste(self, event: Paste) -> None:
         """Route unfocused paste events to chat input for drag/drop reliability."""
         if not self._chat_input:

{deepagents_cli-0.0.33 → deepagents_cli-0.0.34}/deepagents_cli/app.tcss

@@ -51,6 +51,16 @@ Screen {
     border: solid $warning;
 }
 
+/* Placeholder shown while the user is actively typing (approval deferred) */
+.approval-placeholder {
+    height: auto;
+    margin: 1 0;
+    padding: 0 1;
+    border: solid $panel;
+    color: $text-muted;
+    text-style: italic;
+}
+
 .approval-menu .approval-title {
     text-style: bold;
     color: $warning;

{deepagents_cli-0.0.33 → deepagents_cli-0.0.34}/deepagents_cli/built_in_skills/skill-creator/SKILL.md

@@ -7,15 +7,6 @@ compatibility: designed for deepagents-cli
 
 # Skill Creator
 
-This skill provides guidance for creating effective skills.
-
-## About Skills
-
-Skills are modular, self-contained packages that extend agent capabilities by providing
-specialized knowledge, workflows, and tools. Think of them as "onboarding guides" for specific
-domains or tasks—they transform a general-purpose agent into a specialized agent
-equipped with procedural knowledge and domain expertise.
-
 ### Skill Location for Deepagents
 
 The deepagents CLI loads skills from five sources, listed here from lowest to highest precedence:
@@ -44,13 +35,6 @@ Example directory layout:
 └── ...
 ```
 
-### What Skills Provide
-
-1. Specialized workflows - Multi-step procedures for specific domains
-2. Tool integrations - Instructions for working with specific file formats or APIs
-3. Domain expertise - Company-specific knowledge, schemas, business logic
-4. Bundled resources - Scripts, references, and assets for complex and repetitive tasks
-
 ## Core Principles
 
 ### Concise is Key

{deepagents_cli-0.0.33 → deepagents_cli-0.0.34}/deepagents_cli/configurable_model.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING, Any
 
-from deepagents._models import model_matches_spec, resolve_model  # noqa: PLC2701
+from deepagents._models import model_matches_spec  # noqa: PLC2701
 from langchain.agents.middleware.types import (
     AgentMiddleware,
     ModelRequest,
@@ -41,19 +41,22 @@ class CLIContext(TypedDict, total=False):
 
 
 def _is_anthropic_model(model: object) -> bool:
-    """Check whether a resolved model is an Anthropic `ChatAnthropic` instance.
+    """Check whether a resolved model reports `'anthropic'` as its provider.
 
-    Returns `False` if `langchain-anthropic` is not installed.
+    Uses `_get_ls_params` from `BaseChatModel` to read the provider name.
 
     Returns:
-        `True` if the model is a `ChatAnthropic` instance.
+        `True` if the model's `ls_provider` is `'anthropic'`.
     """
     try:
-        from langchain_anthropic import ChatAnthropic
-    except ImportError:
-        logger.debug("langchain_anthropic not installed; assuming non-Anthropic model")
+        ls_params = model._get_ls_params()  # type: ignore[attr-defined]
+    except (AttributeError, TypeError, RuntimeError):
+        logger.debug(
+            "_get_ls_params raised for %s; assuming non-Anthropic",
+            type(model).__name__,
+        )
         return False
-    return isinstance(model, ChatAnthropic)
+    return isinstance(ls_params, dict) and ls_params.get("ls_provider") == "anthropic"
 
 
 _ANTHROPIC_ONLY_SETTINGS: set[str] = {"cache_control"}
@@ -83,8 +86,19 @@ def _apply_overrides(request: ModelRequest) -> ModelRequest:
     new_model = None
     model = ctx.get("model")
     if model and not model_matches_spec(request.model, model):
+        from deepagents_cli.config import create_model
+        from deepagents_cli.model_config import ModelConfigError
+
         logger.debug("Overriding model to %s", model)
-        new_model = resolve_model(model)
+        try:
+            new_model = create_model(model).model
+        except ModelConfigError:
+            logger.exception(
+                "Failed to resolve runtime model override '%s'; "
+                "continuing with current model",
+                model,
+            )
+            return request
         overrides["model"] = new_model
 
     # Param merge