deepagents-code 0.1.46__tar.gz → 0.1.48__tar.gz

{deepagents_code-0.1.46 → deepagents_code-0.1.48}/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 # Deep Agents Code Changelog
 
+## [0.1.48](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.47...deepagents-code==0.1.48) (2026-07-27)
+
+### Features
+
+- Added Fireworks `kimi-k3`, GLM-5.2-Fast, and Kimi-K3 to model selection and recommended models. ([#5082](https://github.com/langchain-ai/deepagents/issues/5082), [#5072](https://github.com/langchain-ai/deepagents/issues/5072))
+- Migrated legacy hooks to v2 events. ([#4971](https://github.com/langchain-ai/deepagents/issues/4971))
+
+### Bug Fixes
+
+- Require an `AGENTS.md` marker for `/agent` discovery, resolving unintended discovery behavior. ([#5076](https://github.com/langchain-ai/deepagents/issues/5076), closes [#4991](https://github.com/langchain-ai/deepagents/issues/4991))
+- Removed the redundant `/restart` hint from the restart prompt. ([#5083](https://github.com/langchain-ai/deepagents/issues/5083))
+- Removed the caret flash in plugin type-to-search. ([#5078](https://github.com/langchain-ai/deepagents/issues/5078))
+
+## [0.1.47](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.46...deepagents-code==0.1.47) (2026-07-24)
+
+### Features
+
+- Added `yolo` mode to the `Shift+Tab` approval cycle ([#5035](https://github.com/langchain-ai/deepagents/issues/5035)).
+- Show the changelog link before prompting to update via the install script ([#5034](https://github.com/langchain-ai/deepagents/issues/5034)).
+
 ## [0.1.46](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.45...deepagents-code==0.1.46) (2026-07-24)
 
 ### Highlights

{deepagents_code-0.1.46 → deepagents_code-0.1.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-code
-Version: 0.1.46
+Version: 0.1.48
 Summary: Terminal coding agent built on the Deep Agents SDK - works with any model, with persistent memory, customizable skills, subagents, and approval controls.
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
 Project-URL: Documentation, https://reference.langchain.com/python/deepagents/
@@ -31,7 +31,7 @@ Requires-Dist: deepagents-acp<1.0.0,>=0.0.9
 Requires-Dist: deepagents==0.7.0b2
 Requires-Dist: filelock<3.30,>=3.29.7
 Requires-Dist: httpx<1.0.0,>=0.28.1
-Requires-Dist: langchain-anthropic<2.0.0,>=1.5.1
+Requires-Dist: langchain-anthropic<2.0.0,>=1.5.2
 Requires-Dist: langchain-google-genai<5.0.0,>=4.3.1
 Requires-Dist: langchain-mcp-adapters<1.0.0,>=0.3.0
 Requires-Dist: langchain-openai<2.0.0,>=1.4.1
@@ -63,7 +63,7 @@ Provides-Extra: agentcore
 Requires-Dist: langchain-agentcore-codeinterpreter<1.0.0,>=0.0.5; extra == 'agentcore'
 Provides-Extra: all-providers
 Requires-Dist: aiohttp<3.15.0,>=3.14.3; extra == 'all-providers'
-Requires-Dist: langchain-anthropic<2.0.0,>=1.5.1; extra == 'all-providers'
+Requires-Dist: langchain-anthropic<2.0.0,>=1.5.2; extra == 'all-providers'
 Requires-Dist: langchain-aws<2.0.0,>=1.6.3; extra == 'all-providers'
 Requires-Dist: langchain-baseten<1.0.0,>=0.2.1; extra == 'all-providers'
 Requires-Dist: langchain-cohere<1.0.0,>=0.6.0; extra == 'all-providers'
@@ -91,7 +91,7 @@ Requires-Dist: langchain-modal>=0.0.5; extra == 'all-sandboxes'
 Requires-Dist: langchain-runloop>=0.0.6; extra == 'all-sandboxes'
 Requires-Dist: langchain-vercel-sandbox>=0.0.1; extra == 'all-sandboxes'
 Provides-Extra: anthropic
-Requires-Dist: langchain-anthropic<2.0.0,>=1.5.1; extra == 'anthropic'
+Requires-Dist: langchain-anthropic<2.0.0,>=1.5.2; extra == 'anthropic'
 Provides-Extra: baseten
 Requires-Dist: langchain-baseten<1.0.0,>=0.2.1; extra == 'baseten'
 Provides-Extra: bedrock

{deepagents_code-0.1.46 → deepagents_code-0.1.48}/deepagents_code/_build_info.py

@@ -1,3 +1,3 @@
 """Generated at build time. Do not edit or commit."""
 
-BUILD_COMMIT = "efa86c5"
+BUILD_COMMIT = "803b832"

{deepagents_code-0.1.46 → deepagents_code-0.1.48}/deepagents_code/_env_vars.py

@@ -401,6 +401,17 @@ THEME = "DEEPAGENTS_CODE_THEME"
 USER_ID = "DEEPAGENTS_CODE_USER_ID"
 """Attach a user identifier to LangSmith trace metadata."""
 
+YOLO_SWITCHER = "DEEPAGENTS_CODE_YOLO_SWITCHER"
+"""Include YOLO in the Shift+Tab approval-mode cycle.
+
+Enabled by default so an interactive session can cycle Manual → Auto → YOLO
+without restarting with `--yolo`. Set to a falsy value (`0`, `false`, `no`,
+`off`, or empty) to leave Shift+Tab limited to Manual/Auto. Also settable via
+`[startup].yolo_switcher` in config.toml so orgs can distribute the opt-out.
+Parsed by `classify_env_bool` through the config resolver (unrecognized values
+fall through rather than forcing the default).
+"""
+
 _TRUTHY_VALUES = frozenset({"1", "true", "yes", "on"})
 _FALSY_VALUES = frozenset({"0", "false", "no", "off", ""})
 

{deepagents_code-0.1.46 → deepagents_code-0.1.48}/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.46"  # x-release-please-version
+__version__ = "0.1.48"  # x-release-please-version
 
 DOCS_URL = "https://docs.langchain.com/oss/python/deepagents/code"
 """URL for `deepagents-code` documentation."""

{deepagents_code-0.1.46 → deepagents_code-0.1.48}/deepagents_code/agent.py

@@ -1107,12 +1107,25 @@ def load_async_subagents(config_path: Path | None = None) -> list[AsyncSubAgent]
     return agents
 
 
+_AGENT_DIR_MARKER = "AGENTS.md"
+"""Filename that marks a `~/.deepagents/<name>/` directory as an agent profile.
+
+Discovery is fail-closed: only directories containing this marker are listed by
+the `/agent` picker. Real agents always create it (empty on first use when
+memory is enabled), so empty folders stay out of the picker without being
+named. Known app-owned directory names are still denylisted so a forced
+invocation such as `dcode -a plugins` cannot stamp the marker into app state
+and surface that directory as a selectable agent.
+"""
+
+
 @functools.lru_cache(maxsize=1)
 def _reserved_agent_dir_names() -> frozenset[str]:
     """Return non-agent directory names reserved by the app under `~/.deepagents/`.
 
     These directories are created by the app for its own use and must never
-    appear in the agent picker:
+    appear in the agent picker — even if they contain an `AGENTS.md` file
+    (e.g. after `dcode -a plugins` stamps the marker via memory setup):
 
     - `bin/` holds the managed `rg` binary (`managed_tools.BIN_DIR`).
     - `plugins/` holds installed plugin state (`plugins.store`).
@@ -1134,28 +1147,38 @@ def _reserved_agent_dir_names() -> frozenset[str]:
 def _is_agent_dir_entry(entry: Path) -> bool:
     """Return whether a `~/.deepagents/` entry should be listed as an agent.
 
-    Filters out symlinks (so dangling links don't masquerade as agents),
-    dot-prefixed names — `.state/` (app internal state) plus any other
-    hidden directory the user may have placed there — and reserved names
-    the app owns (`bin/`, `plugins/`, and `conversation_history/`).
+    Fail-closed on the `AGENTS.md` marker: a directory is an agent only when
+    that file exists as a regular (non-symlink) file inside it.
+
+    Also rejects:
 
-    `OSError` from `is_dir`/`is_symlink` propagates so callers can log
-    with the failing entry's name as context.
+    - Dot-prefixed names (hidden dirs such as `.state/`)
+    - Reserved app-owned names (`bin/`, `plugins/`, `conversation_history/`),
+      even if they contain the marker
+    - Symlinked directories (including dangling links)
+    - Non-directories
+
+    `OSError` from `is_dir`/`is_symlink`/`is_file` propagates so callers can
+    log with the failing entry's name as context.
     """
     if entry.name.startswith(".") or entry.name in _reserved_agent_dir_names():
         return False
-    return entry.is_dir() and not entry.is_symlink()
+    if entry.is_symlink() or not entry.is_dir():
+        return False
+    marker = entry / _AGENT_DIR_MARKER
+    # `is_file()` is True for a symlink-to-file; reject those so a dangling or
+    # external link cannot mint an agent entry.
+    return marker.is_file() and not marker.is_symlink()
 
 
 def get_available_agent_names() -> list[str]:
     """Return a sorted list of available agent names from `~/.deepagents/`.
 
     Scans the user's `.deepagents` directory and returns each real
-    subdirectory found there. Symlinks excluded so a dangling link does not
-    masquerade as an agent. Dot-prefixed entries (e.g., `.state/`) and
-    reserved app-owned directories (`bin/`, `plugins/`, and
-    `conversation_history/`) are skipped so internal state never appears as an
-    agent.
+    subdirectory that contains the `AGENTS.md` agent marker and is not an
+    app-reserved name. Fail-closed: bare directories, reserved app state
+    (`bin/`, `plugins/`, `conversation_history/`), symlinks, and hidden
+    entries are not agents.
 
     Filesystem errors (missing parent, permission denied, broken entries) are
     logged and surfaced as an empty list rather than raised — the caller shows
@@ -1222,7 +1245,9 @@ def list_agents(*, output_format: OutputFormat = "text") -> None:
                 {
                     "name": name,
                     "path": str(agent_path),
-                    "has_agents_md": (agent_path / "AGENTS.md").exists(),
+                    # Always True for names from `get_available_agent_names`
+                    # (fail-closed marker). Kept for JSON schema stability.
+                    "has_agents_md": (agent_path / _AGENT_DIR_MARKER).is_file(),
                     "is_default": name == DEFAULT_AGENT_NAME,
                 }
             )
@@ -1240,17 +1265,10 @@ def list_agents(*, output_format: OutputFormat = "text") -> None:
         is_default = name == DEFAULT_AGENT_NAME
         default_label = " [dim](default)[/dim]" if is_default else ""
 
-        if (agent_path / "AGENTS.md").exists():
-            console.print(
-                f"  {bullet} [bold]{agent_name}[/bold]{default_label}",
-                style=theme.PRIMARY,
-            )
-        else:
-            console.print(
-                f"  {bullet} [bold]{agent_name}[/bold]{default_label}"
-                " [dim](incomplete)[/dim]",
-                style=theme.WARNING,
-            )
+        console.print(
+            f"  {bullet} [bold]{agent_name}[/bold]{default_label}",
+            style=theme.PRIMARY,
+        )
         console.print(
             f"    {escape_markup(str(agent_path))}",
             style=theme.MUTED,

{deepagents_code-0.1.46 → deepagents_code-0.1.48}/deepagents_code/app.py

@@ -3105,6 +3105,7 @@ class DeepAgentsApp(App):
             self._auto_approve = False
         self._approval_mode_blocked = False
         self._auto_mode_notice_pending = False
+        self._yolo_mode_notice_pending = False
 
         if sub_title is None and self._sandbox_type is not None:
             display = _SANDBOX_DISPLAY_NAMES.get(
@@ -5051,37 +5052,20 @@ class DeepAgentsApp(App):
             and self._server_kwargs is not None
         ):
             missing = self._server_startup_missing_provider_package
-            from deepagents_code.extras_info import extra_for_package
+            from deepagents_code.extras_info import resolve_install_hint
 
-            extra = extra_for_package(missing.package)
-            if extra is not None:
+            hint = resolve_install_hint(missing.package)
+            if hint.extra is not None:
                 text += (
-                    f"\n\nHint: install the package with `/install {extra}`, "
+                    f"\n\nHint: install the package with `/install {hint.extra}`, "
                     f"then run `/model {missing.provider}:<model>` to retry. "
                     "Or pick a different provider with `/model`."
                 )
             else:
-                from deepagents_code.extras_info import ExtrasIntrospectionError
-                from deepagents_code.update_check import (
-                    ToolRequirementIntrospectionError,
-                    install_package_command,
-                )
-
-                try:
-                    install_cmd = install_package_command(missing.package)
-                except (
-                    ValueError,
-                    ExtrasIntrospectionError,
-                    ToolRequirementIntrospectionError,
-                ) as exc:
-                    logger.debug(
-                        "install_package_command failed; falling back to "
-                        "manual hint: %s",
-                        exc,
-                    )
-                    install_hint = f"install the `{missing.package}` package manually"
+                if hint.command is not None:
+                    install_hint = f"run `{hint.command}`"
                 else:
-                    install_hint = f"run `{install_cmd}`"
+                    install_hint = f"install the `{missing.package}` package manually"
                 text += (
                     f"\n\nHint: {install_hint}, then run "
                     f"`/model {missing.provider}:<model>` "
@@ -6033,9 +6017,9 @@ class DeepAgentsApp(App):
                 create_update_log_path,
                 editable_extra_hint,
                 install_extra_command,
-                install_extra_recovery_command,
                 is_valid_extra_name,
                 perform_install_extra,
+                safe_install_extra_recovery_command,
             )
         except ImportError as exc:
             logger.warning("/install command import failed", exc_info=True)
@@ -6120,19 +6104,9 @@ class DeepAgentsApp(App):
             # already bound above so the hint is never empty. `manual_cmd` is
             # rendered into a Textual `Content` (literal, not Rich markup), so no
             # bracket escaping is needed here.
-            try:
-                manual_cmd = await asyncio.to_thread(
-                    install_extra_recovery_command, extra
-                )
-            except (
-                ExtrasIntrospectionError,
-                ToolRequirementIntrospectionError,
-                ValueError,
-            ):
-                logger.warning(
-                    "/install recovery command failed (install raised)",
-                    exc_info=True,
-                )
+            manual_cmd = await asyncio.to_thread(
+                safe_install_extra_recovery_command, extra, fallback=manual_cmd
+            )
             await self._mount_message(
                 ErrorMessage(
                     f"Install failed: {type(exc).__name__}: {exc}\n"
@@ -6148,19 +6122,9 @@ class DeepAgentsApp(App):
             detail = f": {output[-200:]}" if output else ""
             # See the OSError branch above: best-effort recovery command, falling
             # back to the already-bound install-script command on failure.
-            try:
-                manual_cmd = await asyncio.to_thread(
-                    install_extra_recovery_command, extra
-                )
-            except (
-                ExtrasIntrospectionError,
-                ToolRequirementIntrospectionError,
-                ValueError,
-            ):
-                logger.warning(
-                    "/install recovery command failed (install reported failure)",
-                    exc_info=True,
-                )
+            manual_cmd = await asyncio.to_thread(
+                safe_install_extra_recovery_command, extra, fallback=manual_cmd
+            )
             await self._mount_message(
                 ErrorMessage(
                     f"Install failed{detail}\n"
@@ -16900,7 +16864,9 @@ class DeepAgentsApp(App):
         elif kind == "denial":
             text = f"Auto denied [{event.get('category', 'policy')}]: {reason}"
         elif kind == "unavailable":
-            text = f"Auto classifier unavailable: {reason}"
+            # Reason is a short cause fragment from the server; keep the UI
+            # line outcome-focused so the blocked action is obvious.
+            text = f"Auto classifier unavailable: {reason} (action blocked)"
         else:
             text = f"Auto warning: {reason}"
         await self._mount_message(AppMessage(text))
@@ -16912,10 +16878,12 @@ class DeepAgentsApp(App):
             panel.toggle()
 
     async def action_toggle_auto_approve(self) -> None:
-        """Toggle between Manual and Auto after Store acknowledgement.
+        """Cycle Manual → Auto → YOLO (when enabled) after Store acknowledgement.
 
-        A session launched in YOLO moves to Manual; normal key navigation never
-        enters unrestricted mode.
+        YOLO is included by default (`startup.yolo_switcher` / env). Auto is
+        skipped when a sandbox makes classifier-backed Auto ineligible. The
+        first Shift+Tab into YOLO prompts for the same install-local
+        acknowledgement used by `--yolo` before unrestricted mode becomes active.
         """
         from deepagents_code.tui.modals.plugin_manager import PluginManagerScreen
         from deepagents_code.tui.widgets.agent_selector import AgentSelectorScreen
@@ -16969,17 +16937,47 @@ class DeepAgentsApp(App):
         if self._pending_ask_user_widget is not None:
             self._pending_ask_user_widget.action_previous_question()
             return
-        from deepagents_code.approval_mode import ApprovalMode
+        from deepagents_code.approval_mode import (
+            ApprovalMode,
+            has_yolo_acknowledgement,
+            next_approval_mode,
+        )
+        from deepagents_code.config import is_yolo_switcher_enabled
 
-        if self._approval_mode is ApprovalMode.MANUAL:
-            if not self._auto_mode_eligible:
-                self._warn_live_approval_mode_unavailable(
-                    "Auto is unavailable with a sandbox."
-                )
-                return
-            target = ApprovalMode.AUTO
-        else:
-            target = ApprovalMode.MANUAL
+        yolo_switcher_enabled = is_yolo_switcher_enabled()
+        target = next_approval_mode(
+            self._approval_mode,
+            auto_eligible=self._auto_mode_eligible,
+            yolo_switcher_enabled=yolo_switcher_enabled,
+        )
+        if target is None:
+            # `next_approval_mode` returns None only from Manual when neither
+            # Auto (sandbox-ineligible) nor the YOLO switcher entry is available,
+            # so this is the only reachable case.
+            self._warn_live_approval_mode_unavailable(
+                "Auto is unavailable with a sandbox, and YOLO is disabled "
+                "in the approval switcher."
+            )
+            return
+
+        # Gate the first YOLO switcher entry on the same policy acknowledgement
+        # as `--yolo`. Do not activate YOLO until the user continues.
+        if target is ApprovalMode.YOLO and not has_yolo_acknowledgement():
+            self._prompt_yolo_switcher_acknowledgement()
+            return
+
+        await self._set_approval_mode(target)
+
+    async def _set_approval_mode(self, target: ApprovalMode) -> bool:
+        """Apply an approval-mode change after optional live Store acknowledgement.
+
+        Args:
+            target: Mode to select.
+
+        Returns:
+            `True` when local UI state was updated to `target`.
+        """
+        from deepagents_code.approval_mode import ApprovalMode
 
         # With no usable agent/session pair there is no running graph to update.
         # Stage the selection locally; `execute_task_textual` persists it before
@@ -16993,7 +16991,12 @@ class DeepAgentsApp(App):
                 self._warn_live_approval_mode_unavailable(
                     "Auto could not be persisted; remaining in Manual."
                 )
-                return
+                return False
+            if target is ApprovalMode.YOLO:
+                self._warn_live_approval_mode_unavailable(
+                    "YOLO could not be persisted; remaining in the previous mode."
+                )
+                return False
             self._approval_mode_blocked = True
             self._warn_live_approval_mode_unavailable(
                 "Manual could not be persisted; active work was cancelled and "
@@ -17001,7 +17004,7 @@ class DeepAgentsApp(App):
             )
             if self._agent_running:
                 self._force_interrupt_active_work()
-            return
+            return False
 
         self._approval_mode_blocked = False
         self._approval_mode = target
@@ -17014,6 +17017,73 @@ class DeepAgentsApp(App):
             self._notify_auto_mode_enabled_once()
             if should_persist_live:
                 await self._auto_accept_pending_goal_rubric()
+        elif target is ApprovalMode.YOLO:
+            # Warn before the await below. State is already committed above, so
+            # if goal-rubric auto-accept raises, YOLO is active and the "no
+            # review" warning must have fired first. AUTO notifies before its
+            # await for the same reason.
+            self.notify(
+                "YOLO is active: gated actions run without review.",
+                severity="warning",
+                timeout=8,
+                markup=False,
+            )
+            if should_persist_live:
+                await self._auto_accept_pending_goal_rubric()
+        return True
+
+    def _prompt_yolo_switcher_acknowledgement(self) -> None:
+        """Show the first-run YOLO acknowledgement before entering unrestricted mode.
+
+        YOLO stays inactive until Enter persists the acknowledgement and the
+        follow-up mode write succeeds. Esc (or a non-true dismiss) leaves the
+        current mode untouched and does not store the acknowledgement.
+        """
+        from deepagents_code.approval_mode import (
+            ApprovalMode,
+            save_yolo_acknowledgement,
+        )
+        from deepagents_code.tui.widgets.yolo_mode_notice import YoloModeNoticeScreen
+
+        if getattr(self, "_yolo_mode_notice_pending", False):
+            return
+
+        def handle_result(accepted: bool | None) -> None:
+            self._yolo_mode_notice_pending = False
+            if accepted is not True:
+                self.notify(
+                    "Stayed in the current approval mode.",
+                    severity="information",
+                    markup=False,
+                )
+                return
+            if not save_yolo_acknowledgement():
+                self._warn_live_approval_mode_unavailable(
+                    "YOLO acknowledgement could not be saved; staying in the "
+                    "current mode."
+                )
+                return
+            task = asyncio.create_task(self._set_approval_mode(ApprovalMode.YOLO))
+            task.add_done_callback(_log_task_exception)
+
+        try:
+            self.push_screen(YoloModeNoticeScreen(), handle_result)
+        except Exception:
+            # This modal *is* the YOLO gate (unlike Auto's post-hoc notice), so
+            # a failed push leaves the mode unchanged. Surface it, or Shift+Tab
+            # looks dead. Leaving `_yolo_mode_notice_pending` unset (it is set
+            # only below, after a successful push) lets a later Shift+Tab retry.
+            logger.warning(
+                "Could not show YOLO switcher acknowledgement", exc_info=True
+            )
+            self._warn_live_approval_mode_unavailable(
+                "Could not open the YOLO confirmation; approval mode unchanged."
+            )
+            return
+
+        # Mark pending only after the push succeeds so a failed push cannot
+        # suppress a later try for the whole session.
+        self._yolo_mode_notice_pending = True
 
     def action_toggle_tool_output(self) -> None:
         """Toggle the most recent collapsible transcript unit."""

{deepagents_code-0.1.46 → deepagents_code-0.1.48}/deepagents_code/approval_mode.py

@@ -63,6 +63,46 @@ def coerce_approval_mode(value: object) -> ApprovalMode:
         return ApprovalMode.MANUAL
 
 
+def next_approval_mode(
+    current: ApprovalMode | str | object,
+    *,
+    auto_eligible: bool,
+    yolo_switcher_enabled: bool,
+) -> ApprovalMode | None:
+    """Return the next Shift+Tab approval mode for the active session.
+
+    The cycle is Manual → Auto → YOLO → Manual when both Auto and the YOLO
+    switcher entry are available. Auto is omitted when `auto_eligible` is false
+    (for example a remote sandbox). YOLO is omitted when orgs/users disable
+    `startup.yolo_switcher`. Launching with `--yolo` still leaves unrestricted
+    mode when the switcher entry is disabled; Shift+Tab only exits YOLO then.
+
+    Args:
+        current: Active approval mode (mode enum or raw value).
+        auto_eligible: Whether classifier-backed Auto can be selected.
+        yolo_switcher_enabled: Whether unrestricted YOLO appears in the cycle.
+
+    Returns:
+        The next mode, or `None` when no alternate mode is available.
+    """
+    mode = (
+        current if isinstance(current, ApprovalMode) else coerce_approval_mode(current)
+    )
+    if mode is ApprovalMode.MANUAL:
+        if auto_eligible:
+            return ApprovalMode.AUTO
+        if yolo_switcher_enabled:
+            return ApprovalMode.YOLO
+        return None
+    if mode is ApprovalMode.AUTO:
+        if yolo_switcher_enabled:
+            return ApprovalMode.YOLO
+        return ApprovalMode.MANUAL
+    # Only genuine YOLO reaches here; unknown/invalid values were normalized to
+    # Manual above and took that branch. Exiting YOLO always returns to Manual.
+    return ApprovalMode.MANUAL
+
+
 def approval_mode_key(thread_id: str) -> str:
     """Return the store key for a thread's live approval mode.
 

{deepagents_code-0.1.46 → deepagents_code-0.1.48}/deepagents_code/auto_mode.py

@@ -506,9 +506,9 @@ def classifier_unavailable_reason(exc: BaseException, *, timeout_seconds: float)
 
     Provider exception text stays out of the reason (it can carry secrets or
     noisy HTML). Only real local deadline expiry
-    (`_ClassifierDeadlineExceededError`) gets app-timeout wording; a bare
-    provider `TimeoutError` stays type-only so we do not claim dcode
-    cancelled a call the model failed first.
+    (`_ClassifierDeadlineExceededError`) includes the configured wait budget; a
+    bare provider `TimeoutError` stays type-only so we do not claim dcode's
+    deadline fired when the model failed first.
 
     Args:
         exc: Failure raised while invoking or validating the classifier.
@@ -518,11 +518,8 @@ def classifier_unavailable_reason(exc: BaseException, *, timeout_seconds: float)
         Compact single-line reason for tool messages and TUI events.
     """
     if isinstance(exc, _ClassifierDeadlineExceededError):
-        return (
-            "dcode cancelled the authorization classifier after its local "
-            f"{timeout_seconds:g}s timeout (app-imposed, not a provider timeout)."
-        )
-    return f"The authorization classifier was unavailable ({type(exc).__name__})."
+        return f"no decision within Auto's {timeout_seconds:g}s limit"
+    return f"failed ({type(exc).__name__})"
 
 
 def _default_counters(mode: ApprovalMode) -> AutoModeCounters: