deepagents-cli 0.0.38__tar.gz → 0.0.39__tar.gz

{deepagents_cli-0.0.38 → deepagents_cli-0.0.39}/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.0.39](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.38...deepagents-cli==0.0.39) (2026-04-17)
+
+
+### Features
+
+* **cli:** inline argument hints for slash commands ([#2181](https://github.com/langchain-ai/deepagents/issues/2181)) ([6b58e06](https://github.com/langchain-ai/deepagents/commit/6b58e06b06f6fb360d85c54eac31953d1e47dd7a))
+* **cli:** subagents for `deepagents deploy` ([#2786](https://github.com/langchain-ai/deepagents/issues/2786)) ([7dd5565](https://github.com/langchain-ai/deepagents/commit/7dd5565e30ab91a2cd2ca10fcd227e590451f13c))
+
+
+### Bug Fixes
+
+* **cli:** throttle update notification to once per day and fix teardown banner ([#2764](https://github.com/langchain-ai/deepagents/issues/2764)) ([ba31294](https://github.com/langchain-ai/deepagents/commit/ba31294b733d4ef542d18830eec6df30cfa0d23f))
+
 ## [0.0.38](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.37...deepagents-cli==0.0.38) (2026-04-15)
 
 

{deepagents_cli-0.0.38 → deepagents_cli-0.0.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-cli
-Version: 0.0.38
+Version: 0.0.39
 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.38 → deepagents_cli-0.0.39}/deepagents_cli/_version.py

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

{deepagents_cli-0.0.38 → deepagents_cli-0.0.39}/deepagents_cli/app.py

@@ -1439,7 +1439,7 @@ class DeepAgentsApp(App):
             )
 
             available, latest = await asyncio.to_thread(is_update_available)
-            if not available:
+            if not available or latest is None:
                 return
 
             self._update_available = (True, latest)
@@ -1447,7 +1447,7 @@ class DeepAgentsApp(App):
             logger.debug("Background update check failed", exc_info=True)
             return
 
-        # Phase 2: auto-update or notify (failures surfaced to user)
+        # Phase 2: auto-update or notify
         try:
             from deepagents_cli._version import __version__ as cli_version
 
@@ -1475,6 +1475,14 @@ class DeepAgentsApp(App):
                         markup=False,
                     )
             else:
+                from deepagents_cli.update_check import (
+                    mark_update_notified,
+                    should_notify_update,
+                )
+
+                if not await asyncio.to_thread(should_notify_update, latest):
+                    return
+
                 cmd = upgrade_command()
                 self.notify(
                     f"Update available: v{latest} (current: v{cli_version}). "
@@ -1484,13 +1492,15 @@ class DeepAgentsApp(App):
                     timeout=15,
                     markup=False,
                 )
+                await asyncio.to_thread(mark_update_notified, latest)
         except Exception:
-            logger.warning("Auto-update failed unexpectedly", exc_info=True)
-            self.notify(
-                "Update failed unexpectedly.",
-                severity="warning",
-                timeout=10,
-            )
+            logger.warning("Update check/notify failed unexpectedly", exc_info=True)
+            if is_auto_update_enabled():
+                self.notify(
+                    "Auto-update failed unexpectedly.",
+                    severity="warning",
+                    timeout=10,
+                )
 
     async def _show_whats_new(self) -> None:
         """Show a 'what's new' banner on the first launch after an upgrade."""
@@ -2763,6 +2773,15 @@ class DeepAgentsApp(App):
         elif cmd == "/remember" or cmd.startswith("/remember "):
             # Convenience alias for /skill:remember — shorter and discoverable
             # before skill loading completes.
+            if not await self._has_conversation_messages():
+                await self._mount_message(UserMessage(command))
+                await self._mount_message(
+                    AppMessage(
+                        "Nothing to remember yet. Start a conversation first,"
+                        " then use /remember to capture learnings."
+                    )
+                )
+                return
             args = command.strip()[len("/remember") :].strip()
             rewritten = f"/skill:remember {args}" if args else "/skill:remember"
             await self._handle_skill_command(rewritten)
@@ -3043,6 +3062,35 @@ class DeepAgentsApp(App):
         skill_name, args = parse_skill_command(command)
         await self._invoke_skill(skill_name, args, command=command)
 
+    async def _has_conversation_messages(self) -> bool:
+        """Check whether the current thread has at least one human message.
+
+        Returns:
+            `True` if the conversation contains a `HumanMessage`, `False`
+            otherwise. On transient errors (network, corrupt state) returns
+            `True` so that `/remember` is not blocked with a misleading
+            "nothing to remember" message.
+        """
+        if not self._agent:
+            return False
+        try:
+            from langchain_core.messages import HumanMessage
+
+            config: RunnableConfig = {
+                "configurable": {"thread_id": self._lc_thread_id},
+            }
+            state = await self._agent.aget_state(config)
+            if not state or not state.values:
+                return False
+            messages = state.values.get("messages", [])
+            return any(isinstance(m, HumanMessage) for m in messages)
+        except Exception:
+            logger.warning(
+                "Failed to check conversation messages; allowing /remember to proceed",
+                exc_info=True,
+            )
+            return True
+
     async def _get_conversation_token_count(self) -> int | None:
         """Return the approximate conversation-only token count.
 

{deepagents_cli-0.0.38 → deepagents_cli-0.0.39}/deepagents_cli/command_registry.py

@@ -1,7 +1,7 @@
 """Unified slash-command registry.
 
 Every slash command is declared once as a `SlashCommand` entry in `COMMANDS`.
-Bypass-tier frozensets and autocomplete tuples are derived automatically — no
+Bypass-tier frozensets and autocomplete entries are derived automatically — no
 other file should hard-code command metadata.
 """
 
@@ -9,7 +9,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import StrEnum
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, NamedTuple
 
 if TYPE_CHECKING:
     from deepagents_cli.skills.load import ExtendedSkillMetadata
@@ -50,9 +50,26 @@ class SlashCommand:
     hidden_keywords: str = ""
     """Space-separated terms for fuzzy matching (never displayed)."""
 
+    argument_hint: str = ""
+    """Placeholder text for autocomplete when the command accepts args."""
+
     aliases: tuple[str, ...] = ()
     """Alternative names (e.g. `("/q",)` for `/quit`)."""
 
+    def to_entry(self) -> CommandEntry:
+        """Project this command into a `CommandEntry` for autocomplete.
+
+        Returns:
+            A `CommandEntry` carrying only the fields the autocomplete
+                layer needs.
+        """
+        return CommandEntry(
+            name=self.name,
+            description=self.description,
+            hidden_keywords=self.hidden_keywords,
+            argument_hint=self.argument_hint,
+        )
+
 
 COMMANDS: tuple[SlashCommand, ...] = (
     SlashCommand(
@@ -94,11 +111,13 @@ COMMANDS: tuple[SlashCommand, ...] = (
         name="/remember",
         description="Update memory and skills from conversation",
         bypass_tier=BypassTier.QUEUED,
+        argument_hint="[context]",
     ),
     SlashCommand(  # Static alias; not auto-generated from skill discovery
         name="/skill-creator",
         description="Guide for creating effective agent skills",
         bypass_tier=BypassTier.QUEUED,
+        argument_hint="[task]",
     ),
     SlashCommand(
         name="/threads",
@@ -228,13 +247,28 @@ ALL_CLASSIFIED: frozenset[str] = (
 
 
 # ---------------------------------------------------------------------------
-# Autocomplete tuples
+# Autocomplete entries
 # ---------------------------------------------------------------------------
 
-SLASH_COMMANDS: list[tuple[str, str, str]] = [
-    (cmd.name, cmd.description, cmd.hidden_keywords) for cmd in COMMANDS
-]
-"""`(name, description, hidden_keywords)` tuples for `SlashCommandController`."""
+
+class CommandEntry(NamedTuple):
+    """A single autocomplete entry for the slash-command controller."""
+
+    name: str
+    """Canonical command name (e.g. `/quit`)."""
+
+    description: str
+    """Short user-facing description."""
+
+    hidden_keywords: str
+    """Space-separated terms for fuzzy matching (never displayed)."""
+
+    argument_hint: str
+    """Placeholder text shown when the command accepts arguments (e.g. `[context]`)."""
+
+
+SLASH_COMMANDS: list[CommandEntry] = [cmd.to_entry() for cmd in COMMANDS]
+"""Autocomplete entries derived from `COMMANDS` for `SlashCommandController`."""
 
 
 def parse_skill_command(command: str) -> tuple[str, str]:
@@ -271,8 +305,8 @@ appear as `/skill:model`).
 
 def build_skill_commands(
     skills: list[ExtendedSkillMetadata],
-) -> list[tuple[str, str, str]]:
-    """Build autocomplete tuples for discovered skills.
+) -> list[CommandEntry]:
+    """Build autocomplete entries for discovered skills.
 
     Each skill becomes a `/skill:<name>` entry with its description
     and the skill name as a hidden keyword for fuzzy matching.
@@ -285,10 +319,15 @@ def build_skill_commands(
         skills: List of discovered skill metadata.
 
     Returns:
-        List of `(name, description, hidden_keywords)` tuples.
+        List of `CommandEntry` instances.
     """
     return [
-        (f"/skill:{skill['name']}", skill["description"], skill["name"])
+        CommandEntry(
+            name=f"/skill:{skill['name']}",
+            description=skill["description"],
+            hidden_keywords=skill["name"],
+            argument_hint="",
+        )
         for skill in skills
         if skill["name"] not in _STATIC_SKILL_ALIASES
     ]

{deepagents_cli-0.0.38 → deepagents_cli-0.0.39}/deepagents_cli/deploy/bundler.py

@@ -27,6 +27,7 @@ import json
 import logging
 import shutil
 from pathlib import Path
+from typing import Any
 
 from deepagents_cli.deploy.config import (
     AGENTS_MD_FILENAME,
@@ -34,12 +35,15 @@ from deepagents_cli.deploy.config import (
     SKILLS_DIRNAME,
     USER_DIRNAME,
     DeployConfig,
+    SubAgentProject,
+    load_subagents,
 )
 from deepagents_cli.deploy.templates import (
     DEPLOY_GRAPH_TEMPLATE,
     MCP_TOOLS_TEMPLATE,
     PYPROJECT_TEMPLATE,
     SANDBOX_BLOCKS,
+    SYNC_SUBAGENTS_TEMPLATE,
 )
 
 logger = logging.getLogger(__name__)
@@ -77,7 +81,7 @@ def bundle(
     system_prompt = agents_md_path.read_text(encoding="utf-8")
 
     # 2. Build and write the seed payload: memory (AGENTS.md) + skills/.
-    seed = _build_seed(config, project_root, system_prompt)
+    seed = _build_seed(project_root, system_prompt)
     (build_dir / "_seed.json").write_text(
         json.dumps(seed, indent=2, ensure_ascii=False),
         encoding="utf-8",
@@ -104,35 +108,89 @@ def bundle(
         shutil.copy2(env_src, build_dir / ".env")
         logger.info("Copied %s → .env", env_src)
 
-    # 4. Render deploy_graph.py.
+    # 4. Load subagents (needed for both deploy_graph.py and pyproject.toml).
+    sync_subagents = load_subagents(project_root)
+
+    # 5. Render deploy_graph.py.
     has_user_memories = (project_root / USER_DIRNAME).is_dir()
+    has_sync_subagents = bool(sync_subagents)
     (build_dir / "deploy_graph.py").write_text(
         _render_deploy_graph(
             config,
             mcp_present=mcp_present,
             has_user_memories=has_user_memories,
+            has_sync_subagents=has_sync_subagents,
         ),
         encoding="utf-8",
     )
     logger.info("Generated deploy_graph.py")
 
-    # 5. Render langgraph.json.
+    # 6. Render langgraph.json.
     (build_dir / "langgraph.json").write_text(
         _render_langgraph_json(env_present=env_present),
         encoding="utf-8",
     )
 
-    # 6. Render pyproject.toml.
+    # 7. Render pyproject.toml.
+    subagent_model_providers: list[str] = []
+    has_subagent_mcp = False
+    for sa in sync_subagents.values():
+        model = sa.config.agent.model
+        if ":" in model:
+            subagent_model_providers.append(model.split(":", 1)[0])
+        if (sa.root / MCP_FILENAME).is_file():
+            has_subagent_mcp = True
+
     (build_dir / "pyproject.toml").write_text(
-        _render_pyproject(config, mcp_present=mcp_present),
+        _render_pyproject(
+            config,
+            mcp_present=mcp_present,
+            subagent_model_providers=subagent_model_providers,
+            has_subagent_mcp=has_subagent_mcp,
+        ),
         encoding="utf-8",
     )
 
     return build_dir
 
 
+def _build_subagent_seed(subagent: SubAgentProject) -> dict:
+    """Build the seed entry for a single sync subagent."""
+    sa_root = subagent.root
+    agent = subagent.config.agent
+
+    memories: dict[str, str] = {
+        f"/{AGENTS_MD_FILENAME}": (sa_root / AGENTS_MD_FILENAME).read_text(
+            encoding="utf-8"
+        ),
+    }
+
+    skills: dict[str, str] = {}
+    skills_dir = sa_root / SKILLS_DIRNAME
+    if skills_dir.is_dir():
+        for f in sorted(skills_dir.rglob("*")):
+            if f.is_file() and not f.name.startswith("."):
+                rel = f.relative_to(skills_dir).as_posix()
+                skills[f"/{rel}"] = f.read_text(encoding="utf-8")
+
+    mcp_path = sa_root / MCP_FILENAME
+    mcp = None
+    if mcp_path.is_file():
+        mcp = json.loads(mcp_path.read_text(encoding="utf-8"))
+
+    return {
+        "config": {
+            "name": agent.name,
+            "description": agent.description,
+            "model": agent.model,
+        },
+        "memories": memories,
+        "skills": skills,
+        "mcp": mcp,
+    }
+
+
 def _build_seed(
-    config: DeployConfig,  # noqa: ARG001
     project_root: Path,
     system_prompt: str,
 ) -> dict:
@@ -172,18 +230,28 @@ def _build_seed(
         )
         user_memories[f"/{AGENTS_MD_FILENAME}"] = content
 
-    return {
+    seed: dict = {
         "memories": memories,
         "skills": skills,
         "user_memories": user_memories,
     }
 
+    # Sync subagents.
+    sync_subagents = load_subagents(project_root)
+    if sync_subagents:
+        seed["subagents"] = {
+            name: _build_subagent_seed(sa) for name, sa in sync_subagents.items()
+        }
+
+    return seed
+
 
 def _render_deploy_graph(
     config: DeployConfig,
     *,
     mcp_present: bool,
     has_user_memories: bool = False,
+    has_sync_subagents: bool = False,
 ) -> str:
     """Render the generated `deploy_graph.py`."""
     provider = config.sandbox.provider
@@ -199,6 +267,16 @@ def _render_deploy_graph(
         mcp_tools_block = ""
         mcp_tools_load_call = "pass  # no MCP servers configured"
 
+    if has_sync_subagents:
+        sync_subagents_block = SYNC_SUBAGENTS_TEMPLATE
+        sync_subagents_load_call = (
+            "all_subagents.extend("
+            "await _build_sync_subagents(seed, store, assistant_id))"
+        )
+    else:
+        sync_subagents_block = ""
+        sync_subagents_load_call = "pass  # no sync subagents"
+
     return DEPLOY_GRAPH_TEMPLATE.format(
         model=config.agent.model,
         sandbox_template=config.sandbox.template,
@@ -209,6 +287,8 @@ def _render_deploy_graph(
         mcp_tools_load_call=mcp_tools_load_call,
         default_assistant_id=config.agent.name,
         has_user_memories=has_user_memories,
+        sync_subagents_block=sync_subagents_block,
+        sync_subagents_load_call=sync_subagents_load_call,
     )
 
 
@@ -224,7 +304,13 @@ def _render_langgraph_json(*, env_present: bool) -> str:
     return json.dumps(data, indent=2) + "\n"
 
 
-def _render_pyproject(config: DeployConfig, *, mcp_present: bool) -> str:
+def _render_pyproject(
+    config: DeployConfig,
+    *,
+    mcp_present: bool,
+    subagent_model_providers: list[str] | None = None,
+    has_subagent_mcp: bool = False,
+) -> str:
     """Render the deployment package's `pyproject.toml`.
 
     Deps are inferred — the user never writes them. We add:
@@ -241,7 +327,13 @@ def _render_pyproject(config: DeployConfig, *, mcp_present: bool) -> str:
     if provider_prefix and provider_prefix in _MODEL_PROVIDER_DEPS:
         deps.append(_MODEL_PROVIDER_DEPS[provider_prefix])
 
-    if mcp_present:
+    # Add deps for subagent model providers.
+    for sp in subagent_model_providers or []:
+        dep = _MODEL_PROVIDER_DEPS.get(sp)
+        if dep and dep not in deps:
+            deps.append(dep)
+
+    if mcp_present or has_subagent_mcp:
         deps.append("langchain-mcp-adapters")
 
     _, partner_pkg = SANDBOX_BLOCKS.get(config.sandbox.provider, (None, None))
@@ -259,7 +351,7 @@ def _render_pyproject(config: DeployConfig, *, mcp_present: bool) -> str:
 def print_bundle_summary(config: DeployConfig, build_dir: Path) -> None:
     """Print a human-readable summary of what was bundled."""
     seed_path = build_dir / "_seed.json"
-    seed: dict[str, dict[str, str]] = {"memories": {}, "skills": {}}
+    seed: dict[str, Any] = {"memories": {}, "skills": {}}
     if seed_path.exists():
         try:
             seed = json.loads(seed_path.read_text(encoding="utf-8"))
@@ -294,6 +386,14 @@ def print_bundle_summary(config: DeployConfig, build_dir: Path) -> None:
     if (build_dir / "_mcp.json").exists():
         print("\n  MCP config: _mcp.json")
 
+    # Subagent summary.
+    sync_subagents = seed.get("subagents", {})
+    if sync_subagents:
+        print(f"\n  Subagents ({len(sync_subagents)}):")
+        for name, sa_data in sync_subagents.items():
+            desc = sa_data.get("config", {}).get("description", "")
+            print(f"    {name} \u2014 {desc}")
+
     print(f"\n  Sandbox: {config.sandbox.provider}")
     print(f"\n  Build directory: {build_dir}")
     generated = sorted(f.name for f in build_dir.iterdir() if f.is_file())

{deepagents_cli-0.0.38 → deepagents_cli-0.0.39}/deepagents_cli/deploy/commands.py

@@ -6,6 +6,7 @@ Registered with the CLI via `setup_deploy_parsers` in `main.py`.
 from __future__ import annotations
 
 import argparse
+import os
 import subprocess
 import tempfile
 from pathlib import Path
@@ -402,12 +403,14 @@ def _run_langgraph_deploy(build_dir: Path, *, name: str) -> None:
 
     config_path = str(build_dir / "langgraph.json")
     cmd = ["langgraph", "deploy", "-c", config_path, "--name", name, "--verbose"]
+    env = os.environ.copy()
+    env["LANGGRAPH_CLI_ANALYTICS_SOURCE"] = "deepagents"
 
     print("Deploying to LangSmith Deployments...")
     print(f"Running: {' '.join(cmd)}")
     print()
 
-    result = subprocess.run(cmd, cwd=str(build_dir), check=False)
+    result = subprocess.run(cmd, cwd=str(build_dir), check=False, env=env)
 
     if result.returncode != 0:
         print(f"\nDeployment failed (exit code {result.returncode}).")