deepagents-code 0.1.78__tar.gz → 0.1.79__tar.gz

{deepagents_code-0.1.78 → deepagents_code-0.1.79}/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 # Deep Agents Code Changelog
 
+## [0.1.79](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.78...deepagents-code==0.1.79) (2026-09-29)
+
+### Bug Fixes
+
+- MCP tool calls now use configurable timeouts to prevent them from hanging indefinitely ([#6625](https://github.com/langchain-ai/deepagents/pull/6625)).
+- Stdio MCP servers now start in the session directory ([#6626](https://github.com/langchain-ai/deepagents/pull/6626)).
+- JavaScript subagent costs are preserved when resuming a session ([#6433](https://github.com/langchain-ai/deepagents/pull/6433)).
+- Thread switching now completes its preflight faster and shows progress sooner ([#6607](https://github.com/langchain-ai/deepagents/pull/6607)).
+- The `/effort` setting is now constrained for between-tools thinking ([#6630](https://github.com/langchain-ai/deepagents/pull/6630)).
+- CLI help now displays the same defaults used at runtime ([#6613](https://github.com/langchain-ai/deepagents/pull/6613)).
+- The incognito label now appears on the chat input border ([#6627](https://github.com/langchain-ai/deepagents/pull/6627)).
+
 ## [0.1.78](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.77...deepagents-code==0.1.78) (2026-09-28)
 
 ### Features

{deepagents_code-0.1.78 → deepagents_code-0.1.79}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: deepagents-code
-Version: 0.1.78
+Version: 0.1.79
 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://www.langchain.com/dcode
 Project-URL: Documentation, https://docs.langchain.com/oss/deepagents/code/overview
@@ -30,12 +30,12 @@ Requires-Python: <4.0,>=3.12
 Requires-Dist: aiosqlite<1.0.0,>=0.22.1
 Requires-Dist: anyio<5.0.0,>=4.14.2
 Requires-Dist: deepagents-acp<1.0.0,>=0.0.10
-Requires-Dist: deepagents==0.7.19
+Requires-Dist: deepagents==0.7.20
 Requires-Dist: fastmcp<5.0.0,>=4.0.0b4
 Requires-Dist: filelock<3.30,>=3.29.7
 Requires-Dist: genai-prices<0.2.0,>=0.1.9
 Requires-Dist: httpx<1.0.0,>=0.28.1
-Requires-Dist: langchain-anthropic<2.0.0,>=1.7.4
+Requires-Dist: langchain-anthropic<2.0.0,>=1.7.5
 Requires-Dist: langchain-google-genai<5.0.0,>=4.4.0
 Requires-Dist: langchain-openai<2.0.0,>=1.6.6
 Requires-Dist: langchain-quickjs<0.4.0,>=0.3.4
@@ -66,7 +66,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.7.4; extra == 'all-providers'
+Requires-Dist: langchain-anthropic<2.0.0,>=1.7.5; extra == 'all-providers'
 Requires-Dist: langchain-aws<2.0.0,>=1.7.9; extra == 'all-providers'
 Requires-Dist: langchain-baseten<1.0.0,>=0.2.4; extra == 'all-providers'
 Requires-Dist: langchain-cohere<1.0.0,>=0.6.0; extra == 'all-providers'
@@ -94,7 +94,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.7.4; extra == 'anthropic'
+Requires-Dist: langchain-anthropic<2.0.0,>=1.7.5; extra == 'anthropic'
 Provides-Extra: baseten
 Requires-Dist: langchain-baseten<1.0.0,>=0.2.4; extra == 'baseten'
 Provides-Extra: bedrock

{deepagents_code-0.1.78 → deepagents_code-0.1.79}/deepagents_code/_build_info.py

@@ -1,3 +1,3 @@
 """Generated at build time. Do not edit or commit."""
 
-BUILD_COMMIT = "2018c6d"
+BUILD_COMMIT = "f6f9721"

{deepagents_code-0.1.78 → deepagents_code-0.1.79}/deepagents_code/_constants.py

@@ -13,6 +13,9 @@ from typing import Final
 DEFAULT_AGENT_NAME: Final[str] = "agent"
 """Default agent / assistant identifier when no `-a` flag is given."""
 
+DEFAULT_THREAD_LIMIT: Final[int] = 100
+"""Fallback maximum number of recent threads to load and display."""
+
 FS_TOOL_NAMES: Final[frozenset[str]] = frozenset(
     {"ls", "read_file", "write_file", "edit_file", "delete", "glob", "grep", "execute"}
 )

{deepagents_code-0.1.78 → deepagents_code-0.1.79}/deepagents_code/_env_vars.py

@@ -70,6 +70,13 @@ Like `AUTO_CLASSIFIER_MODEL`, a committed *project* `.env` cannot set it (see
 `config._PROJECT_DOTENV_DENIED_ENV_KEYS`).
 """
 
+MCP_TOOL_TIMEOUT = "DEEPAGENTS_CODE_MCP_TOOL_TIMEOUT"
+"""Seconds an MCP tool call may run before returning a failed tool message.
+
+Values outside 1-900 seconds are ignored in favor of the next config source.
+Also settable via `[mcp].tool_timeout` in config.toml.
+"""
+
 AUTO_UPDATE = "DEEPAGENTS_CODE_AUTO_UPDATE"
 """Toggle automatic app updates. Enabled by default; set to a falsy value
 ('0', 'false', 'no', 'off', or empty) to opt out."""
@@ -507,7 +514,7 @@ repo file, so a project `.env` cannot disable itself.
 """
 
 RECENT_THREADS = "DEEPAGENTS_CODE_RECENT_THREADS"
-"""Maximum number of recent threads loaded and displayed (default: 100)."""
+"""Maximum recent threads (default: `_constants.DEFAULT_THREAD_LIMIT`)."""
 
 RECURSION_LIMIT = "DEEPAGENTS_CODE_RECURSION_LIMIT"
 """Override the main agent's LangGraph `recursion_limit` (graph step budget).

deepagents_code-0.1.79/deepagents_code/_js_cost.py

@@ -0,0 +1,268 @@
+"""Accounting-only transport for JavaScript subagents."""
+
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+import hashlib
+import itertools
+import json
+import math
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, override
+
+from langchain_core.tools import StructuredTool
+from langchain_quickjs import CodeInterpreterMiddleware
+from langgraph.checkpoint.base import (
+    BaseCheckpointSaver,
+    CheckpointMetadata,
+    empty_checkpoint,
+)
+from langgraph.config import get_config
+from langgraph.types import Command
+
+from deepagents_code.cost_tracking import (
+    _empty_cost_breakdown,
+    _merge_cost_breakdowns,
+    _parent_checkpoint_scope,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from langchain_core.messages import ToolMessage
+    from langchain_core.runnables import RunnableConfig
+    from langgraph.prebuilt.tool_node import ToolCallRequest, ToolRuntime
+
+    from deepagents_code.cost_tracking import CostBreakdown
+
+_ACCOUNTING_KEY = "__deepagents_js_cost_owner"
+_RESPONSE_FORMAT_KEY = "__deepagents_subagent_response_format"
+
+
+class _ReceiptMetadata(CheckpointMetadata):
+    js_cost_owner: str
+
+
+def _digest(value: str) -> str:
+    """Return a hashed identity without storing prompts in checkpoint names."""
+    return hashlib.sha256(value.encode()).hexdigest()
+
+
+class CostAwareCodeInterpreterMiddleware(CodeInterpreterMiddleware):
+    """Transport cost receipts without caching JavaScript or forwarding state."""
+
+    @override
+    def wrap_tool_call(
+        self,
+        request: ToolCallRequest,
+        handler: Callable[[ToolCallRequest], ToolMessage | Command],
+    ) -> ToolMessage | Command:
+        """Preserve synchronous execution; receipt transport is async-only.
+
+        Args:
+            request: Tool call and its runtime context.
+            handler: Synchronous tool executor.
+
+        Returns:
+            The tool result without modification.
+        """
+        return handler(request)
+
+    async def awrap_tool_call(
+        self,
+        request: ToolCallRequest,
+        handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]],
+    ) -> ToolMessage | Command:
+        """Return owned receipts after settling all dispatched children."""
+        if request.tool not in self.tools:
+            return await handler(request)
+        configurable = request.runtime.config.get("configurable", {})
+        scope = configurable.get("checkpoint_ns", "")
+        owner = configurable.get(_ACCOUNTING_KEY)
+        accounting = (
+            owner or f"{scope}|js_cost:{_digest(request.runtime.tool_call_id or '')}"
+        )
+        active: set[asyncio.Task] = set()
+        tools = [
+            _cost_task(tool, request.runtime, accounting, active)
+            if isinstance(tool, StructuredTool) and tool.name == "task"
+            else tool
+            for tool in request.runtime.tools
+        ]
+        runtime = dataclasses.replace(request.runtime, tools=tools)
+        try:
+            result = await handler(request.override(runtime=runtime))
+        finally:
+            for invocation in list(active):
+                if not invocation.cancelling():
+                    invocation.cancel()
+            await asyncio.gather(*active, return_exceptions=True)
+        if owner:
+            return result
+        receipt = await _receipt_total(runtime.config, accounting)
+        if receipt is None:
+            return result
+        total, breakdown = receipt
+        transfers = {
+            accounting: {
+                "owner_scope": _parent_checkpoint_scope(scope),
+                "cost_usd": total,
+                "breakdown": breakdown,
+            }
+        }
+        if isinstance(result, Command):
+            update = dict(result.update) if isinstance(result.update, Mapping) else {}
+            update["_session_cost_transfers"] = transfers
+            return dataclasses.replace(result, update=update)
+        return Command(
+            update={"messages": [result], "_session_cost_transfers": transfers}
+        )
+
+
+def _cost_task(
+    tool: StructuredTool,
+    outer_runtime: ToolRuntime,
+    owner: str,
+    active: set[asyncio.Task],
+) -> StructuredTool:
+    """Return a task proxy with request-isolated child graph checkpoints."""
+    occurrences: dict[str, int] = {}
+
+    async def invoke(
+        description: str, subagent_type: str, runtime: ToolRuntime
+    ) -> object:
+        configurable = dict(runtime.config.get("configurable", {}))
+        response_format = configurable.get(_RESPONSE_FORMAT_KEY)
+        fingerprint = _digest(
+            json.dumps(
+                [description, subagent_type, getattr(response_format, "schema", None)],
+                sort_keys=True,
+            )
+        )
+        occurrence = occurrences.get(fingerprint, 0)
+        occurrences[fingerprint] = occurrence + 1
+        scope = outer_runtime.config.get("configurable", {}).get("checkpoint_ns", "")
+        configurable["checkpoint_ns"] = (
+            f"{scope}|js_dispatch:{fingerprint}_{occurrence}"
+        )
+        configurable[_ACCOUNTING_KEY] = owner
+        # The SDK's task closure owns the actual child ainvoke, including
+        # dynamic response schemas. Public durability="sync" belongs there;
+        # until that boundary exposes it, inherit LangGraph 1.2's config key.
+        configurable["__pregel_durability"] = "sync"
+        configurable["__deepagents_js_cost_loop"] = asyncio.get_running_loop()
+        scratchpad = configurable.get("__pregel_scratchpad")
+        if scratchpad is not None:
+            configurable["__pregel_scratchpad"] = dataclasses.replace(
+                scratchpad, subgraph_counter=itertools.count().__next__
+            )
+        config: RunnableConfig = {**runtime.config, "configurable": configurable}
+        invocation = asyncio.current_task()
+        if invocation is not None:
+            active.add(invocation)
+        try:
+            return await tool.arun(
+                {
+                    "description": description,
+                    "subagent_type": subagent_type,
+                    "runtime": dataclasses.replace(runtime, config=config),
+                },
+                config=config,
+                tool_call_id=runtime.tool_call_id,
+            )
+        finally:
+            if invocation is not None:
+                active.discard(invocation)
+
+    return tool.model_copy(update={"coroutine": invoke})
+
+
+def record_cost_receipt(
+    amount: float, *, breakdown: CostBreakdown | None = None
+) -> None:
+    """Persist one local node delta before its graph update returns.
+
+    Args:
+        amount: Dollars priced here, excluding claimed descendant transfers.
+        breakdown: Local requests, including free and unpriceable usage.
+            Omitted detail is preserved as incomplete legacy accounting.
+    """
+    configurable = get_config().get("configurable", {})
+    owner = configurable.get(_ACCOUNTING_KEY)
+    saver = configurable.get("__pregel_checkpointer")
+    if not owner or not isinstance(saver, BaseCheckpointSaver):
+        return
+    if amount <= 0 and (breakdown is None or breakdown["request_count"] == 0):
+        return
+    namespace = configurable.get("checkpoint_ns", "")
+    config: RunnableConfig = {
+        "configurable": {
+            "thread_id": configurable["thread_id"],
+            "checkpoint_ns": f"{owner}|receipt:{_digest(namespace)}",
+        }
+    }
+    loop = configurable["__deepagents_js_cost_loop"]
+    asyncio.run_coroutine_threadsafe(
+        _put_receipt(saver, config, owner, amount, breakdown), loop
+    ).result()
+
+
+async def _put_receipt(
+    saver: BaseCheckpointSaver,
+    config: RunnableConfig,
+    owner: str,
+    amount: float,
+    breakdown: CostBreakdown | None,
+) -> None:
+    """Persist a node's first usage delta without replacing it on replay."""
+    if await saver.aget_tuple(config) is not None:
+        return
+    checkpoint = empty_checkpoint()
+    checkpoint["channel_values"] = {"cost_usd": amount}
+    if breakdown is not None:
+        checkpoint["channel_values"]["breakdown"] = breakdown
+    checkpoint["channel_versions"] = dict.fromkeys(
+        checkpoint["channel_values"], checkpoint["id"]
+    )
+    metadata: _ReceiptMetadata = {"js_cost_owner": owner}
+    await saver.aput(config, checkpoint, metadata, checkpoint["channel_versions"])
+
+
+async def _receipt_total(
+    config: RunnableConfig, owner: str
+) -> tuple[float, CostBreakdown] | None:
+    """Return the sum of the latest local receipts owned by this eval."""
+    configurable = config.get("configurable", {})
+    saver = configurable.get("__pregel_checkpointer")
+    if not isinstance(saver, BaseCheckpointSaver):
+        return None
+    seen: set[str] = set()
+    total = 0.0
+    breakdown = _empty_cost_breakdown()
+    async for receipt in saver.alist(
+        {"configurable": {"thread_id": configurable["thread_id"]}},
+        filter={"js_cost_owner": owner},
+    ):
+        namespace = receipt.config["configurable"]["checkpoint_ns"]
+        if namespace in seen:
+            continue
+        seen.add(namespace)
+        values = receipt.checkpoint["channel_values"]
+        amount = values.get("cost_usd")
+        if (
+            isinstance(amount, int | float)
+            and not isinstance(amount, bool)
+            and math.isfinite(amount)
+            and amount >= 0
+        ):
+            total += amount
+            detail = values.get("breakdown")
+            if not isinstance(detail, Mapping):
+                # Keep legacy dollars without inventing requests or attribution.
+                detail = _empty_cost_breakdown(historical_complete=False)
+                detail["total_cost_usd"] = amount
+            breakdown = _merge_cost_breakdowns(breakdown, detail)
+        else:
+            breakdown["historical_complete"] = False
+    return (total, breakdown) if seen else None

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

{deepagents_code-0.1.78 → deepagents_code-0.1.79}/deepagents_code/agent.py

@@ -32,6 +32,7 @@ if TYPE_CHECKING:
     from langchain.messages import ToolCall
     from langchain_core.language_models import BaseChatModel
     from langchain_core.messages import ToolMessage
+    from langchain_quickjs import PTCOption
     from langgraph.checkpoint.base import BaseCheckpointSaver
     from langgraph.prebuilt.tool_node import ToolCallRequest
     from langgraph.pregel import Pregel
@@ -2869,6 +2870,13 @@ def create_cli_agent(
                 mcp_tools=mcp_tools,
             )
         )
+        if mcp_tools:
+            from deepagents_code.config_manifest import resolve_mcp_tool_timeout
+            from deepagents_code.mcp_middleware import mcp_tool_middleware
+
+            middleware.append(
+                mcp_tool_middleware(timeout_seconds=resolve_mcp_tool_timeout())
+            )
         # Subagents share the on-disk filesystem backend and can edit the user
         # AGENTS.md, so they get the same managed onboarding-name block guard as
         # the main agent. Gated on memory because the block only exists when
@@ -3146,7 +3154,8 @@ def create_cli_agent(
         from langchain_core._api import (  # noqa: PLC2701  # re-exported in _api.__all__
             suppress_langchain_beta_warning,
         )
-        from langchain_quickjs import CodeInterpreterMiddleware, PTCOption
+
+        from deepagents_code._js_cost import CostAwareCodeInterpreterMiddleware
 
         interpreter = interpreter_config or InterpreterConfig.from_resolver()
         ptc_names = _resolve_ptc_option(
@@ -3163,7 +3172,7 @@ def create_cli_agent(
         # and the warning is not actionable for users, so suppress it.
         with suppress_langchain_beta_warning():
             agent_middleware.append(
-                CodeInterpreterMiddleware(
+                CostAwareCodeInterpreterMiddleware(
                     tool_name="js_eval",
                     timeout=interpreter.timeout_seconds,
                     memory_limit=interpreter.memory_limit_mb * 1024 * 1024,
@@ -3333,6 +3342,15 @@ def create_cli_agent(
     hooks_cwd = Path(effective_cwd) if effective_cwd is not None else Path.cwd()
     server_hooks_middleware = ServerHooksMiddleware(cwd=hooks_cwd, mcp_tools=mcp_tools)
     agent_middleware.append(server_hooks_middleware)
+    # Keep timeout results inside the hooks wrapper so PostToolUseFailure sees
+    # them just like other failed tool calls.
+    if mcp_tools:
+        from deepagents_code.config_manifest import resolve_mcp_tool_timeout
+        from deepagents_code.mcp_middleware import mcp_tool_middleware
+
+        agent_middleware.append(
+            mcp_tool_middleware(timeout_seconds=resolve_mcp_tool_timeout())
+        )
 
     # Publish the server operation on the backend shared with `server_graph`.
     # The custom HTTP route owns checkpoint access and persistence, while this

{deepagents_code-0.1.78 → deepagents_code-0.1.79}/deepagents_code/app.py

@@ -19190,9 +19190,9 @@ class DeepAgentsApp(App):
         """Update model displays and the `/effort` hint for the active model."""
         from deepagents_code.config import runtime_state
         from deepagents_code.reasoning_effort import (
+            available_efforts_for_model,
             current_effort_from_model_params,
             default_effort_for_model,
-            supported_efforts_for_model,
         )
 
         provider = runtime_state.model_provider or ""
@@ -19200,8 +19200,10 @@ class DeepAgentsApp(App):
         spec = self._effective_model_spec()
         if self._chat_input is not None:
             try:
-                efforts = supported_efforts_for_model(
-                    spec, cli_override=self._profile_override
+                efforts = available_efforts_for_model(
+                    spec,
+                    self._model_params_override,
+                    cli_override=self._profile_override,
                 )
                 hint = f"[{'|'.join((*efforts, 'clear'))}]" if efforts else ""
                 self._chat_input.set_argument_hint_override("/effort", hint)
@@ -19243,8 +19245,10 @@ class DeepAgentsApp(App):
                 or default_effort_for_model(spec, cli_override=self._profile_override)
                 or (
                     _UNKNOWN_EFFORT_LABEL
-                    if supported_efforts_for_model(
-                        spec, cli_override=self._profile_override
+                    if available_efforts_for_model(
+                        spec,
+                        self._model_params_override,
+                        cli_override=self._profile_override,
                     )
                     else ""
                 )
@@ -19268,6 +19272,7 @@ class DeepAgentsApp(App):
             load_effort_for_model,
         )
         from deepagents_code.reasoning_effort import (
+            available_efforts_for_model,
             has_explicit_effort_model_params,
             is_effort_supported_for_model,
             with_effort_model_params,
@@ -19296,6 +19301,10 @@ class DeepAgentsApp(App):
                     model_spec,
                 )
             return
+        if effort not in available_efforts_for_model(
+            model_spec, self._model_params_override, cli_override=self._profile_override
+        ):
+            return
         self._model_params_override = with_effort_model_params(
             model_spec,
             self._model_params_override,
@@ -19313,9 +19322,9 @@ class DeepAgentsApp(App):
                 `isinstance(..., _EffortUnavailable)`.
         """
         from deepagents_code.reasoning_effort import (
+            available_efforts_for_model,
             current_effort_from_model_params,
             default_effort_for_model,
-            supported_efforts_for_model,
         )
 
         spec = self._effective_model_spec()
@@ -19323,7 +19332,9 @@ class DeepAgentsApp(App):
             return _EffortUnavailable(
                 "No model is configured yet. Run `/model` to choose one."
             )
-        efforts = supported_efforts_for_model(spec, cli_override=self._profile_override)
+        efforts = available_efforts_for_model(
+            spec, self._model_params_override, cli_override=self._profile_override
+        )
         if not efforts:
             return _EffortUnavailable(
                 f"Reasoning effort is not configurable for {spec}."
@@ -30708,11 +30719,15 @@ class DeepAgentsApp(App):
 
         if self._session_state.thread_id == thread_id:
             prev_cwd = Path(self._cwd)
-            cwd_choice = await self._offer_thread_cwd_switch(
-                thread_id,
-                restart_server=True,
-                abort="thread_switch",
-            )
+            try:
+                await self._set_spinner("Loading thread")
+                cwd_choice = await self._offer_thread_cwd_switch(
+                    thread_id,
+                    restart_server=True,
+                    abort="thread_switch",
+                )
+            finally:
+                await self._set_spinner(None)
             if cwd_choice == "abort":
                 return
             if await asyncio.to_thread(self._cwd_paths_equal, self._cwd, prev_cwd):
@@ -30748,6 +30763,8 @@ class DeepAgentsApp(App):
 
         self._thread_switching = True
         try:
+            self._update_status(f"Loading thread: {thread_id}")
+            await self._set_spinner("Loading thread")
             blocked = await self._thread_resume_block(thread_id)
             if blocked:
                 await self._mount_message(AppMessage(blocked))
@@ -30778,8 +30795,6 @@ class DeepAgentsApp(App):
             prefetched_payload: _ThreadHistoryPayload | None = None
             outgoing_ended = False
             try:
-                self._update_status(f"Loading thread: {thread_id}")
-                await self._set_spinner("Loading thread")
                 prefetched_payload = await self._fetch_thread_history_data(thread_id)
                 from deepagents_code.hooks.models.domain import (
                     SessionEndCause,
@@ -30932,12 +30947,12 @@ class DeepAgentsApp(App):
                 error_message += " Use /threads to try again."
                 await self._mount_message(AppMessage(error_message))
             finally:
-                await self._set_spinner(None)
-                self._update_status("")
                 if self._chat_input:
                     self._chat_input.set_cursor_active(active=not self._agent_running)
         finally:
             self._thread_switching = False
+            await self._set_spinner(None)
+            self._update_status("")
 
     async def _mount_resume_adoption_failure(
         self, desired: str, reason: str, *, hint: str = ""

{deepagents_code-0.1.78 → deepagents_code-0.1.79}/deepagents_code/client/commands/config.py

@@ -273,6 +273,7 @@ def _resolve(
         _ranked_source,
         resolve_auto_classifier_model_with_source,
         resolve_auto_classifier_timeout_with_source,
+        resolve_mcp_tool_timeout_with_source,
         resolve_startup_mode_with_source,
     )
     from deepagents_code.configuration.resolver import (
@@ -323,6 +324,13 @@ def _resolve(
         )
         return source != "default", source, timeout
 
+    if option.key == "mcp.tool_timeout":
+        timeout, source = resolve_mcp_tool_timeout_with_source(
+            toml_data=toml_data,
+            managed_toml_data=managed_toml_data,
+        )
+        return source != "default", source, timeout
+
     if option.key == "startup.mode":
         # The manifest default that plain resolution returns ignores the
         # app-managed `[startup].recent` fallback that `load_startup_mode`

{deepagents_code-0.1.78 → deepagents_code-0.1.79}/deepagents_code/config.py

@@ -40,6 +40,7 @@ from deepagents_code._env_vars import (
     DISABLED_PROJECT_MCP_SERVERS,
     FORKED_SUBAGENTS,
     HIDE_SPLASH_VERSION,
+    MCP_TOOL_TIMEOUT,
     READ_PROJECT_DOTENV,
     UI_CHARSET_MODE,
     is_env_truthy,
@@ -386,6 +387,7 @@ _PROJECT_DOTENV_DENIED_ENV_KEYS = frozenset(
         DISABLED_PROJECT_MCP_SERVERS,
         AUTO_CLASSIFIER_MODEL,
         AUTO_CLASSIFIER_TIMEOUT,
+        MCP_TOOL_TIMEOUT,
         FORKED_SUBAGENTS,
         _LANGGRAPH_DEFAULT_RECURSION_LIMIT_ENV,
         "TERM_PROGRAM",