deepagents-cli 0.0.53__tar.gz → 0.0.54__tar.gz

{deepagents_cli-0.0.53 → deepagents_cli-0.0.54}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Deep Agents CLI Changelog
 
+## [0.0.54](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.53...deepagents-cli==0.0.54) (2026-05-11)
+
+### Features
+
+* Allow filtering threads by directory ([#3290](https://github.com/langchain-ai/deepagents/issues/3290)) ([07a973a](https://github.com/langchain-ai/deepagents/commit/07a973ae5b0256fddfd9591dc88c7987e5581264))
+* Show sandbox provider in header `sub_title` ([#3295](https://github.com/langchain-ai/deepagents/issues/3295)) ([779f7f4](https://github.com/langchain-ai/deepagents/commit/779f7f45c501f3c6d53e12087e3d4c340ef8aded))
+* Surface sandbox startup errors in server crash messages ([#3306](https://github.com/langchain-ai/deepagents/issues/3306)) ([2606d57](https://github.com/langchain-ai/deepagents/commit/2606d57b623f16955df6f91e693051f4b61f6120))
+
+### Bug Fixes
+
+* Allow TUI launch without preconfigured model credentials ([#3301](https://github.com/langchain-ai/deepagents/issues/3301)) ([aa28ff7](https://github.com/langchain-ai/deepagents/commit/aa28ff73768a826b216bfa54d76ecd313c325077))
+* Suppress token placeholder on first invoke ([#3302](https://github.com/langchain-ai/deepagents/issues/3302)) ([c21dee2](https://github.com/langchain-ai/deepagents/commit/c21dee2e9bc1a7d3f52ff62e9e66d1caaaf7b464))
+* Sync thread ID and render clickable link on `/clear` ([#3305](https://github.com/langchain-ai/deepagents/issues/3305)) ([0904974](https://github.com/langchain-ai/deepagents/commit/0904974d52dff259809d00a7a8b26c3e894cc0c0))
+
 ## [0.0.53](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.52...deepagents-cli==0.0.53) (2026-05-10)
 
 ### Features

{deepagents_cli-0.0.53 → deepagents_cli-0.0.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-cli
-Version: 0.0.53
+Version: 0.0.54
 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/
@@ -45,7 +45,7 @@ Requires-Dist: packaging>=23.0
 Requires-Dist: pillow<13.0.0,>=10.0.0
 Requires-Dist: prompt-toolkit<4.0.0,>=3.0.52
 Requires-Dist: pyperclip<2.0.0,>=1.11.0
-Requires-Dist: python-dotenv<2.0.0,>=1.0.0
+Requires-Dist: python-dotenv<2.0.0,>=1.2.2
 Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: requests<3.0.0,>=2.0.0
 Requires-Dist: rich<16.0.0,>=14.2.0

{deepagents_cli-0.0.53 → deepagents_cli-0.0.54}/deepagents_cli/_version.py

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

{deepagents_cli-0.0.53 → deepagents_cli-0.0.54}/deepagents_cli/app.py

@@ -92,6 +92,11 @@ from deepagents_cli.widgets.welcome import WelcomeBanner
 logger = logging.getLogger(__name__)
 _monotonic = time.monotonic
 
+_DEFERRED_START_NOTICE = (
+    "No model is configured yet. Run `/model` to choose one. "
+    "Deep Agents will ask for credentials for the selected provider."
+)
+
 # Serializes process-local read-modify-write operations for `config.toml`.
 # Without this, overlapping global-theme and per-terminal-theme saves can each
 # read the same pre-mutation state and then clobber the other's keys.
@@ -807,6 +812,26 @@ def _build_model_switch_error_body(exc: BaseException) -> str | Content:
     return f"Failed to switch model: {exc}"
 
 
+def _build_whats_new_message(heading: str) -> Content:
+    """Build the post-upgrade banner with a clickable changelog URL.
+
+    Args:
+        heading: First line of the post-upgrade banner.
+
+    Returns:
+        Styled banner content with the changelog URL embedded as a link.
+    """
+    return Content.assemble(
+        (heading, TStyle(dim=True, italic=True)),
+        "\n",
+        ("See what's new: ", TStyle(dim=True, italic=True)),
+        (
+            CHANGELOG_URL,
+            TStyle(dim=True, italic=True, underline=True, link=CHANGELOG_URL),
+        ),
+    )
+
+
 def _format_startup_error(error: BaseException) -> str:
     """Format a server-startup exception for the welcome banner.
 
@@ -863,6 +888,15 @@ _COMMAND_URLS: dict[str, str] = {
 }
 """Slash-command to URL mapping for commands that just open a browser."""
 
+_SANDBOX_DISPLAY_NAMES: dict[str, str] = {
+    "agentcore": "AgentCore",
+    "daytona": "Daytona",
+    "langsmith": "LangSmith",
+    "modal": "Modal",
+    "runloop": "Runloop",
+}
+"""Human-readable display names for sandbox providers."""
+
 
 _toast_internals_warned: list[bool] = [False]
 """Single-slot flag; once `_Toast._notification` is missing, log warning once.
@@ -1034,6 +1068,7 @@ class DeepAgentsApp(App):
         server_kwargs: dict[str, Any] | None = None,
         mcp_preload_kwargs: dict[str, Any] | None = None,
         model_kwargs: dict[str, Any] | None = None,
+        defer_server_start: bool = False,
         title: str | None = None,
         sub_title: str | None = None,
         **kwargs: Any,
@@ -1086,6 +1121,8 @@ class DeepAgentsApp(App):
 
                 When provided, model creation runs in a background worker after
                 first paint instead of blocking startup.
+            defer_server_start: Whether to keep CLI-owned server startup paused
+                until the user configures credentials or explicitly picks a model.
             title: Override the Textual `App.title` shown in the optional
                 header bar.
 
@@ -1250,12 +1287,21 @@ class DeepAgentsApp(App):
         """Cached kwargs for `start_server_and_get_agent`.
 
         When non-`None`, startup is deferred and the UI begins in
-        "Connecting..." state.
+        "Connecting..." state unless `_server_startup_deferred` is set.
 
         Re-used so downstream features that restart the server (e.g. `/agents`)
         start from the same config.
         """
 
+        self._server_startup_deferred = defer_server_start
+        """True when no model can be selected yet, usually first launch with
+        no credentials. The TUI is usable, but server startup waits for
+        `/auth`, `/reload`, or `/model`.
+        """
+
+        self._server_startup_deferred_notice_shown = False
+        """Whether the first-launch no-model guidance has been mounted."""
+
         self._mcp_preload_kwargs = mcp_preload_kwargs
         """Kwargs for `_preload_session_mcp_server_info`, run concurrently
         with server startup when `server_kwargs` is set."""
@@ -1278,6 +1324,12 @@ class DeepAgentsApp(App):
         self._sandbox_type: str | None = raw if raw and raw != "none" else None
         """Normalized sandbox type (or `None`), attached to trace metadata."""
 
+        if sub_title is None and self._sandbox_type is not None:
+            display = _SANDBOX_DISPLAY_NAMES.get(
+                self._sandbox_type, self._sandbox_type.title()
+            )
+            self.sub_title = f"Sandbox: {display}"
+
         # Per-turn model overrides
         self._model_override: str | None = None
         """Per-turn model override set via `/model`; `None` uses session default."""
@@ -1336,7 +1388,9 @@ class DeepAgentsApp(App):
         """
 
         # Lifecycle flags & re-entry guards
-        self._connecting = server_kwargs is not None
+        self._connecting = (
+            server_kwargs is not None and not self._server_startup_deferred
+        )
         """True while the backing server is being started or restarted.
 
         Gates message handling so user input is queued until the agent is
@@ -1886,6 +1940,9 @@ class DeepAgentsApp(App):
         self._ui_adapter._on_tokens_pending = self._show_pending_tokens
         self._ui_adapter._on_tokens_show = self._show_tokens
 
+        if self._server_startup_deferred:
+            await self._mount_deferred_start_notice()
+
         # Fire-and-forget workers — none of these block the event loop.
 
         # Discover skills first so /skill: autocomplete is ready as early
@@ -1899,7 +1956,7 @@ class DeepAgentsApp(App):
         self.run_worker(self._init_session_state, exclusive=True, group="session-init")
 
         # Server startup (model creation + server process)
-        if self._server_kwargs is not None:
+        if self._server_kwargs is not None and not self._server_startup_deferred:
             self.run_worker(
                 self._start_server_background,
                 exclusive=True,
@@ -1968,7 +2025,7 @@ class DeepAgentsApp(App):
         # `on_deep_agents_app_server_ready` fires; otherwise run it now so the
         # non-connecting path (pre-built agent) also honors `--startup-cmd` and
         # serializes startup against user input.
-        if not self._connecting:
+        if not self._connecting and not self._server_startup_deferred:
             self.call_after_refresh(
                 lambda: asyncio.create_task(self._run_session_start_sequence())
             )
@@ -2820,9 +2877,7 @@ class DeepAgentsApp(App):
             else:
                 heading = f"Updated to v{cli_version}"
 
-            await self._mount_message(
-                AppMessage(f"{heading}\nSee what's new: {CHANGELOG_URL}")
-            )
+            await self._mount_message(AppMessage(_build_whats_new_message(heading)))
         except Exception:
             logger.debug("What's new banner display failed", exc_info=True)
             return
@@ -3720,6 +3775,9 @@ class DeepAgentsApp(App):
         startup command before any user-facing agent work guarantees the
         agent never observes input until the command has completed.
         """
+        if self._server_startup_deferred:
+            return
+
         if self._launch_init_requested:
             self._ensure_launch_init_task()
         launch_init_task = self._launch_init_task
@@ -4769,13 +4827,18 @@ class DeepAgentsApp(App):
             # Reset thread to start fresh conversation
             if self._session_state:
                 new_thread_id = self._session_state.reset_thread()
+                self._lc_thread_id = new_thread_id
                 try:
                     banner = self.query_one("#welcome-banner", WelcomeBanner)
                     banner.update_thread_id(new_thread_id)
                 except NoMatches:
                     pass
-                await self._mount_message(
-                    AppMessage(f"Started new thread: {new_thread_id}")
+                thread_msg_widget = AppMessage(f"Started new thread: {new_thread_id}")
+                await self._mount_message(thread_msg_widget)
+                self._schedule_thread_message_link(
+                    thread_msg_widget,
+                    prefix="Started new thread",
+                    thread_id=new_thread_id,
                 )
         elif cmd == "/copy":
             await self._mount_message(UserMessage(command))
@@ -5030,6 +5093,7 @@ class DeepAgentsApp(App):
                     skill_lines.append(f"  - Removed: {', '.join(removed_skills)}")
                 report += "\nSkills updated:\n" + "\n".join(skill_lines)
             await self._mount_message(AppMessage(report))
+            await self._maybe_start_deferred_server_from_default()
         elif cmd.startswith("/skill:"):
             await self._handle_skill_command(command)
         # -- Hidden debug commands (not in COMMANDS / autocomplete) -----------
@@ -5461,6 +5525,8 @@ class DeepAgentsApp(App):
                 self._run_agent_task(message, message_kwargs=message_kwargs),
                 exclusive=False,
             )
+        elif self._server_startup_deferred:
+            await self._mount_message(AppMessage(_DEFERRED_START_NOTICE))
         elif not self._server_startup_error:
             # When a server-startup failure is in flight, the chat
             # `ErrorMessage` mounted by `on_deep_agents_app_server_start_failed`
@@ -5469,6 +5535,13 @@ class DeepAgentsApp(App):
                 AppMessage("Agent not configured for this session.")
             )
 
+    async def _mount_deferred_start_notice(self) -> None:
+        """Tell first-launch users how to configure model credentials."""
+        if self._server_startup_deferred_notice_shown:
+            return
+        self._server_startup_deferred_notice_shown = True
+        await self._mount_message(AppMessage(_DEFERRED_START_NOTICE))
+
     async def _run_agent_task(
         self,
         message: str,
@@ -6991,6 +7064,8 @@ class DeepAgentsApp(App):
         def handle_result(_result: None) -> None:
             if self._chat_input:
                 self._chat_input.focus_input()
+            task = asyncio.create_task(self._maybe_start_deferred_server_from_default())
+            task.add_done_callback(_log_task_exception)
 
         self.push_screen(AuthManagerScreen(), handle_result)
 
@@ -8205,14 +8280,13 @@ class DeepAgentsApp(App):
                         timeout=3,
                     )
                     return
-                # Recover from a failed startup (e.g., `MissingCredentialsError`).
-                # The server never came up, so the only way out without
-                # restarting the CLI is to retry startup with the new model.
-                # Only valid for CLI-owned servers.
+                # Recover from a startup that has not produced a server yet:
+                # either a deferred first launch with no credentials, or a
+                # failed startup such as `MissingCredentialsError`.
                 if (
-                    self._server_startup_error is not None
-                    and self._server_kwargs is not None
-                ):
+                    self._server_startup_deferred
+                    or self._server_startup_error is not None
+                ) and self._server_kwargs is not None:
                     await self._retry_startup_with_model(
                         model_spec, extra_kwargs=extra_kwargs
                     )
@@ -8386,6 +8460,7 @@ class DeepAgentsApp(App):
 
         self._server_startup_error = None
         self._server_startup_missing_credentials_provider = None
+        self._server_startup_deferred = False
         self._connecting = True
         try:
             banner = self.query_one("#welcome-banner", WelcomeBanner)
@@ -8415,6 +8490,32 @@ class DeepAgentsApp(App):
             group="server-startup",
         )
 
+    async def _maybe_start_deferred_server_from_default(self) -> bool:
+        """Start a deferred first-launch server once a default model resolves.
+
+        Returns:
+            `True` when startup was kicked off, otherwise `False`.
+        """
+        if not self._server_startup_deferred:
+            return False
+
+        from deepagents_cli.config import _get_default_model_spec
+        from deepagents_cli.model_config import (
+            ModelConfigError,
+            NoCredentialsConfiguredError,
+        )
+
+        try:
+            model_spec = _get_default_model_spec()
+        except NoCredentialsConfiguredError:
+            return False
+        except ModelConfigError as exc:
+            await self._mount_message(ErrorMessage(str(exc)))
+            return False
+
+        await self._retry_startup_with_model(model_spec)
+        return True
+
     async def _set_default_model(self, model_spec: str) -> None:
         """Set the default model in config without switching the current session.
 
@@ -8505,6 +8606,7 @@ async def run_textual_app(
     server_kwargs: dict[str, Any] | None = None,
     mcp_preload_kwargs: dict[str, Any] | None = None,
     model_kwargs: dict[str, Any] | None = None,
+    defer_server_start: bool = False,
     title: str | None = None,
     sub_title: str | None = None,
 ) -> AppResult:
@@ -8550,6 +8652,8 @@ async def run_textual_app(
 
             When provided, model creation runs in a background worker after
             first paint so the splash screen appears immediately.
+        defer_server_start: Whether to keep CLI-owned server startup paused
+            until credentials or a model are configured from inside the TUI.
         title: Override the Textual `App.title` shown in the optional header
             bar (gated on `DEEPAGENTS_CLI_SHOW_HEADER`). When `None`, the
             default `"Deep Agents"` is used.
@@ -8577,6 +8681,7 @@ async def run_textual_app(
         server_kwargs=server_kwargs,
         mcp_preload_kwargs=mcp_preload_kwargs,
         model_kwargs=model_kwargs,
+        defer_server_start=defer_server_start,
         title=title,
         sub_title=sub_title,
     )

{deepagents_cli-0.0.53 → deepagents_cli-0.0.54}/deepagents_cli/config.py

@@ -1847,12 +1847,18 @@ def _get_default_model_spec() -> str:
     3. Auto-detection based on available API credentials.
 
     Returns:
-        Model specification in provider:model format.
+        Model specification in `provider:model` format.
 
     Raises:
-        ModelConfigError: If no credentials are configured.
+        NoCredentialsConfiguredError: If no credentials are configured for any
+            of the auto-detectable providers. Callers may catch this to defer
+            startup and prompt for credentials interactively.
     """
-    from deepagents_cli.model_config import ModelConfig, ModelConfigError
+    from deepagents_cli.model_config import (
+        ModelConfig,
+        NoCredentialsConfiguredError,
+        get_provider_auth_status,
+    )
 
     config = ModelConfig.load()
     if config.default_model:
@@ -1861,19 +1867,25 @@ def _get_default_model_spec() -> str:
     if config.recent_model:
         return config.recent_model
 
-    s = _get_settings()
-    if s.has_openai:
+    # `is True` deliberately excludes `ProviderAuthState.UNKNOWN` (which maps
+    # to `as_legacy_bool() -> None`). For the three explicit-credential
+    # providers below, an UNKNOWN result means we cannot prove auth works, so
+    # we fall through rather than pick an unverifiable default. If an
+    # implicit-auth provider (e.g., Vertex ADC) is added to this fallback
+    # list, switch to checking `state` against the relevant
+    # `ProviderAuthState` members directly.
+    if get_provider_auth_status("openai").as_legacy_bool() is True:
         return "openai:gpt-5.5"
-    if s.has_anthropic:
+    if get_provider_auth_status("anthropic").as_legacy_bool() is True:
         return "anthropic:claude-opus-4-7"
-    if s.has_google:
+    if get_provider_auth_status("google_genai").as_legacy_bool() is True:
         return "google_genai:gemini-3.1-pro-preview"
 
     msg = (
         "No credentials configured. Please set one of: "
         "ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_API_KEY"
     )
-    raise ModelConfigError(msg)
+    raise NoCredentialsConfiguredError(msg)
 
 
 _OPENROUTER_APP_URL = "https://pypi.org/project/deepagents-cli/"

{deepagents_cli-0.0.53 → deepagents_cli-0.0.54}/deepagents_cli/main.py

@@ -81,6 +81,38 @@ def _resolve_agent_arg(args: argparse.Namespace) -> str:
     return DEFAULT_AGENT_NAME
 
 
+def _normalize_cwd_filter(cwd: str | None) -> str | None:
+    """Normalize the `threads list --cwd` filter for metadata matching.
+
+    Storage uses `str(Path.cwd())` (absolute, no symlink resolution — see
+    `build_run_metadata`). We mirror that here with lexical normalization
+    rather than `.resolve()` so a user invoking from a symlinked path doesn't
+    get an empty result set due to symlink normalization.
+
+    Args:
+        cwd: Parsed `--cwd` value. An empty string means the flag was passed
+            without a value and should use the current working directory.
+
+    Returns:
+        Absolute path string for filtering, or `None` when no filter was
+        requested. Returns `None` if the current working directory cannot
+        be determined (bare `--cwd` only).
+    """
+    if cwd is None:
+        return None
+    if cwd == "":  # noqa: PLC1901
+        try:
+            return str(Path.cwd())
+        except OSError:
+            logger.warning(
+                "Could not determine working directory for --cwd; "
+                "no cwd filter will be applied",
+                exc_info=True,
+            )
+            return None
+    return os.path.normpath(str(Path(cwd).expanduser().absolute()))
+
+
 def _recent_agent_is_valid(name: str) -> bool:
     """Return `True` when `~/.deepagents/<name>/` still exists on disk.
 
@@ -627,6 +659,16 @@ def parse_args() -> argparse.Namespace:
         default=None,
         help="Filter by git branch name",
     )
+    threads_list.add_argument(
+        "--cwd",
+        nargs="?",
+        const="",
+        default=None,
+        help=(
+            "Filter by working directory. With no value, uses the current "
+            "directory; pass a path to filter by that directory instead."
+        ),
+    )
     threads_list.add_argument(
         "-v",
         "--verbose",
@@ -994,15 +1036,23 @@ async def run_textual_cli_async(
         detect_provider,
         settings,
     )
-    from deepagents_cli.model_config import ModelConfigError, ModelSpec
+    from deepagents_cli.model_config import (
+        ModelConfigError,
+        ModelSpec,
+        NoCredentialsConfiguredError,
+    )
     from deepagents_cli.onboarding import should_run_onboarding
 
     # Resolve display-name cheaply (<1ms, no langchain) so the status
     # bar can show the model on first paint. The expensive create_model()
     # (~560ms) is deferred to a background worker.
 
+    defer_server_start = False
     try:
         resolved_spec = model_name or _get_default_model_spec()
+    except NoCredentialsConfiguredError:
+        resolved_spec = ""
+        defer_server_start = True
     except ModelConfigError as e:
         from rich.markup import escape
 
@@ -1011,19 +1061,25 @@ async def run_textual_cli_async(
         console.print(f"[bold red]Error:[/bold red] {escape(str(e))}", highlight=False)
         return AppResult(return_code=1, thread_id=None)
 
-    parsed = ModelSpec.try_parse(resolved_spec)
-    if parsed:
-        settings.model_provider = parsed.provider
-        settings.model_name = parsed.model
+    if resolved_spec:
+        parsed = ModelSpec.try_parse(resolved_spec)
+        if parsed:
+            settings.model_provider = parsed.provider
+            settings.model_name = parsed.model
+        else:
+            settings.model_name = resolved_spec
+            settings.model_provider = detect_provider(resolved_spec) or ""
     else:
-        settings.model_name = resolved_spec
-        settings.model_provider = detect_provider(resolved_spec) or ""
-
-    model_kwargs: dict[str, Any] = {
-        "model_spec": model_name,
-        "extra_kwargs": model_params,
-        "profile_overrides": profile_override,
-    }
+        settings.model_provider = ""
+        settings.model_name = ""
+
+    model_kwargs: dict[str, Any] | None = None
+    if not defer_server_start:
+        model_kwargs = {
+            "model_spec": model_name or resolved_spec,
+            "extra_kwargs": model_params,
+            "profile_overrides": profile_override,
+        }
 
     # Build kwargs for deferred server startup (runs inside the TUI).
     # Never pass auto_approve to the server — the interactive server must
@@ -1032,7 +1088,7 @@ async def run_textual_cli_async(
     # session_state.auto_approve in textual_adapter.py.
     server_kwargs: dict[str, Any] = {
         "assistant_id": assistant_id,
-        "model_name": model_name,
+        "model_name": model_name or resolved_spec or None,
         "model_params": model_params,
         "sandbox_type": sandbox_type,
         "sandbox_id": sandbox_id,
@@ -1068,6 +1124,7 @@ async def run_textual_cli_async(
             server_kwargs=server_kwargs,
             mcp_preload_kwargs=mcp_preload_kwargs,
             model_kwargs=model_kwargs,
+            defer_server_start=defer_server_start,
         )
     except Exception as e:
         logger.debug("App error", exc_info=True)
@@ -1913,12 +1970,31 @@ def cli_main() -> None:
             # "ls" is an argparse alias for "list" — argparse stores the
             # alias as-is in the namespace, so we must match both values.
             if args.threads_command in {"list", "ls"}:
+                raw_cwd = getattr(args, "cwd", None)
+                cwd_filter = _normalize_cwd_filter(raw_cwd)
+                # Warn (but still query) when the user passed an explicit
+                # `--cwd <path>` that does not exist on disk — otherwise a
+                # typo would silently return "No threads found" with no hint.
+                # Skip the check for the bare-flag (empty string) form, where
+                # the path was generated from `Path.cwd()` and is known to
+                # exist.
+                if (
+                    raw_cwd not in {None, ""}
+                    and cwd_filter is not None
+                    and not Path(cwd_filter).exists()
+                ):
+                    print(  # noqa: T201
+                        f"Warning: --cwd path {cwd_filter!r} does not exist; "
+                        "filtering by stored metadata anyway.",
+                        file=sys.stderr,
+                    )
                 asyncio.run(
                     list_threads_command(
                         agent_name=getattr(args, "agent", None),
                         limit=getattr(args, "limit", None),
                         sort_by=getattr(args, "sort", None),
                         branch=getattr(args, "branch", None),
+                        cwd=cwd_filter,
                         verbose=getattr(args, "verbose", False),
                         relative=getattr(args, "relative", None),
                         output_format=output_format,

{deepagents_cli-0.0.53 → deepagents_cli-0.0.54}/deepagents_cli/model_config.py

@@ -107,6 +107,18 @@ class ModelConfigError(Exception):
     """Raised when model configuration or creation fails."""
 
 
+class NoCredentialsConfiguredError(ModelConfigError):
+    """Raised when no credentials are configured for any default-resolvable provider.
+
+    Distinct from `MissingCredentialsError` (which targets a specific provider
+    the user has selected): this fires from `_get_default_model_spec()` when
+    auto-detection finds no usable credentials at all. Callers (the deferred-
+    start path in the TUI and CLI) `isinstance`-check this type to recover by
+    launching the TUI with model creation deferred, rather than string-matching
+    the formatted message.
+    """
+
+
 class UnknownProviderError(ModelConfigError):
     """Raised when neither the CLI nor `init_chat_model` can infer a provider.
 

{deepagents_cli-0.0.53 → deepagents_cli-0.0.54}/deepagents_cli/server.py

@@ -34,6 +34,8 @@ _LOG_TAIL_CHARS = 3000
 """Max chars of subprocess log appended to the early-exit `RuntimeError`
 message. Enough to carry a Python traceback without flooding the TUI banner
 when it surfaces via `ServerStartFailed`."""
+_STARTUP_ERROR_MARKER = "DEEPAGENTS_STARTUP_ERROR:"
+"""Machine-readable prefix emitted by the server subprocess for known startup errors."""
 
 
 def _port_in_use(host: str, port: int) -> bool:
@@ -86,6 +88,22 @@ def get_server_url(host: str = _DEFAULT_HOST, port: int = _DEFAULT_PORT) -> str:
     return f"http://{host}:{port}"
 
 
+def _extract_startup_error_marker(output: str) -> str | None:
+    """Extract a marked startup error from subprocess output.
+
+    Args:
+        output: Combined stdout/stderr captured from the server subprocess.
+
+    Returns:
+        The marked startup error message, or `None` if no marker was emitted.
+    """
+    for line in reversed(output.splitlines()):
+        if _STARTUP_ERROR_MARKER in line:
+            _, summary = line.rsplit(_STARTUP_ERROR_MARKER, 1)
+            return summary.strip() or None
+    return None
+
+
 def generate_langgraph_json(
     output_dir: str | Path,
     *,
@@ -204,6 +222,9 @@ async def wait_for_server_healthy(
                 output = read_log() if read_log else ""
                 msg = f"Server process exited with code {process.returncode}"
                 if output:
+                    summary = _extract_startup_error_marker(output)
+                    if summary:
+                        msg += f": {summary}"
                     msg += f"\n{output[-_LOG_TAIL_CHARS:]}"
                 raise RuntimeError(msg)