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

{deepagents_cli-0.0.36 → deepagents_cli-0.0.37}/.gitignore

@@ -212,6 +212,9 @@ __marimo__/
 #claude
 .claude
 
+# Harbor local job output
+jobs/
+
 .idea
 TEXTUAL_REFACTOR_PLAN.md
 libs/cli/TEXTUAL_PROGRESS.md

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

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.0.37](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.36...deepagents-cli==0.0.37) (2026-04-10)
+
+### Features
+
+* Permissions for `deepagents deploy` ([#2651](https://github.com/langchain-ai/deepagents/issues/2651)) ([5d93b73](https://github.com/langchain-ai/deepagents/commit/5d93b736af6ffb165f33569233d533ced95a6943))
+
+### Bug Fixes
+
+* Add missing model provider deps to `deepagents deploy` bundler [closes [#2647](https://github.com/langchain-ai/deepagents/issues/2647)] ([#2660](https://github.com/langchain-ai/deepagents/issues/2660)) ([b710a69](https://github.com/langchain-ai/deepagents/commit/b710a69b12e49479045eaa54dfb709326473500b))
+* `AGENTS.md` in system prompt twice ([#2652](https://github.com/langchain-ai/deepagents/issues/2652)) ([9052be9](https://github.com/langchain-ai/deepagents/commit/9052be98d9f4ef9b11a88c9b1df3fae5e5ac666c))
+* Harden `deepagents deploy` config parsing and add unit tests ([#2636](https://github.com/langchain-ai/deepagents/issues/2636)) ([0469d14](https://github.com/langchain-ai/deepagents/commit/0469d1429d129e604fc1b622263923162f719314))
+* Load `deepagents deploy` project `.env` before deploy/dev config validation ([#2644](https://github.com/langchain-ai/deepagents/issues/2644)) ([8299091](https://github.com/langchain-ai/deepagents/commit/829909166606f8a9d9571b00da725845bad08da7))
+
 ## [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_cli-0.0.36 → deepagents_cli-0.0.37}/PKG-INFO

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

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

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

@@ -1478,7 +1478,7 @@ class DeepAgentsApp(App):
                 cmd = upgrade_command()
                 self.notify(
                     f"Update available: v{latest} (current: v{cli_version}). "
-                    f"Run: {cmd}\n"
+                    f"Run: {cmd}\n\n"
                     f"Enable auto-updates: /auto-update",
                     severity="information",
                     timeout=15,

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

@@ -1937,7 +1937,9 @@ def _get_provider_kwargs(
             result["api_key"] = api_key
 
     if provider == "openrouter":
-        from deepagents._models import check_openrouter_version  # noqa: PLC2701
+        from deepagents.profiles._openrouter import (
+            check_openrouter_version,  # noqa: PLC2701
+        )
 
         check_openrouter_version()
         _apply_openrouter_defaults(result)

{deepagents_cli-0.0.36 → deepagents_cli-0.0.37}/deepagents_cli/deploy/__init__.py

@@ -6,8 +6,11 @@ from deepagents_cli.deploy.commands import (
     execute_init_command,
     setup_deploy_parsers,
 )
+from deepagents_cli.deploy.config import SandboxProvider, SandboxScope
 
 __all__ = [
+    "SandboxProvider",
+    "SandboxScope",
     "execute_deploy_command",
     "execute_dev_command",
     "execute_init_command",

{deepagents_cli-0.0.36 → deepagents_cli-0.0.37}/deepagents_cli/deploy/bundler.py

@@ -3,11 +3,12 @@
 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
+<project>/
+    deepagents.toml  # required — agent + sandbox config
+    AGENTS.md        # required — system prompt + seeded memory
+    .env             # optional — environment variables
+    mcp.json         # optional — HTTP/SSE MCP servers
+    skills/          # optional — auto-seeded into skills namespace
 ```
 
 ...and writes everything `langgraph deploy` needs to a build directory.
@@ -35,13 +36,22 @@ from deepagents_cli.deploy.templates import (
 
 logger = logging.getLogger(__name__)
 
-_MODEL_PROVIDER_DEPS = {
+_MODEL_PROVIDER_DEPS: dict[str, str] = {
     "anthropic": "langchain-anthropic",
-    "openai": "langchain-openai",
+    "azure_openai": "langchain-openai",
+    "baseten": "langchain-baseten",
+    "cohere": "langchain-cohere",
+    "deepseek": "langchain-deepseek",
+    "fireworks": "langchain-fireworks",
     "google_genai": "langchain-google-genai",
     "google_vertexai": "langchain-google-vertexai",
     "groq": "langchain-groq",
     "mistralai": "langchain-mistralai",
+    "nvidia": "langchain-nvidia-ai-endpoints",
+    "openai": "langchain-openai",
+    "openrouter": "langchain-openrouter",
+    "perplexity": "langchain-perplexity",
+    "xai": "langchain-xai",
 }
 """Dependencies inferred from a provider: prefix on the model string."""
 
@@ -76,8 +86,8 @@ def bundle(
         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
+    # 3b. Copy .env from the project root if present (alongside
+    # deepagents.toml). 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()
@@ -87,7 +97,7 @@ def bundle(
 
     # 4. Render deploy_graph.py.
     (build_dir / "deploy_graph.py").write_text(
-        _render_deploy_graph(config, system_prompt, mcp_present=mcp_present),
+        _render_deploy_graph(config, mcp_present=mcp_present),
         encoding="utf-8",
     )
     logger.info("Generated deploy_graph.py")
@@ -118,17 +128,18 @@ def _build_seed(
 
     ```txt
     {
-        "memories": { "AGENTS.md": "..." },
-        "skills":   { "<skill>/SKILL.md": "...", ... }
+        "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.
+    `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.
 
-    `skills` walks `src/skills/` if present. Keys are paths relative to the
-    skills dir; the runtime namespace handles the scoping.
+    `skills` walks `skills/` if present. Keys are paths relative to the
+    skills dir with a leading slash; 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
@@ -149,7 +160,6 @@ def _build_seed(
 
 def _render_deploy_graph(
     config: DeployConfig,
-    system_prompt: str,
     *,
     mcp_present: bool,
 ) -> str:
@@ -169,7 +179,6 @@ def _render_deploy_graph(
 
     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,
@@ -231,8 +240,12 @@ def print_bundle_summary(config: DeployConfig, build_dir: Path) -> None:
     if seed_path.exists():
         try:
             seed = json.loads(seed_path.read_text(encoding="utf-8"))
-        except Exception:
-            pass
+        except (json.JSONDecodeError, OSError) as exc:
+            logger.warning(
+                "Failed to parse %s; summary may be incomplete: %s",
+                seed_path,
+                exc,
+            )
 
     print(f"\n  Agent: {config.agent.name}")
     print(f"  Model: {config.agent.model}")

{deepagents_cli-0.0.36 → deepagents_cli-0.0.37}/deepagents_cli/deploy/commands.py

@@ -1,11 +1,6 @@
-"""CLI commands for `deepagents deploy`.
+"""CLI commands for `deepagents init`, `dev`, and `deploy`.
 
-Registered with the CLI via `setup_deploy_parser` in `main.py`.
-
-Commands:
-- `deepagents deploy` — Bundle and deploy to LangGraph Platform
-- `deepagents deploy --dry-run` — Show what would be generated
-- `deepagents init [NAME]` — Scaffold a new deploy project folder
+Registered with the CLI via `setup_deploy_parsers` in `main.py`.
 """
 
 from __future__ import annotations
@@ -70,7 +65,7 @@ def setup_deploy_parsers(
         "--config",
         type=str,
         default=None,
-        help="Path to deepagents.toml (default: auto-discovered from cwd upward)",
+        help="Path to deepagents.toml (default: auto-discovered from cwd)",
     )
     dev_parser.add_argument(
         "--port",
@@ -100,7 +95,7 @@ def setup_deploy_parsers(
         "--config",
         type=str,
         default=None,
-        help="Path to deepagents.toml (default: auto-discovered from cwd upward)",
+        help="Path to deepagents.toml (default: auto-discovered from cwd)",
     )
     deploy_parser.add_argument(
         "--dry-run",
@@ -197,14 +192,16 @@ def _init_project(*, name: str, force: bool = False) -> None:
     ]
 
     for filename, content in files:
-        (project_dir / filename).write_text(content)
+        (project_dir / filename).write_text(content, encoding="utf-8")
 
     # Create skills/ directory with a starter skill.
     skills_dir = project_dir / SKILLS_DIRNAME
     skills_dir.mkdir(exist_ok=True)
     starter_skill_dir = skills_dir / STARTER_SKILL_NAME
     starter_skill_dir.mkdir(exist_ok=True)
-    (starter_skill_dir / "SKILL.md").write_text(generate_starter_skill_md())
+    (starter_skill_dir / "SKILL.md").write_text(
+        generate_starter_skill_md(), encoding="utf-8"
+    )
 
     print(f"Created {name}/ with:")
     for filename, _ in files:
@@ -227,6 +224,7 @@ def _deploy(
         config_path: Path to config file, or `None` for default.
         dry_run: If `True`, generate artifacts but don't deploy.
     """
+    from deepagents_cli.config import _load_dotenv
     from deepagents_cli.deploy.bundler import bundle, print_bundle_summary
     from deepagents_cli.deploy.config import (
         DEFAULT_CONFIG_FILENAME,
@@ -242,6 +240,11 @@ def _deploy(
         cfg_path = discovered or Path.cwd() / DEFAULT_CONFIG_FILENAME
 
     project_root = cfg_path.parent
+    # Ensure the project .env is loaded into os.environ before validation.
+    # The main CLI bootstrap loads .env lazily (on first `settings` access),
+    # but deploy/dev commands may never touch `settings`, so the project
+    # .env would be missing when _validate_model_credentials checks os.environ.
+    _load_dotenv(start_path=project_root)
 
     # Load and validate config
     try:
@@ -262,10 +265,7 @@ def _deploy(
         raise SystemExit(1)
 
     # Bundle
-    if dry_run:
-        build_dir = Path(tempfile.mkdtemp(prefix="deepagents-deploy-"))
-    else:
-        build_dir = Path(tempfile.mkdtemp(prefix="deepagents-deploy-"))
+    build_dir = Path(tempfile.mkdtemp(prefix="deepagents-deploy-"))
 
     try:
         bundle(config, project_root, build_dir)
@@ -276,14 +276,13 @@ def _deploy(
             print(f"Inspect the build directory: {build_dir}")
             return
 
-        # Deploy via langgraph CLI
+        # Deploy via langgraph CLI.
         _run_langgraph_deploy(build_dir, name=config.agent.name)
+    finally:
+        if not dry_run:
+            import shutil
 
-    except Exception:
-        if dry_run:
-            # Keep build dir for inspection on dry run
-            raise
-        raise
+            shutil.rmtree(build_dir, ignore_errors=True)
 
 
 def _dev(
@@ -298,7 +297,7 @@ def _dev(
     served locally instead of pushed to LangGraph Platform. Hot-reloading
     is provided by `langgraph dev` itself watching the build directory;
     edits to the source project (`deepagents.toml`, skills, `AGENTS.md`)
-    require re-running `deepagents deploy dev` to re-bundle.
+    require re-running `deepagents dev` to re-bundle.
 
     Args:
         config_path: Path to `deepagents.toml`, or `None` for default.
@@ -309,6 +308,7 @@ def _dev(
     """
     import shutil
 
+    from deepagents_cli.config import _load_dotenv
     from deepagents_cli.deploy.bundler import bundle, print_bundle_summary
     from deepagents_cli.deploy.config import (
         DEFAULT_CONFIG_FILENAME,
@@ -322,12 +322,17 @@ def _dev(
         discovered = find_config()
         cfg_path = discovered or Path.cwd() / DEFAULT_CONFIG_FILENAME
     project_root = cfg_path.parent
+    # Ensure the project .env is loaded before validation (see _deploy).
+    _load_dotenv(start_path=project_root)
 
     try:
         config = load_config(cfg_path)
     except FileNotFoundError:
         print(f"Error: Config file not found: {cfg_path}")
         raise SystemExit(1) from None
+    except ValueError as e:
+        print(f"Error: Invalid config: {e}")
+        raise SystemExit(1) from None
 
     errors = config.validate(project_root)
     if errors:
@@ -337,35 +342,43 @@ def _dev(
         raise SystemExit(1)
 
     build_dir = Path(tempfile.mkdtemp(prefix="deepagents-dev-"))
-    bundle(config, project_root, build_dir)
-    print_bundle_summary(config, build_dir)
-
-    if shutil.which("langgraph") is None:
-        print(
-            "Error: `langgraph` CLI not found. Install it with:\n"
-            "  pip install 'langgraph-cli[inmem]'"
-        )
-        raise SystemExit(1)
+    try:
+        bundle(config, project_root, build_dir)
+        print_bundle_summary(config, build_dir)
 
-    cmd = [
-        "langgraph",
-        "dev",
-        "--no-browser",
-        "--port",
-        str(port),
-    ]
-    if allow_blocking:
-        cmd.append("--allow-blocking")
+        if shutil.which("langgraph") is None:
+            print(
+                "Error: `langgraph` CLI not found. Install it with:\n"
+                "  pip install 'langgraph-cli[inmem]'"
+            )
+            raise SystemExit(1)
 
-    print(f"\nStarting langgraph dev on http://localhost:{port}")
-    print(f"Build directory: {build_dir}")
-    print(f"Running: {' '.join(cmd)}\n")
+        cmd = [
+            "langgraph",
+            "dev",
+            "--no-browser",
+            "--port",
+            str(port),
+        ]
+        if allow_blocking:
+            cmd.append("--allow-blocking")
+
+        print(f"\nStarting langgraph dev on http://localhost:{port}")
+        print(f"Build directory: {build_dir}")
+        print(f"Running: {' '.join(cmd)}\n")
+
+        # Pass through stdout/stderr so the user sees dev server logs live.
+        try:
+            result = subprocess.run(cmd, cwd=str(build_dir), check=False)
+        except KeyboardInterrupt:
+            print("\nShutting down.")
+            return
 
-    # Pass through stdout/stderr so the user sees the dev server logs live.
-    try:
-        subprocess.run(cmd, cwd=str(build_dir), check=False)
-    except KeyboardInterrupt:
-        print("\nShutting down.")
+        if result.returncode != 0:
+            print(f"\nDev server exited with error (exit code {result.returncode}).")
+            raise SystemExit(result.returncode)
+    finally:
+        shutil.rmtree(build_dir, ignore_errors=True)
 
 
 def _run_langgraph_deploy(build_dir: Path, *, name: str) -> None:

{deepagents_cli-0.0.36 → deepagents_cli-0.0.37}/deepagents_cli/deploy/config.py

@@ -11,9 +11,9 @@ The new minimal surface has exactly two sections:
 read it at runtime, but writes/edits to that path are blocked by a read-only
 middleware in the generated graph.
 
-Skills (`src/skills/`) and MCP servers (`src/mcp.json`) are auto-detected
-from the project layout. The agent's system prompt is read from
-`src/AGENTS.md` at bundle time — there is no `system_prompt` key.
+Skills (`skills/`) and MCP servers (`mcp.json`) are auto-detected from the
+project layout. The agent's system prompt is read from `AGENTS.md` at bundle
+time — there is no `system_prompt` key.
 """
 
 from __future__ import annotations
@@ -23,12 +23,18 @@ import os
 import tomllib
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal, get_args
 
-VALID_SANDBOX_PROVIDERS = frozenset(
-    {"none", "daytona", "langsmith", "modal", "runloop"}
-)
-"""Valid sandbox providers (mirrors sandbox_factory._PROVIDER_TO_WORKING_DIR)"""
+SandboxProvider = Literal["none", "daytona", "langsmith", "modal", "runloop"]
+"""Valid sandbox provider identifiers."""
+
+SandboxScope = Literal["thread", "assistant"]
+"""Valid sandbox scope values."""
+
+VALID_SANDBOX_PROVIDERS: frozenset[str] = frozenset(get_args(SandboxProvider))
+"""Valid sandbox providers for deploy (subset of sandbox_factory, plus `"none"`)."""
+
+VALID_SANDBOX_SCOPES: frozenset[str] = frozenset(get_args(SandboxScope))
 
 DEFAULT_CONFIG_FILENAME = "deepagents.toml"
 
@@ -40,13 +46,15 @@ MCP_FILENAME = "mcp.json"
 
 @dataclass(frozen=True)
 class AgentConfig:
-    """``[agent]`` section — core agent identity."""
+    """`[agent]` section — core agent identity."""
 
     name: str
     model: str = "anthropic:claude-sonnet-4-6"
 
-
-VALID_SANDBOX_SCOPES = frozenset({"thread", "assistant"})
+    def __post_init__(self) -> None:  # noqa: D105 — simple guard, not a public API
+        if not self.name.strip():
+            msg = "AgentConfig.name must be non-empty"
+            raise ValueError(msg)
 
 
 @dataclass(frozen=True)
@@ -65,10 +73,10 @@ class SandboxConfig:
         same assistant share a single sandbox and its filesystem.
     """
 
-    provider: str = "none"
+    provider: SandboxProvider = "none"
     template: str = "deepagents-deploy"
     image: str = "python:3"
-    scope: str = "thread"
+    scope: SandboxScope = "thread"
 
 
 @dataclass(frozen=True)
@@ -82,8 +90,7 @@ class DeployConfig:
         """Validate config against the filesystem.
 
         Args:
-            project_root: Directory containing `deepagents.toml` (i.e.
-                the `src/` dir in the canonical layout).
+            project_root: Directory containing `deepagents.toml`.
 
         Returns:
             List of validation error strings. Empty if valid.
@@ -168,13 +175,19 @@ def load_config(config_path: Path) -> DeployConfig:
         msg = f"Config file not found: {config_path}"
         raise FileNotFoundError(msg)
 
-    with config_path.open("rb") as f:
-        data = tomllib.load(f)
+    try:
+        with config_path.open("rb") as f:
+            data = tomllib.load(f)
+    except tomllib.TOMLDecodeError as exc:
+        msg = f"Syntax error in {config_path}: {exc}"
+        raise ValueError(msg) from exc
 
     return _parse_config(data)
 
 
 _ALLOWED_SECTIONS = frozenset({"agent", "sandbox"})
+_ALLOWED_AGENT_KEYS = frozenset({"name", "model"})
+_ALLOWED_SANDBOX_KEYS = frozenset({"provider", "template", "image", "scope"})
 
 
 def _parse_config(data: dict[str, Any]) -> DeployConfig:
@@ -195,18 +208,33 @@ def _parse_config(data: dict[str, Any]) -> DeployConfig:
         msg = "[agent].name is required in deepagents.toml"
         raise ValueError(msg)
 
-    agent = AgentConfig(
-        name=agent_data["name"],
-        model=agent_data.get("model", "anthropic:claude-sonnet-4-6"),
-    )
+    unknown_agent = set(agent_data.keys()) - _ALLOWED_AGENT_KEYS
+    if unknown_agent:
+        msg = (
+            f"Unknown key(s) in [agent]: {sorted(unknown_agent)}. "
+            f"Allowed: {sorted(_ALLOWED_AGENT_KEYS)}"
+        )
+        raise ValueError(msg)
+
+    # Only pass keys present in TOML; dataclass defaults handle the rest.
+    agent_kwargs: dict[str, Any] = {"name": agent_data["name"]}
+    if "model" in agent_data:
+        agent_kwargs["model"] = agent_data["model"]
+    agent = AgentConfig(**agent_kwargs)
 
     sandbox_data = data.get("sandbox", {})
-    sandbox = SandboxConfig(
-        provider=sandbox_data.get("provider", "none"),
-        template=sandbox_data.get("template", "deepagents-deploy"),
-        image=sandbox_data.get("image", "python:3"),
-        scope=sandbox_data.get("scope", "thread"),
-    )
+    unknown_sandbox = set(sandbox_data.keys()) - _ALLOWED_SANDBOX_KEYS
+    if unknown_sandbox:
+        msg = (
+            f"Unknown key(s) in [sandbox]: {sorted(unknown_sandbox)}. "
+            f"Allowed: {sorted(_ALLOWED_SANDBOX_KEYS)}"
+        )
+        raise ValueError(msg)
+
+    sandbox_kwargs: dict[str, Any] = {
+        k: sandbox_data[k] for k in _ALLOWED_SANDBOX_KEYS if k in sandbox_data
+    }
+    sandbox = SandboxConfig(**sandbox_kwargs)
 
     return DeployConfig(agent=agent, sandbox=sandbox)
 
@@ -261,7 +289,7 @@ def _validate_model_credentials(model: str) -> list[str]:
 
 
 def _validate_sandbox_credentials(provider: str) -> list[str]:
-    """Check that the API key env var is set for the sandbox provider."""
+    """Check that at least one required API key env var is set for the provider."""
     required_vars = _SANDBOX_PROVIDER_ENV.get(provider)
     if required_vars is None:
         return []
@@ -276,9 +304,11 @@ def _validate_sandbox_credentials(provider: str) -> list[str]:
 
 
 def find_config(start_path: Path | None = None) -> Path | None:
-    """Find `deepagents.toml` in the current directory.
+    """Find `deepagents.toml` in *start_path* (or cwd if not given).
+
+    Only checks the single directory — does not walk parent directories.
 
-    Returns the path if found, or ``None`` otherwise.
+    Returns the path if found, or `None` otherwise.
     """
     current = (start_path or Path.cwd()).resolve()
     candidate = current / DEFAULT_CONFIG_FILENAME