deepagents-code 0.1.19__tar.gz → 0.1.20__tar.gz

{deepagents_code-0.1.19 → deepagents_code-0.1.20}/.gitignore

@@ -100,6 +100,7 @@ ipython_config.py
 #   This is especially recommended for binary packages to ensure reproducibility, and is more
 #   commonly ignored for libraries.
 #uv.lock
+.local_deps/
 
 # poetry
 #   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.

{deepagents_code-0.1.19 → deepagents_code-0.1.20}/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 # Deep Agents Code Changelog
 
+## [0.1.20](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.19...deepagents-code==0.1.20) (2026-06-17)
+
+### Features
+
+* Manage Tavily web-search API key in `/auth` ([#4062](https://github.com/langchain-ai/deepagents/issues/4062)) ([90cc099](https://github.com/langchain-ai/deepagents/commit/90cc099b0998a9aa55df01e3bc12ad1597c65365))
+* Surface uninstalled known providers in `/auth` menu ([#4059](https://github.com/langchain-ai/deepagents/issues/4059)) ([73db271](https://github.com/langchain-ai/deepagents/commit/73db2719bce5ad3c933ffee643df4a62cfd60e17))
+* Show provider in usage stats table ([#4049](https://github.com/langchain-ai/deepagents/issues/4049)) ([309b054](https://github.com/langchain-ai/deepagents/commit/309b054fdd040adb5086408a3bcb2550ba73439e))
+* Quiet install script's full dependency list ([#4058](https://github.com/langchain-ai/deepagents/issues/4058)) ([de2c9fd](https://github.com/langchain-ai/deepagents/commit/de2c9fd8c7437fdcdfe738599f83808c5423c55c))
+
+### Bug Fixes
+
+* Read `LANGSMITH_PROJECT` for `tracing.langsmith_project` + show default ([#4054](https://github.com/langchain-ai/deepagents/issues/4054)) ([fec1551](https://github.com/langchain-ai/deepagents/commit/fec1551e901a4fe88bd74ee4833a91ef93b1e93f))
+* Surface recommended models missing from installed provider profiles ([#4057](https://github.com/langchain-ai/deepagents/issues/4057)) ([56e0d31](https://github.com/langchain-ai/deepagents/commit/56e0d31b6c507d5a1e95c3f2058a8d3b9488a4db))
+* Clarify post-update restart semantics ([#4046](https://github.com/langchain-ai/deepagents/issues/4046)) ([6318b81](https://github.com/langchain-ai/deepagents/commit/6318b817399f7dd2f2e6dc07987dca46f1da9886))
+* Hide `[SYSTEM]` interrupt notices from `/threads` prompt ([#3988](https://github.com/langchain-ai/deepagents/issues/3988)) ([68fa0cb](https://github.com/langchain-ai/deepagents/commit/68fa0cb4d48ff3f3e552bbf16f8316433c7b6f34))
+* Keep install-required `/model` rows dimmed after navigation ([#4048](https://github.com/langchain-ai/deepagents/issues/4048)) ([c499634](https://github.com/langchain-ai/deepagents/commit/c499634c530dcab9b18e3126b4573ff0d36c3efa))
+* Rescaffold server workspace on `/restart` when config is missing ([#4050](https://github.com/langchain-ai/deepagents/issues/4050)) ([de51b0e](https://github.com/langchain-ai/deepagents/commit/de51b0e082293f5f795d96d3bf717c82efb9337e))
+* Remove transient `Restarting server...` message after restart ([#4047](https://github.com/langchain-ai/deepagents/issues/4047)) ([87cc504](https://github.com/langchain-ai/deepagents/commit/87cc50428bc96ef11dfb11cee4020bff322a7216))
+* Suppress model-switch defer toast on bare reconnect ([#4060](https://github.com/langchain-ai/deepagents/issues/4060)) ([60b1052](https://github.com/langchain-ai/deepagents/commit/60b10520d24c87b9c8c9d85b94cffae9e3c67c43))
+
 ## [0.1.19](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.18...deepagents-code==0.1.19) (2026-06-17)
 
 ### Features

{deepagents_code-0.1.19 → deepagents_code-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-code
-Version: 0.1.19
+Version: 0.1.20
 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/

{deepagents_code-0.1.19 → deepagents_code-0.1.20}/deepagents_code/_constants.py

@@ -12,3 +12,12 @@ from typing import Final
 
 DEFAULT_AGENT_NAME: Final[str] = "agent"
 """Default agent / assistant identifier when no `-a` flag is given."""
+
+SYSTEM_MESSAGE_PREFIX: Final[str] = "[SYSTEM]"
+"""Prefix for synthetic human messages (e.g. interrupt cancellation notices).
+
+Such messages are written to the `messages` channel for the agent's benefit on
+resume but are not user-authored, so they are filtered out of both the rendered
+transcript and a thread's initial prompt. Shared here so the single producer
+(`textual_adapter`) and its consumers (`app`, `sessions`) agree on one literal.
+"""

{deepagents_code-0.1.19 → deepagents_code-0.1.20}/deepagents_code/_session_stats.py

@@ -17,64 +17,91 @@ SpinnerStatus = Literal["Thinking", "Offloading", "Loading thread"] | None
 
 @dataclass
 class ModelStats:
-    """Token stats for a single model within a session.
-
-    Attributes:
-        request_count: Number of LLM API requests made to this model.
-        input_tokens: Cumulative input tokens sent to this model.
-        output_tokens: Cumulative output tokens received from this model.
-    """
+    """Token stats for a single model within a session."""
 
     request_count: int = 0
+    """Number of LLM API requests made to this model."""
+
     input_tokens: int = 0
+    """Cumulative input tokens sent to this model."""
+
     output_tokens: int = 0
+    """Cumulative output tokens received from this model."""
+
+    provider: str = ""
+    """Provider that served this model (e.g. `openai`), or `""` when unknown."""
+
+    model_name: str = ""
+    """Model name displayed in usage output."""
+
+
+ModelStatsKey = tuple[str, str]
+"""Per-model dict key: the `(provider, model_name)` pair.
+
+Pairing the provider with the model name keeps the same model served by
+different providers (e.g. `gpt-5.5` via `openai` vs `azure`) in separate rows
+instead of collapsing them. The key is always built from the same values stored
+on the corresponding `ModelStats`, so key and fields never diverge.
+"""
 
 
 @dataclass
 class SessionStats:
-    """Stats accumulated over a single agent turn (or full session).
-
-    Attributes:
-        request_count: Total LLM API requests made (each chunk with
-            usage_metadata counts as one completed request).
-        input_tokens: Cumulative input tokens across all LLM requests.
-        output_tokens: Cumulative output tokens across all LLM requests.
-        wall_time_seconds: Wall-clock duration from stream start to end.
-        per_model: Per-model breakdown keyed by model name.
-            Populated only when `record_request` receives a non-empty
-            `model_name`. Empty dict means no named-model requests were
-            recorded; `print_usage_table` omits the model table in that case and
-            shows only the wall-time line (if applicable).
-    """
+    """Stats accumulated over a single agent turn (or full session)."""
 
     request_count: int = 0
+    """Total LLM API requests made.
+
+    Each chunk with `usage_metadata` counts as one completed request.
+    """
+
     input_tokens: int = 0
+    """Cumulative input tokens across all LLM requests."""
+
     output_tokens: int = 0
+    """Cumulative output tokens across all LLM requests."""
+
     wall_time_seconds: float = 0.0
-    per_model: dict[str, ModelStats] = field(default_factory=dict)
+    """Wall-clock duration from stream start to end."""
+
+    per_model: dict[ModelStatsKey, ModelStats] = field(default_factory=dict)
+    """Per-model breakdown keyed by `(provider, model_name)`.
+
+    Populated only when `record_request` receives a non-empty `model_name`. Empty
+    dict means no named-model requests were recorded; `print_usage_table` omits
+    the model table in that case and shows only the wall-time line (if applicable).
+    """
 
     def record_request(
         self,
         model_name: str,
         input_toks: int,
         output_toks: int,
+        provider: str = "",
     ) -> None:
         """Accumulate token counts for one completed LLM request.
 
         Updates both the session totals and the per-model breakdown.
 
         Args:
-            model_name: The model that served this request (used as the
-                per-model key). Pass an empty string to skip the per-model
-                breakdown for this request.
+            model_name: The model that served this request. Combined with
+                `provider` to form the per-model key. Pass an empty string to
+                skip the per-model breakdown for this request.
             input_toks: Input tokens for this request.
             output_toks: Output tokens for this request.
+            provider: Provider that served the model (e.g. `openai`). Combined
+                with `model_name` to form the per-model key, so the same model
+                served by different providers is tracked separately.
         """
         self.request_count += 1
         self.input_tokens += input_toks
         self.output_tokens += output_toks
         if model_name:
-            entry = self.per_model.setdefault(model_name, ModelStats())
+            key = (provider, model_name)
+            entry = self.per_model.setdefault(
+                key,
+                ModelStats(provider=provider, model_name=model_name),
+            )
             entry.request_count += 1
             entry.input_tokens += input_toks
             entry.output_tokens += output_toks
@@ -91,8 +118,11 @@ class SessionStats:
         self.input_tokens += other.input_tokens
         self.output_tokens += other.output_tokens
         self.wall_time_seconds += other.wall_time_seconds
-        for model, ms in other.per_model.items():
-            entry = self.per_model.setdefault(model, ModelStats())
+        for key, ms in other.per_model.items():
+            entry = self.per_model.setdefault(
+                key,
+                ModelStats(provider=ms.provider, model_name=ms.model_name),
+            )
             entry.request_count += ms.request_count
             entry.input_tokens += ms.input_tokens
             entry.output_tokens += ms.output_tokens

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

{deepagents_code-0.1.19 → deepagents_code-0.1.20}/deepagents_code/app.py

@@ -42,7 +42,10 @@ from deepagents_code import (
     theme,
 )
 from deepagents_code._cli_context import CLIContext
-from deepagents_code._constants import DEFAULT_AGENT_NAME as DEFAULT_ASSISTANT_ID
+from deepagents_code._constants import (
+    DEFAULT_AGENT_NAME as DEFAULT_ASSISTANT_ID,
+    SYSTEM_MESSAGE_PREFIX,
+)
 from deepagents_code._git import (
     read_git_branch_from_filesystem,
     read_git_branch_via_subprocess,
@@ -161,6 +164,32 @@ def _create_model_with_deepagents_import_lock(
         )
 
 
+def _extra_is_ready(extra: str) -> bool | None:
+    """Return whether all dependencies for `extra` are installed.
+
+    Returns:
+        `True` when every package declared by `extra` is importable, `False`
+            when one or more are missing, or `None` when the extra metadata
+            can't be introspected — an unknown state, distinct from a negative
+            one, so callers don't treat "couldn't check" as "not installed".
+    """
+    from deepagents_code.extras_info import (
+        ExtrasIntrospectionError,
+        get_optional_dependency_status,
+    )
+
+    try:
+        statuses = get_optional_dependency_status(strict=True)
+    except ExtrasIntrospectionError:
+        logger.warning(
+            "Could not verify whether extra %r is installed",
+            extra,
+            exc_info=True,
+        )
+        return None
+    return any(status.name == extra and status.ready for status in statuses)
+
+
 @dataclass(frozen=True)
 class _ConfigWriteResult:
     """Result of a config write with TUI-facing failure context."""
@@ -3684,7 +3713,8 @@ class DeepAgentsApp(App):
                 self.notify(
                     f"Update available: v{latest}{release_age}. "
                     f"Currently installed: {cli_version}{installed_age}. "
-                    "Restart dcode to install the update automatically.",
+                    "Quit and relaunch dcode to install the update "
+                    "automatically.",
                     severity="information",
                     timeout=12,
                     markup=False,
@@ -3924,7 +3954,9 @@ class DeepAgentsApp(App):
                 self._update_available = (False, None)
                 await self._mount_message(
                     AppMessage(
-                        f"Updated to v{latest}. Restart to use the new version."
+                        f"Updated to v{latest}. Quit and relaunch dcode to use "
+                        "the new version (`/restart` only restarts the server, "
+                        "not the CLI)."
                     ),
                 )
             else:
@@ -4727,6 +4759,35 @@ class DeepAgentsApp(App):
                 return
         await container.mount(widget)
 
+    async def _mount_transient_app_message(self, content: str) -> AppMessage | None:
+        """Mount an `AppMessage` that is not tracked by the message store.
+
+        Use for status text that should disappear once the state it describes
+        resolves (e.g. "Restarting server..."). The returned widget can be
+        removed directly; nothing lingers in the store to re-hydrate later.
+
+        Args:
+            content: The message text to display.
+
+        Returns:
+            The mounted widget, or `None` when the messages container is
+                missing or detached.
+        """
+        try:
+            messages = self.query_one("#messages", Container)
+        except (NoMatches, ScreenStackError):
+            logger.debug(
+                "Messages container unavailable; skipping transient status %r",
+                content,
+                exc_info=True,
+            )
+            return None
+        if not messages.is_attached:
+            return None
+        widget = AppMessage(content)
+        await self._mount_before_queued(messages, widget)
+        return widget
+
     def _is_spinner_at_correct_position(self, container: Container) -> bool:
         """Check whether the loading spinner is already correctly positioned.
 
@@ -7528,7 +7589,7 @@ class DeepAgentsApp(App):
                 content = (
                     msg.content if isinstance(msg.content, str) else str(msg.content)
                 )
-                if content.startswith("[SYSTEM]"):
+                if content.startswith(SYSTEM_MESSAGE_PREFIX):
                     continue
 
                 # Detect skill invocations persisted via additional_kwargs
@@ -8951,6 +9012,13 @@ class DeepAgentsApp(App):
     ) -> None:
         """Switch to `model_spec` now, or defer until in-flight work finishes.
 
+        The deferral toast is shown only for genuine in-flight user work
+        (`_agent_running`/`_shell_running`). A switch deferred solely because the
+        server is reconnecting (`_connecting` — e.g. the transient restart during
+        install-then-switch) drains automatically once the server is ready and is
+        already confirmed by the following "Switched to ..." message, so the
+        "after current task completes" toast there is misleading noise.
+
         Args:
             model_spec: The `provider:model` spec to switch to.
             extra_kwargs: Extra constructor kwargs from `--model-params`.
@@ -8968,10 +9036,11 @@ class DeepAgentsApp(App):
                     ),
                 ),
             )
-            self.notify(
-                "Model will switch after current task completes.",
-                timeout=3,
-            )
+            if self._agent_running or self._shell_running:
+                self.notify(
+                    "Model will switch after current task completes.",
+                    timeout=3,
+                )
         else:
             self.call_later(
                 partial(
@@ -9186,10 +9255,53 @@ class DeepAgentsApp(App):
         def handle_result(_result: None) -> None:
             if self._chat_input:
                 self._chat_input.focus_input()
+            # When the user selected a greyed-out (uninstalled) provider and
+            # confirmed installing it, install the extra and reopen the manager
+            # so they can add a key against the now-installed provider.
+            extra = screen.pending_install_extra
+            if extra is not None:
+                from functools import partial
+
+                self.call_later(
+                    partial(self._install_provider_then_reopen_auth, extra),
+                )
+                return
             task = asyncio.create_task(self._maybe_start_deferred_server_from_default())
             task.add_done_callback(_log_task_exception)
 
-        self.push_screen(AuthManagerScreen(), handle_result)
+        screen = AuthManagerScreen()
+        self.push_screen(screen, handle_result)
+
+    async def _install_provider_then_reopen_auth(self, extra: str) -> None:
+        """Install a provider's extra from `/auth`, then reopen the manager.
+
+        Args:
+            extra: The extra that installs the selected provider's integration.
+        """
+        if await self._install_extra(extra, auto_restart=True):
+            await self._show_auth_manager()
+            return
+        # `_install_extra` returns `False` both when the install genuinely
+        # failed (it already surfaced the reason) and when the package landed
+        # but the server restart didn't. Adding a key doesn't need the restart,
+        # so reopen whenever the extra is importable; only stay in chat on a
+        # real failure the user has already seen explained.
+        ready = await asyncio.to_thread(_extra_is_ready, extra)
+        if ready:
+            from deepagents_code.model_config import clear_caches
+
+            clear_caches()
+            await self._show_auth_manager()
+            return
+        if ready is None:
+            # Introspection couldn't confirm the state (rare). Don't dead-end
+            # silently after a multi-step flow — point the user back to `/auth`.
+            await self._mount_message(
+                AppMessage(
+                    f"Couldn't verify whether '{extra}' finished installing. "
+                    "Reopen `/auth` to add a key once it has.",
+                ),
+            )
 
     def _switch_agent(self, agent_name: str) -> None:
         """Switch to a different agent and hot-restart the backing server.
@@ -9982,8 +10094,49 @@ class DeepAgentsApp(App):
                     markup=False,
                 )
             return
+        if action_id == ActionId.ENTER_API_KEY:
+            await self._enter_service_api_key(entry, payload)
+            return
         self._log_unknown_action(entry, action_id)
 
+    async def _enter_service_api_key(
+        self,
+        entry: PendingNotification,
+        payload: MissingDepPayload,
+    ) -> None:
+        """Open the API-key entry prompt (the one `/auth` uses) for a service.
+
+        Lets the user store a service API key inline instead of exporting an
+        env var before launch.
+
+        Args:
+            entry: The missing-dependency notification entry.
+            payload: Typed payload carrying the service (tool) name.
+        """
+        from deepagents_code.model_config import SERVICE_API_KEY_ENV
+
+        service = payload.tool
+        # `env_var is None` covers any non-service tool, since `is_service` is
+        # exactly membership in `SERVICE_API_KEY_ENV`.
+        env_var = SERVICE_API_KEY_ENV.get(service)
+        if env_var is None:
+            self._log_unknown_action(entry, ActionId.ENTER_API_KEY)
+            return
+
+        from deepagents_code.widgets.auth import AuthPromptScreen, AuthResult
+
+        result = await self._push_screen_wait(
+            AuthPromptScreen(service, env_var),
+        )
+        if result == AuthResult.SAVED:
+            self._notice_registry.remove(entry.key)
+            self.notify(
+                f"Saved {service} API key. Restart to apply.",
+                severity="information",
+                timeout=6,
+                markup=False,
+            )
+
     async def _handle_update_action(
         self,
         entry: PendingNotification,
@@ -10058,7 +10211,8 @@ class DeepAgentsApp(App):
                     if not progress_modal_visible:
                         self.notify(
                             f"Updated to v{payload.latest}. "
-                            "Restart to use the new version.",
+                            "Quit and relaunch dcode to use the new version "
+                            "(/restart only restarts the server, not the CLI).",
                             severity="information",
                             timeout=10,
                             markup=False,
@@ -11081,8 +11235,15 @@ class DeepAgentsApp(App):
             return False
         if not await self._reload_configuration_for_restart():
             return False
-        await self._mount_message(AppMessage("Restarting server..."))
-        if not await self._restart_server_manual():
+        restarting = await self._mount_transient_app_message("Restarting server...")
+        restarted = False
+        try:
+            restarted = await self._restart_server_manual()
+        finally:
+            if restarting is not None:
+                with suppress(NoMatches, ScreenStackError):
+                    await restarting.remove()
+        if not restarted:
             return False
         await self._mount_message(AppMessage("Restart complete."))
         return True
@@ -11202,8 +11363,15 @@ class DeepAgentsApp(App):
                 )
             return
 
-        await self._mount_message(AppMessage("Restarting server..."))
-        if await self._restart_server_manual():
+        restarting = await self._mount_transient_app_message("Restarting server...")
+        restarted = False
+        try:
+            restarted = await self._restart_server_manual()
+        finally:
+            if restarting is not None:
+                with suppress(NoMatches, ScreenStackError):
+                    await restarting.remove()
+        if restarted:
             await self._mount_message(AppMessage("Restart complete."))
 
     async def _restart_server_manual(self) -> bool:

{deepagents_code-0.1.19 → deepagents_code-0.1.20}/deepagents_code/config.py

@@ -549,6 +549,13 @@ def _ensure_bootstrap() -> None:
             # Tracing enabled without a key floods the TUI with 401 ingest
             # errors; disable it before any traced run starts.
             _disable_orphaned_tracing()
+
+            # Bridge stored service keys (e.g. Tavily web search, entered via
+            # `/auth`) onto their canonical env vars before settings detection,
+            # so a stored key activates the feature without exporting the var.
+            from deepagents_code.model_config import apply_stored_service_credentials
+
+            apply_stored_service_credentials()
         except Exception:
             logger.exception(
                 "Bootstrap failed; .env values and LANGSMITH_PROJECT override "
@@ -2378,6 +2385,7 @@ def get_langsmith_project_name() -> str | None:
     Returns:
         Project name string when LangSmith tracing is active, None otherwise.
     """
+    from deepagents_code.config_manifest import LANGSMITH_PROJECT_DEFAULT
     from deepagents_code.model_config import resolve_env_var
 
     langsmith_key = resolve_env_var("LANGSMITH_API_KEY") or resolve_env_var(
@@ -2392,7 +2400,7 @@ def get_langsmith_project_name() -> str | None:
     return (
         _get_settings().deepagents_langchain_project
         or os.environ.get("LANGSMITH_PROJECT")
-        or "deepagents-code"
+        or LANGSMITH_PROJECT_DEFAULT
     )
 
 

{deepagents_code-0.1.19 → deepagents_code-0.1.20}/deepagents_code/config_manifest.py

@@ -58,6 +58,12 @@ INTERPRETER_MAX_RESULT_CHARS_DEFAULT = 4000
 INTERPRETER_PTC_DEFAULT: str | bool | list[str] = False
 INTERPRETER_PTC_ACKNOWLEDGE_UNSAFE_DEFAULT = False
 
+LANGSMITH_PROJECT_DEFAULT = "deepagents-code"
+"""Project agent traces fall back to when no project env var is set.
+
+Single source of truth shared by the `tracing.langsmith_project` option and
+`config.get_langsmith_project_name`."""
+
 
 class OptionKind(Enum):
     """How an option's raw env/TOML value is coerced to a typed value.
@@ -163,6 +169,14 @@ class ConfigOption:
     `DEEPAGENTS_CODE_` prefix override is applied dynamically at resolution time.
     """
 
+    fallback_env_vars: tuple[str, ...] = ()
+    """Secondary env vars read (in order) when `env_var` is unset.
+
+    Read literally — no `DEEPAGENTS_CODE_` prefix logic — so `config show`/`get`
+    mirror runtime fallbacks such as `get_langsmith_project_name` reading bare
+    `LANGSMITH_PROJECT`.
+    """
+
     toml_keys: tuple[str, ...] | None = None
     """Section/key path within `config.toml`, or `None`."""
 
@@ -207,9 +221,24 @@ class ConfigOption:
         `resolve_scalar`. Catching it here fails the import (and the test suite).
 
         Raises:
-            TypeError: When `default` is mutable, a `STRUCTURED` option declares
-                a default, or a scalar option's default has the wrong type.
+            TypeError: When `fallback_env_vars` is not a tuple of non-empty
+                strings, `default` is mutable, a `STRUCTURED` option declares a
+                default, or a scalar option's default has the wrong type.
         """
+        # Guard `fallback_env_vars` independently of `default` (which has its own
+        # early-return path below): like `default`, it is shared by reference
+        # through the `get_config_options` `lru_cache`, so a mutable value (a
+        # `list`) would reintroduce the aliasing hazard the default guard exists
+        # to prevent. Empty names never match any env var, so reject those too.
+        if not isinstance(self.fallback_env_vars, tuple) or any(
+            not isinstance(name, str) or not name for name in self.fallback_env_vars
+        ):
+            msg = (
+                f"{self.key}: fallback_env_vars must be a tuple of non-empty "
+                f"strings, got {self.fallback_env_vars!r}"
+            )
+            raise TypeError(msg)
+
         default = self.default
         if default is None:
             if self.invert_toml_bool:
@@ -498,27 +527,40 @@ def resolve_scalar(
         option: The option to resolve.
         toml_data: Parsed `config.toml` mapping (see `load_config_toml`).
 
+    Resolution order is: the prefixed primary `env_var`, then each
+    `fallback_env_vars` name in declaration order, then `config.toml`, then the
+    typed `default`.
+
     Returns:
         `(value, source)`, where `source` is `env (<name>)`, `config.toml`, or
         `default`. A malformed `int`/`float`/list/PTC value, an unrecognized
         boolean token, or any TOML value of the wrong type is logged and skipped
         so the next layer (or the typed default) applies. An empty env value is
         treated as unset (mirroring `resolve_env_var`), so it falls through to
-        `config.toml`/`default` rather than counting as set. Theme resolution
-        (`THEME_DELEGATE`) reports its own richer `config.toml [ui.*]` sources.
+        the next env var, then `config.toml`/`default`, rather than counting as
+        set. Theme resolution (`THEME_DELEGATE`) reports its own richer
+        `config.toml [ui.*]` sources.
     """
     if option.kind is OptionKind.THEME_DELEGATE:
         return _resolve_theme(toml_data)
 
-    if option.env_var:
+    if option.env_var or option.fallback_env_vars:
         from deepagents_code.model_config import resolved_env_var_name
 
-        name = resolved_env_var_name(option.env_var)
-        # An empty string counts as unset, matching `resolve_env_var`: this
-        # keeps `config show`/`get` aligned with what the runtime reads (and
-        # lets a prefixed empty var suppress a canonical one).
-        raw = os.environ.get(name)
-        if raw:
+        names: list[str] = []
+        if option.env_var:
+            names.append(resolved_env_var_name(option.env_var))
+        names.extend(option.fallback_env_vars)
+        # An empty string counts as unset, matching `resolve_env_var`, so it is
+        # skipped and the loop continues to the next name. This keeps
+        # `config show`/`get` aligned with what the runtime reads: e.g. an empty
+        # prefixed `DEEPAGENTS_CODE_LANGSMITH_PROJECT` falls through to a bare
+        # `LANGSMITH_PROJECT`, mirroring `get_langsmith_project_name`. Names are
+        # tried in order, so the primary `env_var` wins over any fallback.
+        for name in names:
+            raw = os.environ.get(name)
+            if not raw:
+                continue
             value = _coerce_env(option, raw, name)
             if value is not _INVALID:
                 return value, f"env ({name})"
@@ -819,7 +861,9 @@ _STATIC_OPTIONS: tuple[ConfigOption, ...] = (
         group="Models",
         summary="LangSmith project name for deepagents agent traces.",
         kind=OptionKind.STR,
+        default=LANGSMITH_PROJECT_DEFAULT,
         env_var=_env_vars.LANGSMITH_PROJECT,
+        fallback_env_vars=("LANGSMITH_PROJECT",),
         settings_field="deepagents_langchain_project",
     ),
     ConfigOption(

{deepagents_code-0.1.19 → deepagents_code-0.1.20}/deepagents_code/main.py

@@ -704,13 +704,15 @@ def build_missing_tool_notification(tool: str) -> "PendingNotification":
             key="dep:tavily",
             title="Web search disabled",
             body=(
-                "TAVILY_API_KEY is not set, so web search is disabled.\n\n"
-                "Get a key at https://tavily.com"
+                "No Tavily API key is set, so web search is disabled.\n\n"
+                "Enter a key to store it (takes effect next launch), or get one "
+                "at https://tavily.com"
             ),
             actions=(
                 NotificationAction(
-                    ActionId.OPEN_WEBSITE, "Open tavily.com", primary=True
+                    ActionId.ENTER_API_KEY, "Enter API key", primary=True
                 ),
+                NotificationAction(ActionId.OPEN_WEBSITE, "Open tavily.com"),
                 suppress_action,
             ),
             payload=MissingDepPayload(tool="tavily", url="https://tavily.com"),