deepagents-code 0.1.9__tar.gz → 0.1.11__tar.gz

{deepagents_code-0.1.9 → deepagents_code-0.1.11}/AGENTS.md

@@ -10,10 +10,10 @@ For monorepo-wide conventions (commit titles, lint, testing, docs, CI, benchmark
 
 **Key Textual resources:**
 
-- **Guide:** https://textual.textualize.io/guide/
-- **Widget gallery:** https://textual.textualize.io/widget_gallery/
-- **CSS reference:** https://textual.textualize.io/styles/
-- **API reference:** https://textual.textualize.io/api/
+- **Guide:** <https://textual.textualize.io/guide/>
+- **Widget gallery:** <https://textual.textualize.io/widget_gallery/>
+- **CSS reference:** <https://textual.textualize.io/styles/>
+- **API reference:** <https://textual.textualize.io/api/>
 
 ### Styled text in widgets
 
@@ -92,8 +92,18 @@ To add a new slash command: (1) add a `SlashCommand` entry to `COMMANDS`, (2) se
 `deepagents-code` supports LangChain-based chat model providers as optional dependencies. To add a new provider, update these files (all entries alphabetically sorted):
 
 1. `deepagents_code/model_config.py` — add `"provider_name": "ENV_VAR_NAME"` to `PROVIDER_API_KEY_ENV`
-2. `pyproject.toml` — add `provider = ["langchain-provider>=X.Y.Z,<N.0.0"]` to `[project.optional-dependencies]` and include it in the `all-providers` composite extra
-3. `tests/unit_tests/test_model_config.py` — add `assert PROVIDER_API_KEY_ENV["provider_name"] == "ENV_VAR_NAME"` to `TestProviderApiKeyEnv.test_contains_major_providers`
+2. `deepagents_code/model_config.py` — if the provider reads a *dedicated* endpoint env var, add `"provider_name": ("CANONICAL_BASE_URL", "ALTERNATE", ...)` to `PROVIDER_BASE_URL_ENV` (see guidelines below); omit the provider entirely when it has no provider-specific endpoint variable
+3. `pyproject.toml` — add `provider = ["langchain-provider>=X.Y.Z,<N.0.0"]` to `[project.optional-dependencies]` and include it in the `all-providers` composite extra
+4. `tests/unit_tests/test_model_config.py` — add `assert PROVIDER_API_KEY_ENV["provider_name"] == "ENV_VAR_NAME"` to `TestProviderApiKeyEnv.test_contains_major_providers`, and pin any `PROVIDER_BASE_URL_ENV` entry with a matching assertion
+
+### `PROVIDER_BASE_URL_ENV` guidelines
+
+`PROVIDER_BASE_URL_ENV` pairs a provider with the endpoint env var(s) its LangChain integration and SDK read, so a stored `/auth` endpoint resolves and an inherited gateway URL cannot leak. Before adding an entry:
+
+- **Verify against source — never infer from naming.** Read both the `langchain-<provider>` chat model (look for `from_env` / `get_from_dict_or_env` / `secret_from_env`, or a `Field` default on the `base_url`/`endpoint` alias) and the underlying vendor SDK, and record the exact env var name each reads. The integration and the SDK often read different names (e.g. `GROQ_API_BASE` vs `GROQ_BASE_URL`).
+- **Canonical name first.** Element `[0]` is written by `apply_stored_credentials` and read by `get_base_url`; every other name the integration or SDK may read goes in the tuple so it is cleared too. By convention the SDK's `*_BASE_URL`-style name is canonical and the integration's `*_API_BASE`/`*_API_URL` name is the alternate.
+- **Never list another provider's shared var.** OpenAI-compatible providers (e.g. `deepseek`, `openrouter`, `together`, `xai`, `baseten`) sit on the `openai` SDK, whose only endpoint var is the shared `OPENAI_BASE_URL`. Listing it under those providers would clobber the user's real OpenAI endpoint when their credential is written or cleared — list only the provider's own var (e.g. `DEEPSEEK_API_BASE`), or nothing.
+- **Omit providers with no dedicated var.** When the endpoint is a hardcoded default plus a constructor arg (`baseten`), an `api_base` arg resolved per-provider inside the library (`litellm`), or derived from the region (`google_vertexai`), leave the provider out. A `/auth` endpoint still resolves through `get_base_url`'s stored-credential step and reaches the model as the `base_url` kwarg.
 
 **Not required** unless the provider's models have a distinctive name prefix (like `gpt-*`, `claude*`, `gemini*`):
 

{deepagents_code-0.1.9 → deepagents_code-0.1.11}/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 # Deep Agents Code Changelog
 
+## [0.1.11](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.10...deepagents-code==0.1.11) (2026-06-07)
+
+### Bug Fixes
+
+* Pause loading timer during approvals ([#3782](https://github.com/langchain-ai/deepagents/issues/3782)) ([f98fb0c](https://github.com/langchain-ai/deepagents/commit/f98fb0c80d08e408a018ea33a8aa7144180f4e93))
+* Run auto-update before startup ([#3784](https://github.com/langchain-ai/deepagents/issues/3784)) ([c160ea3](https://github.com/langchain-ai/deepagents/commit/c160ea3eeda1d0ba707bb524cfd0ce087a854e08))
+* Skip update prompts for editable installs ([#3781](https://github.com/langchain-ai/deepagents/issues/3781)) ([ae2874e](https://github.com/langchain-ai/deepagents/commit/ae2874e8ece96c04233c1a88a9da1bd7b9ee2bb2))
+
+## [0.1.10](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.9...deepagents-code==0.1.10) (2026-06-05)
+
+### Features
+
+* Pair model API keys with their endpoints ([#3770](https://github.com/langchain-ai/deepagents/issues/3770)) ([cf98030](https://github.com/langchain-ai/deepagents/commit/cf9803072dc0fdc1d5850c9fd2fc4eb6893ed8c9))
+* Word-level double-click selection ([#3740](https://github.com/langchain-ai/deepagents/issues/3740)) ([4bb4286](https://github.com/langchain-ai/deepagents/commit/4bb4286a26c9c9bc69a36f2714d9eb0e3e5e4d40))
+* Blueprint bootstrapping for Runloop sandboxes ([#3556](https://github.com/langchain-ai/deepagents/issues/3556)) ([13dafd8](https://github.com/langchain-ai/deepagents/commit/13dafd8823c4b530c8e096012733ad74cd501b59))
+
+### Bug Fixes
+
+* Propagate runtime model switches to subagents ([#3771](https://github.com/langchain-ai/deepagents/issues/3771)) ([f577182](https://github.com/langchain-ai/deepagents/commit/f577182c84746e625b65c3c2fda95f8ca21164cf))
+* Guard pasted-path probes against `OSError` ([#3745](https://github.com/langchain-ai/deepagents/issues/3745)) ([c9617d3](https://github.com/langchain-ai/deepagents/commit/c9617d3594ab1448c4f3ee2212cdc66cbf138b77))
+* Keep startup import prewarm from crashing the TUI mid-upgrade ([#3756](https://github.com/langchain-ai/deepagents/issues/3756)) ([867a2e5](https://github.com/langchain-ai/deepagents/commit/867a2e5c341bd9dfa70b47c7fafc194ac51d7469))
+* Move MCP trust state out of user config ([#3742](https://github.com/langchain-ai/deepagents/issues/3742)) ([a97f2fd](https://github.com/langchain-ai/deepagents/commit/a97f2fd394e6b0b943225a0195b0901188bd368c))
+
 ## [0.1.9](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.8...deepagents-code==0.1.9) (2026-06-03)
 
 ### Bug Fixes

{deepagents_code-0.1.9 → deepagents_code-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-code
-Version: 0.1.9
+Version: 0.1.11
 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/
@@ -26,7 +26,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Terminals
 Requires-Python: <4.0,>=3.11
 Requires-Dist: aiosqlite<1.0.0,>=0.22.1
-Requires-Dist: deepagents-acp<1.0.0,>=0.0.7
+Requires-Dist: deepagents-acp<1.0.0,>=0.0.8
 Requires-Dist: deepagents==0.6.8
 Requires-Dist: httpx<1.0.0,>=0.28.1
 Requires-Dist: langchain-anthropic<2.0.0,>=1.4.4
@@ -81,7 +81,7 @@ Provides-Extra: all-sandboxes
 Requires-Dist: langchain-agentcore-codeinterpreter<1.0.0,>=0.0.3; extra == 'all-sandboxes'
 Requires-Dist: langchain-daytona>=0.0.6; extra == 'all-sandboxes'
 Requires-Dist: langchain-modal>=0.0.4; extra == 'all-sandboxes'
-Requires-Dist: langchain-runloop>=0.0.5; extra == 'all-sandboxes'
+Requires-Dist: langchain-runloop>=0.0.6; extra == 'all-sandboxes'
 Provides-Extra: anthropic
 Requires-Dist: langchain-anthropic<2.0.0,>=1.4.4; extra == 'anthropic'
 Provides-Extra: baseten
@@ -123,7 +123,7 @@ Requires-Dist: langchain-perplexity<2.0.0,>=1.3.1; extra == 'perplexity'
 Provides-Extra: quickjs
 Requires-Dist: langchain-quickjs<0.2.0,>=0.1.3; extra == 'quickjs'
 Provides-Extra: runloop
-Requires-Dist: langchain-runloop>=0.0.5; extra == 'runloop'
+Requires-Dist: langchain-runloop>=0.0.6; extra == 'runloop'
 Provides-Extra: together
 Requires-Dist: langchain-together<2.0.0,>=0.4.0; extra == 'together'
 Provides-Extra: vertex

{deepagents_code-0.1.9 → deepagents_code-0.1.11}/THREAT_MODEL.md

@@ -156,7 +156,7 @@
 | DC1 | API Keys / Credentials | `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `TAVILY_API_KEY`, `LANGSMITH_API_KEY`, `LANGGRAPH_API_KEY` | Critical | Process environment only; never written to disk by CLI code | N/A (in-memory) | Process lifetime | All — breach trigger |
 | DC2 | Conversation Messages  | User prompts, LLM responses, tool args/results   | High        | SQLite (`~/.deepagents/*.db`) via LangGraph checkpointer | No (local file, unencrypted) | Unbounded (session files persist) | GDPR if personal data is discussed |
 | DC3 | System Prompt Content  | `DA_SERVER_SYSTEM_PROMPT` env var; custom AGENTS.md contents | Medium | Process environment (transient); `~/.deepagents/{agent}/AGENTS.md` on disk | No | Config lifetime | None direct |
-| DC4 | MCP Trust Fingerprints | `mcp_trust.projects.*` in `config.toml`          | Low         | `~/.deepagents/config.toml`      | No                | Until revoked      | None       |
+| DC4 | MCP Trust Fingerprints | `projects.*` in `mcp_trust.json`                 | Low         | `~/.deepagents/.state/mcp_trust.json` | No           | Until revoked      | None       |
 | DC5 | Offloaded Conversation History | Summarized + raw conversation messages written to sandbox backend | High | Sandbox filesystem at `/conversation_history/{thread_id}.md` | Depends on sandbox provider | Sandbox session lifetime | GDPR if personal data is discussed |
 
 ### Data Classification Details

{deepagents_code-0.1.9 → deepagents_code-0.1.11}/deepagents_code/_env_vars.py

@@ -134,6 +134,16 @@ and `/api/show`. See `_ollama_discovery_enabled` for accepted truthy/falsy
 values.
 """
 
+RESTARTED_AFTER_UPDATE = "DEEPAGENTS_CODE_RESTARTED_AFTER_UPDATE"
+"""Internal sentinel recording the target version immediately before the
+startup auto-update re-execs the process.
+
+Not user-facing. The re-exec'd process consumes it and, if that same version
+still reports as available (a no-op upgrade that did not change the running
+version), skips auto-updating to break out of an otherwise endless
+upgrade/restart loop. Set and read internally across `os.execv`.
+"""
+
 SERVER_ENV_PREFIX = "DEEPAGENTS_CODE_SERVER_"
 """Environment variable prefix used to pass CLI config to the server subprocess."""
 

{deepagents_code-0.1.9 → deepagents_code-0.1.11}/deepagents_code/_server_config.py

@@ -180,7 +180,7 @@ class ServerConfig:
     """Existing sandbox ID to attach to; `None` creates a fresh sandbox."""
 
     sandbox_snapshot_name: str | None = None
-    """Sandbox snapshot name to use or create. LangSmith-only; must be `None`
+    """Sandbox snapshot (langsmith) or blueprint (runloop) name; must be `None`
     when `sandbox_id` is set."""
 
     sandbox_setup: str | None = None
@@ -365,8 +365,8 @@ class ServerConfig:
                 server subprocess for `ShellAllowListMiddleware`.
             sandbox_type: Sandbox type.
             sandbox_id: Existing sandbox ID to reuse.
-            sandbox_snapshot_name: Sandbox snapshot name to use or create
-                (langsmith only).
+            sandbox_snapshot_name: Snapshot (langsmith) or blueprint (runloop)
+                name to use or create.
             sandbox_setup: Path to setup script for the sandbox.
             enable_shell: Enable shell execution tools.
             enable_ask_user: Enable ask_user tool.

deepagents_code-0.1.11/deepagents_code/_textual_patches.py

@@ -0,0 +1,287 @@
+r"""Runtime patches over Textual internals, imported for side effect.
+
+This module hosts two independent best-effort patches over private Textual
+APIs. Each guards its own import/assignment and degrades to stock Textual
+behavior (logging a warning) if the targeted internals move, so they have
+separate lifecycles — do not delete the whole file when only one lands
+upstream.
+
+1. Alt-modifier preservation on legacy `ESC + <byte>` sequences. Upstream
+    `XTermParser._sequence_to_key_events` drops the `alt` flag on the
+    tuple-branch fast path, so VSCode's `sendSequence` shift+enter binding
+    (which writes `\x1b\r` to the PTY) arrives as bare `enter` instead of
+    `alt+enter`. Tracked in Textualize/textual#6378. Remove this patch and
+    the Textual pin comment in `pyproject.toml` when that lands.
+
+2. Double-click word selection. Stock Textual selects the entire widget on
+    a click chain; these patches narrow a double-click (and double-click
+    drag) to word boundaries. No upstream issue tracks this yet, so it has
+    no removal criterion — it stays until Textual grows native word select.
+
+Imported for side effect from `app.py` before any `App()` is created.
+"""
+
+from __future__ import annotations
+
+import logging
+from inspect import isawaitable
+from typing import TYPE_CHECKING
+
+from rich.text import Text
+from textual import __version__ as _textual_version
+from textual.content import Content
+from textual.geometry import Offset
+from textual.selection import Selection
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from textual.events import Click, Event
+    from textual.screen import Screen
+    from textual.selection import SelectState
+    from textual.widget import Widget
+
+logger = logging.getLogger(__name__)
+
+_ESC_PREFIX_LEN = 2
+_DOUBLE_CLICK_CHAIN = 2
+_TRIPLE_CLICK_CHAIN = 3
+_DEEPAGENTS_WORD_SELECT_ACTIVE = "_deepagents_word_select_active"
+
+try:
+    from textual import events
+    from textual._ansi_sequences import (
+        ANSI_SEQUENCES_KEYS,  # noqa: PLC2701
+        IGNORE_SEQUENCE,  # noqa: PLC2701
+    )
+    from textual._xterm_parser import XTermParser  # noqa: PLC2701
+
+    _original = XTermParser._sequence_to_key_events
+except (ImportError, AttributeError) as exc:  # pragma: no cover - defensive
+    logger.warning("Textual keyboard parser patch skipped: %s", exc)
+else:
+
+    def _emit_alt(keys: tuple, character: str | None) -> Iterable[events.Key]:
+        for key in keys:
+            yield events.Key(f"alt+{key.value}", character)
+
+    def _sequence_to_key_events_with_alt(
+        self: XTermParser, sequence: str, alt: bool = False
+    ) -> Iterable[events.Key]:
+        # Fast path: \x1b<byte> on first pass. Short-circuits the ~100 ms
+        # escape-delay wait when both bytes arrive together. Semantic side
+        # effect: \x1b\x1b dispatches as `alt+escape` with no delay, matching
+        # crossterm and Node TTY.
+        if not alt and len(sequence) == _ESC_PREFIX_LEN and sequence[0] == "\x1b":
+            inner = ANSI_SEQUENCES_KEYS.get(sequence[1])
+            if inner is not IGNORE_SEQUENCE and isinstance(inner, tuple):
+                yield from _emit_alt(inner, None)
+                return
+        # Correctness fix (Textualize/textual#6378): preserve `alt` on the
+        # reissue path for single-byte tuple mappings.
+        if alt:
+            keys = ANSI_SEQUENCES_KEYS.get(sequence)
+            if keys is not IGNORE_SEQUENCE and isinstance(keys, tuple):
+                character = sequence if len(sequence) == 1 else None
+                yield from _emit_alt(keys, character)
+                return
+        yield from _original(self, sequence, alt=alt)
+
+    try:
+        XTermParser._sequence_to_key_events = _sequence_to_key_events_with_alt  # ty: ignore[invalid-assignment]
+    except (AttributeError, TypeError) as exc:  # pragma: no cover - defensive
+        logger.warning("Textual keyboard parser patch assignment rejected: %s", exc)
+
+
+def _rendered_text(widget: Widget) -> str | None:
+    visual = widget._render()  # match Textual's get_selection path
+    if isinstance(visual, (Content, Text)):
+        return str(visual)
+    return None
+
+
+def _word_bounds(text: str, offset: Offset) -> tuple[Offset, Offset] | None:
+    lines = text.splitlines()
+    if not lines:
+        return None
+
+    y = min(max(offset.y, 0), len(lines) - 1)
+    line = lines[y]
+    if not line:
+        return None
+
+    x = min(max(offset.x, 0), len(line))
+    index = min(x, len(line) - 1)
+    if line[index].isspace():
+        # A click just past the final character (x == len(line)) lands on the
+        # virtual end-of-line position; snap back onto the trailing word so
+        # double-clicking after a word still selects it. Genuine whitespace
+        # clicks fall through and select nothing.
+        if x == len(line) and x > 0 and not line[x - 1].isspace():
+            index = x - 1
+        else:
+            return None
+
+    start = index
+    while start > 0 and not line[start - 1].isspace():
+        start -= 1
+
+    end = index + 1
+    while end < len(line) and not line[end].isspace():
+        end += 1
+
+    return Offset(start, y), Offset(end, y)
+
+
+def _word_selection(widget: Widget, selection: Selection) -> Selection | None:
+    if selection.start is None or selection.end is None:
+        return None
+
+    text = _rendered_text(widget)
+    if text is None:
+        return None
+
+    start, end = selection.start, selection.end
+    # `Offset.transpose` is (y, x) — Textual's reading-order key. A backward
+    # drag leaves end before start in reading order; normalize so the word
+    # bounds below extend outward from the correct endpoints.
+    if end.transpose < start.transpose:
+        start, end = end, start
+
+    start_bounds = _word_bounds(text, start)
+    end_bounds = _word_bounds(text, end)
+    if start_bounds is None and end_bounds is None:
+        return None
+
+    return Selection(
+        start_bounds[0] if start_bounds is not None else start,
+        end_bounds[1] if end_bounds is not None else end,
+    )
+
+
+def _select_word_at_click(widget: Widget, event: Click) -> bool:
+    offset = event.get_content_offset(widget)
+    if offset is None:
+        return False
+
+    text = _rendered_text(widget)
+    if text is None:
+        return False
+
+    bounds = _word_bounds(text, offset)
+    if bounds is None:
+        widget.screen.clear_selection()
+        return True
+
+    widget.screen.selections = {widget: Selection(*bounds)}
+    return True
+
+
+try:
+    from textual import events as _events
+    from textual.screen import Screen as _Screen
+    from textual.widget import Widget as _Widget
+
+    _original_forward_event = _Screen._forward_event
+    _original_watch_select_state = _Screen._watch__select_state
+    _original_widget_on_click = _Widget._on_click
+except (ImportError, AttributeError) as exc:  # pragma: no cover - defensive
+    logger.warning(
+        "Textual word-selection patch skipped (textual %s): %s",
+        _textual_version,
+        exc,
+    )
+else:
+
+    def _is_word_select_start(screen: Screen, event: Event) -> bool:
+        # Mirrors Textual's own click-chain detection (App._on_mouse_down),
+        # reading its private `_click_chain_last_*` bookkeeping to recognize
+        # the second press of a double-click before Textual increments the
+        # chain count. Re-verify these attribute names on every Textual bump.
+        if not isinstance(event, _events.MouseDown) or screen.app.mouse_captured:
+            return False
+
+        last_offset = getattr(screen.app, "_click_chain_last_offset", None)
+        last_time = getattr(screen.app, "_click_chain_last_time", None)
+        if last_offset != event.screen_offset or last_time is None:
+            return False
+
+        if event.time - last_time > screen.app.CLICK_CHAIN_TIME_THRESHOLD:
+            return False
+
+        select_widget, select_offset = screen.get_widget_and_offset_at(event.x, event.y)
+        return (
+            select_widget is not None
+            and select_widget.allow_select
+            and screen.allow_select
+            and screen.app.ALLOW_SELECT
+            and select_offset is not None
+        )
+
+    def _forward_event_with_word_select(self: Screen, event: Event) -> None:
+        if isinstance(event, _events.MouseDown):
+            setattr(
+                self,
+                _DEEPAGENTS_WORD_SELECT_ACTIVE,
+                _is_word_select_start(self, event),
+            )
+        try:
+            _original_forward_event(self, event)
+        finally:
+            if isinstance(event, _events.MouseUp):
+                setattr(self, _DEEPAGENTS_WORD_SELECT_ACTIVE, False)
+
+    async def _watch_select_state_with_word_select(
+        self: Screen,
+        select_state: SelectState | None,
+    ) -> None:
+        result = _original_watch_select_state(self, select_state)
+        # `_watch__select_state` is synchronous in the pinned Textual; the
+        # isawaitable guard tolerates a future release making it a coroutine
+        # without forcing a same-day patch update.
+        if isawaitable(result):
+            await result
+        if not getattr(self, _DEEPAGENTS_WORD_SELECT_ACTIVE, False):
+            return
+
+        selections = dict(self.selections)
+        changed = False
+        for widget, selection in selections.items():
+            word_selection = _word_selection(widget, selection)
+            if word_selection is None or word_selection == selection:
+                continue
+            selections[widget] = word_selection
+            changed = True
+
+        if changed:
+            self.selections = selections
+
+    async def _on_click_with_word_select(self: Widget, event: Click) -> None:
+        if (
+            event.widget is self
+            and self.allow_select
+            and self.screen.allow_select
+            and self.app.ALLOW_SELECT
+        ):
+            if event.chain == _DOUBLE_CLICK_CHAIN and _select_word_at_click(
+                self, event
+            ):
+                await self.broker_event("click", event)
+                return
+            if event.chain == _TRIPLE_CLICK_CHAIN:
+                self.text_select_all()
+                await self.broker_event("click", event)
+                return
+
+        await _original_widget_on_click(self, event)
+
+    try:
+        _Screen._forward_event = _forward_event_with_word_select  # ty: ignore[invalid-assignment]
+        _Screen._watch__select_state = _watch_select_state_with_word_select  # ty: ignore[invalid-assignment]
+        _Widget._on_click = _on_click_with_word_select  # ty: ignore[invalid-assignment]
+    except (AttributeError, TypeError) as exc:  # pragma: no cover - defensive
+        logger.warning(
+            "Textual word-selection patch assignment rejected (textual %s): %s",
+            _textual_version,
+            exc,
+        )

{deepagents_code-0.1.9 → deepagents_code-0.1.11}/deepagents_code/_version.py

@@ -2,7 +2,7 @@
 
 # Keep the `x-release-please-version` annotation — release-please uses it to
 # bump `__version__` in sync with `pyproject.toml` on every release PR.
-__version__ = "0.1.9"  # x-release-please-version
+__version__ = "0.1.11"  # x-release-please-version
 
 DOCS_URL = "https://docs.langchain.com/oss/python/deepagents/code"
 """URL for `deepagents-code` documentation."""

{deepagents_code-0.1.9 → deepagents_code-0.1.11}/deepagents_code/agent.py

@@ -1205,40 +1205,53 @@ def create_cli_agent(
         else settings.get_project_agents_dir()
     )
 
+    def _subagent_cli_middleware(*, has_explicit_model: bool) -> list[AgentMiddleware]:
+        middleware: list[AgentMiddleware] = []
+        if not has_explicit_model:
+            middleware.append(ConfigurableModelMiddleware())
+        if restrictive_shell_allow_list is not None:
+            middleware.append(ShellAllowListMiddleware(restrictive_shell_allow_list))
+        return middleware
+
     for subagent_meta in list_subagents(
         user_agents_dir=user_agents_dir,
         project_agents_dir=project_agents_dir,
     ):
+        # Treat a falsy spec (`None` or `""`) as "no explicit model" so an empty
+        # `model:` in subagent frontmatter inherits the runtime model rather than
+        # being forwarded verbatim to `resolve_model("")`.
+        model_spec = subagent_meta["model"]
+        has_explicit_model = bool(model_spec)
         subagent: SubAgent = {
             "name": subagent_meta["name"],
             "description": subagent_meta["description"],
             "system_prompt": subagent_meta["system_prompt"],
         }
-        if subagent_meta["model"]:
-            subagent["model"] = subagent_meta["model"]
-        if restrictive_shell_allow_list is not None:
-            subagent["middleware"] = [
-                ShellAllowListMiddleware(restrictive_shell_allow_list)
-            ]
+        if model_spec:
+            subagent["model"] = model_spec
+        subagent_middleware = _subagent_cli_middleware(
+            has_explicit_model=has_explicit_model
+        )
+        if subagent_middleware:
+            subagent["middleware"] = subagent_middleware
         custom_subagents.append(subagent)
 
-    if restrictive_shell_allow_list is not None:
-        from deepagents.middleware.subagents import (
-            GENERAL_PURPOSE_SUBAGENT,
-            SubAgent as RuntimeSubAgent,
-        )
+    from deepagents.middleware.subagents import (
+        GENERAL_PURPOSE_SUBAGENT,
+        SubAgent as RuntimeSubAgent,
+    )
 
-        if not any(
-            subagent["name"] == GENERAL_PURPOSE_SUBAGENT["name"]
-            for subagent in custom_subagents
-        ):
-            general_purpose_subagent: RuntimeSubAgent = {
-                "name": GENERAL_PURPOSE_SUBAGENT["name"],
-                "description": GENERAL_PURPOSE_SUBAGENT["description"],
-                "system_prompt": GENERAL_PURPOSE_SUBAGENT["system_prompt"],
-                "middleware": [ShellAllowListMiddleware(restrictive_shell_allow_list)],
-            }
-            custom_subagents.append(general_purpose_subagent)
+    if not any(
+        subagent["name"] == GENERAL_PURPOSE_SUBAGENT["name"]
+        for subagent in custom_subagents
+    ):
+        general_purpose_subagent: RuntimeSubAgent = {
+            "name": GENERAL_PURPOSE_SUBAGENT["name"],
+            "description": GENERAL_PURPOSE_SUBAGENT["description"],
+            "system_prompt": GENERAL_PURPOSE_SUBAGENT["system_prompt"],
+            "middleware": _subagent_cli_middleware(has_explicit_model=False),
+        }
+        custom_subagents.append(general_purpose_subagent)
 
     # Build middleware stack based on enabled features
     agent_middleware = [