deepagents-cli 0.0.35__tar.gz → 0.0.36__tar.gz

{deepagents_cli-0.0.35 → deepagents_cli-0.0.36}/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.0.36](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.35...deepagents-cli==0.0.36) (2026-04-09)
+
+### Features
+
+* `deepagents deploy` ([#2491](https://github.com/langchain-ai/deepagents/issues/2491)) ([01dc60e](https://github.com/langchain-ai/deepagents/commit/01dc60e394ecb56bd5336e447d32caeed8a67ec2))
+* Warn on missing tavily key, add `/notifications` ([#2555](https://github.com/langchain-ai/deepagents/issues/2555)) ([3dff3ed](https://github.com/langchain-ai/deepagents/commit/3dff3ed6835eae9f8b420b8a73c054127faaf7d2))
+
+### Bug Fixes
+
+* Fail fast on missing provider credentials ([#2554](https://github.com/langchain-ai/deepagents/issues/2554)) ([50fb8ae](https://github.com/langchain-ai/deepagents/commit/50fb8aefe7e3065024e10f1d5ecd11a54d736641))
+* Fix mktemp template in debug script for macOS ([#2603](https://github.com/langchain-ai/deepagents/issues/2603)) ([63fa537](https://github.com/langchain-ai/deepagents/commit/63fa537e9995ca2ead492ee44902227567e9a130))
+
 ## [0.0.35](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.34...deepagents-cli==0.0.35) (2026-04-07)
 
 ### Highlights

{deepagents_cli-0.0.35 → deepagents_cli-0.0.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-cli
-Version: 0.0.35
+Version: 0.0.36
 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.0
+Requires-Dist: deepagents==0.5.1
 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.35 → deepagents_cli-0.0.36}/deepagents_cli/_version.py

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

{deepagents_cli-0.0.35 → deepagents_cli-0.0.36}/deepagents_cli/app.py

@@ -2626,9 +2626,9 @@ class DeepAgentsApp(App):
             await self._mount_message(UserMessage(command))
             help_body = (
                 "Commands: /quit, /clear, /offload, /editor, /mcp, "
-                "/model [--model-params JSON] [--default], /reload, "
-                "/skill:<name>, /remember, /skill-creator, /theme, /tokens, "
-                "/threads, /trace, "
+                "/model [--model-params JSON] [--default], /notifications, "
+                "/reload, /skill:<name>, /remember, /skill-creator, /theme, "
+                "/tokens, /threads, /trace, "
                 "/update, /auto-update, /changelog, /docs, /feedback, /help\n\n"
                 "Interactive Features:\n"
                 "  Enter           Submit your message\n"
@@ -2774,6 +2774,8 @@ class DeepAgentsApp(App):
             await self._show_mcp_viewer()
         elif cmd == "/theme":
             await self._show_theme_selector()
+        elif cmd == "/notifications":
+            await self._show_notification_settings()
         elif cmd == "/model" or cmd.startswith("/model "):
             model_arg = None
             set_default = False
@@ -4552,6 +4554,36 @@ class DeepAgentsApp(App):
         screen = ThemeSelectorScreen(current_theme=self.theme)
         self.push_screen(screen, handle_result)
 
+    async def _show_notification_settings(self) -> None:
+        """Show notification settings modal."""
+        from deepagents_cli.model_config import is_warning_suppressed
+        from deepagents_cli.widgets.notification_settings import (
+            WARNING_TOGGLES,
+            NotificationSettingsScreen,
+        )
+
+        suppressed: set[str] = set()
+        try:
+            for key, _ in WARNING_TOGGLES:
+                if await asyncio.to_thread(is_warning_suppressed, key):
+                    suppressed.add(key)
+        except Exception:
+            logger.warning("Failed to read notification settings", exc_info=True)
+            suppressed = set()
+            self.notify(
+                "Could not read notification preferences. Showing defaults.",
+                severity="warning",
+                timeout=6,
+                markup=False,
+            )
+
+        def handle_result(_result: None) -> None:
+            if self._chat_input:
+                self._chat_input.focus_input()
+
+        screen = NotificationSettingsScreen(suppressed=suppressed)
+        self.push_screen(screen, handle_result)
+
     async def _show_mcp_viewer(self) -> None:
         """Show read-only MCP server/tool viewer as a modal screen."""
         from deepagents_cli.widgets.mcp_viewer import MCPViewerScreen

{deepagents_cli-0.0.35 → deepagents_cli-0.0.36}/deepagents_cli/command_registry.py

@@ -77,6 +77,12 @@ COMMANDS: tuple[SlashCommand, ...] = (
         description="Switch or configure model (--model-params, --default)",
         bypass_tier=BypassTier.IMMEDIATE_UI,
     ),
+    SlashCommand(
+        name="/notifications",
+        description="Configure startup warning preferences",
+        bypass_tier=BypassTier.IMMEDIATE_UI,
+        hidden_keywords="warnings alerts suppress",
+    ),
     SlashCommand(
         name="/offload",
         description="Free up context window space by offloading older messages",

{deepagents_cli-0.0.35 → deepagents_cli-0.0.36}/deepagents_cli/config.py

@@ -32,8 +32,8 @@ _bootstrap_done = False
 """Whether `_ensure_bootstrap()` has executed."""
 
 _bootstrap_lock = threading.Lock()
-"""Guards `_ensure_bootstrap()` against concurrent access from the main
-thread and the prewarm worker thread."""
+"""Guards `_ensure_bootstrap()` against concurrent access from the main thread
+and the prewarm worker thread."""
 
 _singleton_lock = threading.Lock()
 """Guards lazy singleton construction in `_get_console` / `_get_settings`."""
@@ -2195,7 +2195,14 @@ def create_model(
         >>> model = create_model("gpt-4o")  # Auto-detects openai
         >>> model = create_model()  # Uses environment defaults
     """
-    from deepagents_cli.model_config import ModelConfig, ModelConfigError, ModelSpec
+    from deepagents_cli.model_config import (
+        IMPLICIT_AUTH_PROVIDERS,
+        ModelConfig,
+        ModelConfigError,
+        ModelSpec,
+        get_credential_env_var,
+        has_provider_credentials,
+    )
 
     if not model_spec:
         model_spec = _get_default_model_spec()
@@ -2225,6 +2232,20 @@ def create_model(
         model_name = model_spec
         provider = detect_provider(model_spec) or ""
 
+    # Early credential check — fail fast with an actionable message instead of
+    # letting the provider SDK raise an opaque auth error on first invocation.
+    # Providers that support implicit auth (e.g., Vertex AI ADC) are excluded
+    # because their env-var mapping is not a reliable indicator.
+    if provider and provider not in IMPLICIT_AUTH_PROVIDERS:
+        cred_status = has_provider_credentials(provider)
+        if cred_status is False:
+            env_var = get_credential_env_var(provider) or f"<{provider} API key>"
+            msg = (
+                f"No credentials found for provider '{provider}'. "
+                f"Please set the {env_var} environment variable."
+            )
+            raise ModelConfigError(msg)
+
     # Provider-specific kwargs (with per-model overrides)
     kwargs = _get_provider_kwargs(provider, model_name=model_name)
 

deepagents_cli-0.0.36/deepagents_cli/deploy/__init__.py

@@ -0,0 +1,15 @@
+"""Deploy commands for bundling and shipping deep agents."""
+
+from deepagents_cli.deploy.commands import (
+    execute_deploy_command,
+    execute_dev_command,
+    execute_init_command,
+    setup_deploy_parsers,
+)
+
+__all__ = [
+    "execute_deploy_command",
+    "execute_dev_command",
+    "execute_init_command",
+    "setup_deploy_parsers",
+]

deepagents_cli-0.0.36/deepagents_cli/deploy/bundler.py

@@ -0,0 +1,259 @@
+"""Bundle a deepagents project for deployment.
+
+Reads the canonical project layout:
+
+```txt
+src/
+    AGENTS.md       # required — system prompt + seeded memory
+    skills/         # optional — auto-seeded into skills namespace
+    mcp.json        # optional — HTTP/SSE MCP servers
+    deepagents.toml
+```
+
+...and writes everything `langgraph deploy` needs to a build directory.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import shutil
+from pathlib import Path
+
+from deepagents_cli.deploy.config import (
+    AGENTS_MD_FILENAME,
+    MCP_FILENAME,
+    SKILLS_DIRNAME,
+    DeployConfig,
+)
+from deepagents_cli.deploy.templates import (
+    DEPLOY_GRAPH_TEMPLATE,
+    MCP_TOOLS_TEMPLATE,
+    PYPROJECT_TEMPLATE,
+    SANDBOX_BLOCKS,
+)
+
+logger = logging.getLogger(__name__)
+
+_MODEL_PROVIDER_DEPS = {
+    "anthropic": "langchain-anthropic",
+    "openai": "langchain-openai",
+    "google_genai": "langchain-google-genai",
+    "google_vertexai": "langchain-google-vertexai",
+    "groq": "langchain-groq",
+    "mistralai": "langchain-mistralai",
+}
+"""Dependencies inferred from a provider: prefix on the model string."""
+
+
+def bundle(
+    config: DeployConfig,
+    project_root: Path,
+    build_dir: Path,
+) -> Path:
+    """Create the full deployment bundle in *build_dir*."""
+    build_dir.mkdir(parents=True, exist_ok=True)
+
+    # 1. Read AGENTS.md — the system prompt AND (optionally) seeded memory.
+    agents_md_path = project_root / AGENTS_MD_FILENAME
+    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)
+    (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)",
+        len(seed["memories"]),
+        len(seed["skills"]),
+    )
+
+    # 3. Copy mcp.json if present.
+    mcp_present = (project_root / MCP_FILENAME).is_file()
+    if mcp_present:
+        shutil.copy2(project_root / MCP_FILENAME, build_dir / "_mcp.json")
+        logger.info("Copied %s → _mcp.json", MCP_FILENAME)
+
+    # 3b. Copy .env from the project root if present (i.e. alongside
+    # deepagents.toml inside ``src/``). The bundler skips .env when
+    # building the seed payload so secrets never land in _seed.json.
+    env_src = project_root / ".env"
+    env_present = env_src.is_file()
+    if env_present:
+        shutil.copy2(env_src, build_dir / ".env")
+        logger.info("Copied %s → .env", env_src)
+
+    # 4. Render deploy_graph.py.
+    (build_dir / "deploy_graph.py").write_text(
+        _render_deploy_graph(config, system_prompt, mcp_present=mcp_present),
+        encoding="utf-8",
+    )
+    logger.info("Generated deploy_graph.py")
+
+    # 5. Render langgraph.json.
+    (build_dir / "langgraph.json").write_text(
+        _render_langgraph_json(env_present=env_present),
+        encoding="utf-8",
+    )
+
+    # 6. Render pyproject.toml.
+    (build_dir / "pyproject.toml").write_text(
+        _render_pyproject(config, mcp_present=mcp_present),
+        encoding="utf-8",
+    )
+
+    return build_dir
+
+
+def _build_seed(
+    config: DeployConfig,  # noqa: ARG001
+    project_root: Path,
+    system_prompt: str,
+) -> dict[str, dict[str, str]]:
+    """Build the `_seed.json` payload.
+
+    Layout:
+
+    ```txt
+    {
+        "memories": { "AGENTS.md": "..." },
+        "skills":   { "<skill>/SKILL.md": "...", ... }
+    }
+    ```
+
+    `memories` always contains `AGENTS.md` — the agent reads it at runtime
+    via `/memories/AGENTS.md`. Writes and edits to that path are blocked
+    by `ReadOnlyStoreBackend` in the generated graph.
+
+    `skills` walks `src/skills/` if present. Keys are paths relative to the
+    skills dir; the runtime namespace handles the scoping.
+    """
+    # 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] = {}
+
+    skills_dir = project_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")
+
+    return {"memories": memories, "skills": skills}
+
+
+def _render_deploy_graph(
+    config: DeployConfig,
+    system_prompt: str,
+    *,
+    mcp_present: bool,
+) -> str:
+    """Render the generated `deploy_graph.py`."""
+    provider = config.sandbox.provider
+    if provider not in SANDBOX_BLOCKS:
+        msg = f"Unknown sandbox provider {provider!r}. Valid: {sorted(SANDBOX_BLOCKS)}"
+        raise ValueError(msg)
+    sandbox_block, _ = SANDBOX_BLOCKS[provider]
+
+    if mcp_present:
+        mcp_tools_block = MCP_TOOLS_TEMPLATE
+        mcp_tools_load_call = "tools.extend(await _load_mcp_tools())"
+    else:
+        mcp_tools_block = ""
+        mcp_tools_load_call = "pass  # no MCP servers configured"
+
+    return DEPLOY_GRAPH_TEMPLATE.format(
+        model=config.agent.model,
+        system_prompt=system_prompt,
+        sandbox_template=config.sandbox.template,
+        sandbox_image=config.sandbox.image,
+        sandbox_scope=config.sandbox.scope,
+        sandbox_block=sandbox_block,
+        mcp_tools_block=mcp_tools_block,
+        mcp_tools_load_call=mcp_tools_load_call,
+        default_assistant_id=config.agent.name,
+    )
+
+
+def _render_langgraph_json(*, env_present: bool) -> str:
+    """Render `langgraph.json` — adds `"env": ".env"` when a `.env` was copied."""
+    data: dict = {
+        "dependencies": ["."],
+        "graphs": {"agent": "./deploy_graph.py:make_graph"},
+        "python_version": "3.12",
+    }
+    if env_present:
+        data["env"] = ".env"
+    return json.dumps(data, indent=2) + "\n"
+
+
+def _render_pyproject(config: DeployConfig, *, mcp_present: bool) -> str:
+    """Render the deployment package's `pyproject.toml`.
+
+    Deps are inferred — the user never writes them. We add:
+
+    - the LangChain partner package matching the model provider prefix
+    - `langchain-mcp-adapters` if `mcp.json` is present
+    - the sandbox partner package (daytona/modal/runloop)
+    """
+    deps: list[str] = []
+
+    provider_prefix = (
+        config.agent.model.split(":", 1)[0] if ":" in config.agent.model else ""
+    )
+    if provider_prefix and provider_prefix in _MODEL_PROVIDER_DEPS:
+        deps.append(_MODEL_PROVIDER_DEPS[provider_prefix])
+
+    if mcp_present:
+        deps.append("langchain-mcp-adapters")
+
+    _, partner_pkg = SANDBOX_BLOCKS.get(config.sandbox.provider, (None, None))
+    if partner_pkg:
+        deps.append(partner_pkg)
+
+    extra_deps_lines = "".join(f'    "{dep}",\n' for dep in deps)
+
+    return PYPROJECT_TEMPLATE.format(
+        agent_name=config.agent.name,
+        extra_deps=extra_deps_lines,
+    )
+
+
+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": {}}
+    if seed_path.exists():
+        try:
+            seed = json.loads(seed_path.read_text(encoding="utf-8"))
+        except Exception:
+            pass
+
+    print(f"\n  Agent: {config.agent.name}")
+    print(f"  Model: {config.agent.model}")
+
+    memory_files = sorted(seed.get("memories", {}).keys())
+    if memory_files:
+        print(f"\n  Memory seed ({len(memory_files)} file(s)):")
+        for f in 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)):")
+        for f in skills_files:
+            print(f"    {f}")
+
+    if (build_dir / "_mcp.json").exists():
+        print("\n  MCP config: _mcp.json")
+
+    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())
+    print(f"  Generated files: {', '.join(generated)}")
+    print()