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

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

@@ -1,5 +1,35 @@
 # 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)
+
+
+### Features
+
+* **cli:** user scoped memory ([#2708](https://github.com/langchain-ai/deepagents/issues/2708)) ([23bfca6](https://github.com/langchain-ai/deepagents/commit/23bfca6e46e6f3e4fba6657d858ddd5a0b06626f))
+
+
+### Bug Fixes
+
+* **deepagents:** remove old integration tests ([#2728](https://github.com/langchain-ai/deepagents/issues/2728)) ([6653197](https://github.com/langchain-ai/deepagents/commit/6653197b6cbec6dd1ca23d9f90bc1439ca26e6e5))
+
+
+### Performance Improvements
+
+* **cli:** `O(1)` message lookups in `MessageStore` ([#2350](https://github.com/langchain-ai/deepagents/issues/2350)) ([d39fd5d](https://github.com/langchain-ai/deepagents/commit/d39fd5d3651fd87d1eea8c02cbef2c2f62449e67))
+
 ## [0.0.37](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.36...deepagents-cli==0.0.37) (2026-04-10)
 
 ### Features

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-cli
-Version: 0.0.37
+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/
@@ -27,7 +27,7 @@ Classifier: Topic :: Terminals
 Requires-Python: <4.0,>=3.11
 Requires-Dist: aiosqlite<1.0.0,>=0.19.0
 Requires-Dist: deepagents-acp>=0.0.4
-Requires-Dist: deepagents==0.5.2
+Requires-Dist: deepagents==0.5.3
 Requires-Dist: httpx<1.0.0,>=0.28.1
 Requires-Dist: langchain-anthropic<2.0.0,>=1.4.0
 Requires-Dist: langchain-google-genai<5.0.0,>=4.2.1

{deepagents_cli-0.0.37 → deepagents_cli-0.0.39}/deepagents_cli/_version.py

@@ -1,6 +1,6 @@
 """Version information and lightweight constants for `deepagents-cli`."""
 
-__version__ = "0.0.37"  # 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.37 → 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."""
@@ -1505,11 +1515,15 @@ class DeepAgentsApp(App):
 
         try:
             from deepagents_cli._version import __version__ as cli_version
+            from deepagents_cli.config import _is_editable_install
+
+            if await asyncio.to_thread(_is_editable_install):
+                heading = f"Now running v{cli_version}"
+            else:
+                heading = f"Updated to v{cli_version}"
 
             await self._mount_message(
-                AppMessage(
-                    f"Updated to v{cli_version}\nSee what's new: {CHANGELOG_URL}"
-                )
+                AppMessage(f"{heading}\nSee what's new: {CHANGELOG_URL}")
             )
         except Exception:
             logger.debug("What's new banner display failed", exc_info=True)
@@ -2759,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)
@@ -3039,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.37 → 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.37 → deepagents_cli-0.0.39}/deepagents_cli/deploy/bundler.py

@@ -9,9 +9,16 @@ Reads the canonical project layout:
     .env             # optional — environment variables
     mcp.json         # optional — HTTP/SSE MCP servers
     skills/          # optional — auto-seeded into skills namespace
+    user/            # optional — per-user writable memory
+        AGENTS.md    # optional — seeded as empty if not provided
 ```
 
 ...and writes everything `langgraph deploy` needs to a build directory.
+
+AGENTS.md and skills are read-only at runtime.  When a ``user/``
+directory is present, a per-user ``AGENTS.md`` is seeded (from
+``user/AGENTS.md`` if provided, otherwise empty) and is writable
+at runtime.
 """
 
 from __future__ import annotations
@@ -20,18 +27,23 @@ import json
 import logging
 import shutil
 from pathlib import Path
+from typing import Any
 
 from deepagents_cli.deploy.config import (
     AGENTS_MD_FILENAME,
     MCP_FILENAME,
     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__)
@@ -69,15 +81,16 @@ 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",
     )
     logger.info(
-        "Wrote _seed.json (memories: %d, skills: %d)",
+        "Wrote _seed.json (memories: %d, skills: %d, user_memories: %d)",
         len(seed["memories"]),
         len(seed["skills"]),
+        len(seed.get("user_memories", {})),
     )
 
     # 3. Copy mcp.json if present.
@@ -95,58 +108,110 @@ 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),
+        _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[str, dict[str, str]]:
+) -> dict:
     """Build the `_seed.json` payload.
 
-    Layout:
+    Layout::
 
-    ```txt
-    {
-        "memories": { "/AGENTS.md": "..." },
-        "skills":   { "/<skill>/SKILL.md": "...", ... }
-    }
-    ```
-
-    `memories` always contains `/AGENTS.md` — the middleware loads it at
-    startup via `/memories/AGENTS.md`. Agent reads of `/memories/` and
-    `/skills/` are denied by `FilesystemPermission` rules.
+        {
+            "memories":       { "/AGENTS.md": "..." },
+            "skills":         { "/<skill>/SKILL.md": "...", ... },
+            "user_memories":  { "/AGENTS.md": "..." }
+        }
 
-    `skills` walks `skills/` if present. Keys are paths relative to the
-    skills dir with a leading slash; the runtime namespace handles the
-    scoping.
+    ``memories`` and ``skills`` are read-only at runtime.
+    ``user_memories`` contains a single writable ``AGENTS.md`` mounted at
+    ``/memories/user/``, namespaced per user_id.  If the project has a
+    ``user/`` directory (even if empty), an ``AGENTS.md`` is always seeded.
     """
-    # Keys must match what CompositeBackend passes to the mounted
-    # StoreBackend after stripping the route prefix: for a read of
-    # /memories/AGENTS.md it calls store.read("/AGENTS.md").
-    # Seed with the same leading-slash convention.
     memories: dict[str, str] = {f"/{AGENTS_MD_FILENAME}": system_prompt}
     skills: dict[str, str] = {}
+    user_memories: dict[str, str] = {}
 
     skills_dir = project_root / SKILLS_DIRNAME
     if skills_dir.is_dir():
@@ -155,13 +220,38 @@ def _build_seed(
                 rel = f.relative_to(skills_dir).as_posix()
                 skills[f"/{rel}"] = f.read_text(encoding="utf-8")
 
-    return {"memories": memories, "skills": skills}
+    user_dir = project_root / USER_DIRNAME
+    if user_dir.is_dir():
+        user_agents_md = user_dir / AGENTS_MD_FILENAME
+        content = (
+            user_agents_md.read_text(encoding="utf-8")
+            if user_agents_md.is_file()
+            else ""
+        )
+        user_memories[f"/{AGENTS_MD_FILENAME}"] = content
+
+    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
@@ -177,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,
@@ -186,6 +286,9 @@ def _render_deploy_graph(
         mcp_tools_block=mcp_tools_block,
         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,
     )
 
 
@@ -201,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:
@@ -218,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))
@@ -236,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"))
@@ -256,6 +371,12 @@ def print_bundle_summary(config: DeployConfig, build_dir: Path) -> None:
         for f in memory_files:
             print(f"    {f}")
 
+    user_memory_files = sorted(seed.get("user_memories", {}).keys())
+    if user_memory_files:
+        print(f"\n  User memory seed ({len(user_memory_files)} file(s)):")
+        for f in user_memory_files:
+            print(f"    {f}")
+
     skills_files = sorted(seed.get("skills", {}).keys())
     if skills_files:
         print(f"\n  Skills seed ({len(skills_files)} file(s)):")
@@ -265,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.37 → 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}).")