ms-tau-sdk 2.0.10.dev50__tar.gz → 2.0.11.dev52__tar.gz

{ms_tau_sdk-2.0.10.dev50 → ms_tau_sdk-2.0.11.dev52}/CHANGELOG.md

@@ -1,7 +1,27 @@
 # Changelog
 
+## 2.0.11 — 2026-10-11
+
+- **Every MCP connection honors per-call response deadlines
+  ([#90](https://github.com/mainsequence-sdk/ms-tau-sdk/issues/90), ADR 0022 amendment).**
+  `call_tool(..., timeout_seconds=N)` can wait for delayed headers, JSON bodies and SSE data
+  beyond the backend HTTP read limit. The finite, positive override replaces the session's
+  default response wait without changing shared HTTP settings or another call's deadline.
+  Expiration and caller cancellation close that call's local response, keep the connection
+  usable, and never replay its remote operation; cancelled queued calls are skipped.
+  Initialization/catalog/resource read limits and HTTP connect/write/pool limits remain bounded.
+  A standalone platform call has no implicit runtime turn limit. Real HTTP regression tests
+  cover these behaviors for platform and generic MCP connections.
+
 ## 2.0.10 — 2026-10-09
 
+- **Declared applications wait while waking ([#87](https://github.com/mainsequence-sdk/ms-tau-sdk/issues/87)).**
+  An access response with `state: waking` and no grant no longer fails immediately as
+  `access_unavailable`. Tau follows the platform's retry guidance until access is ready, for up
+  to `TAU_MCP_APPLICATION_READY_TIMEOUT_SECONDS` (default `120`) or the remaining turn time.
+  Cancellation and ended delegation stop the wait, refusals remain terminal, and a call is sent
+  only once access is ready. An exhausted wait reports `readiness_timeout`, distinct from the
+  tool's execution timeout. The same readiness handling applies when renewing an application token.
 - **Application access timeouts no longer become `access_unavailable`.** Platform transport
   timeouts retain their classification and time limit when application access is obtained or
   renewed. The tool reports `failure: timeout` with `phase: access`; HTTP 408/504 responses

{ms_tau_sdk-2.0.10.dev50 → ms_tau_sdk-2.0.11.dev52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ms-tau-sdk
-Version: 2.0.10.dev50
+Version: 2.0.11.dev52
 Summary: Workspace-bound Tau application primitives for Main Sequence projects
 Project-URL: Changelog, https://github.com/mainsequence-sdk/ms-tau-sdk/blob/development/CHANGELOG.md
 Project-URL: Documentation, https://github.com/mainsequence-sdk/ms-tau-sdk/tree/development/docs

{ms_tau_sdk-2.0.10.dev50 → ms_tau_sdk-2.0.11.dev52}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ms-tau-sdk"
-version = "2.0.10.dev50"
+version = "2.0.11.dev52"
 description = "Workspace-bound Tau application primitives for Main Sequence projects"
 readme = "README.md"
 requires-python = ">=3.13"

{ms_tau_sdk-2.0.10.dev50 → ms_tau_sdk-2.0.11.dev52}/src/ms_tau_sdk/agent_skills/tau_project_customization/SKILL.md

@@ -91,6 +91,11 @@ the application's tool, not in the Agent. A tool that declares nothing gets
 `harness_agent.spec.env_vars`, the process environment, or
 `TauSDKSettings(mcp_tool_timeout_seconds=...)`. No call outlives its turn.
 
+Before MCP opens, an application's access may be `waking`. Tau waits according to the platform's
+retry guidance for up to `TAU_MCP_APPLICATION_READY_TIMEOUT_SECONDS` (default `120`) or the remaining
+turn time. This startup budget is separate from the tool's execution limit; an expired readiness
+wait reports `readiness_timeout`. Cancellation, ended delegation and terminal refusals stop the wait.
+
 ## Invariants extensions must not replace
 
 Extensions may change effective agent capabilities, but they must not replace or bypass:

{ms_tau_sdk-2.0.10.dev50 → ms_tau_sdk-2.0.11.dev52}/src/ms_tau_sdk/backend/mcp.py

@@ -4,14 +4,20 @@ from __future__ import annotations
 
 import asyncio
 import contextvars
-from collections.abc import AsyncGenerator
+import math
+from collections.abc import AsyncGenerator, AsyncIterator, Callable
+from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from datetime import timedelta
-from typing import Any, Literal, Self
+from typing import Any, Literal, Self, cast
 
+import anyio
 import httpx
+from anyio.abc import ObjectSendStream
+from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 from mcp import ClientSession, types
-from mcp.client.streamable_http import streamable_http_client
+from mcp.client.streamable_http import RequestContext, StreamableHTTPTransport
+from mcp.shared.message import SessionMessage
 from pydantic import AnyUrl
 from structlog.contextvars import bound_contextvars, get_contextvars
 
@@ -47,6 +53,145 @@ class _RuntimeCredentialHTTPXAuth(httpx.Auth):
             yield request
 
 
+@dataclass
+class _ToolCall:
+    cancel_scope: anyio.CancelScope
+    request_id: types.RequestId | None = None
+    http_cancel_scope: anyio.CancelScope | None = None
+    finished: bool = False
+
+    def cancel_if_abandoned(self, result: asyncio.Future[Any]) -> None:
+        if result.cancelled():
+            self.cancel_scope.cancel()
+
+    def finish(self) -> None:
+        self.finished = True
+        if self.http_cancel_scope is not None:
+            self.http_cancel_scope.cancel()
+
+
+_tool_call: contextvars.ContextVar[_ToolCall | None] = contextvars.ContextVar(
+    "mcp_tool_call", default=None
+)
+
+
+class _ToolCallWriteStream(ObjectSendStream[SessionMessage]):
+    """Associate the session's request ID with its call before the transport sends it.
+
+    MCP's HTTP writer runs in another task, so the calling task's context does not reach its
+    requests. Keep this association local to the connection, without adding anything to the wire.
+    """
+
+    def __init__(
+        self,
+        stream: MemoryObjectSendStream[SessionMessage],
+        calls: dict[types.RequestId, _ToolCall],
+    ) -> None:
+        self._stream = stream
+        self._calls = calls
+
+    async def send(self, item: SessionMessage) -> None:
+        message = item.message.root
+        call = _tool_call.get()
+        if (
+            call is not None
+            and isinstance(message, types.JSONRPCRequest)
+            and message.method == "tools/call"
+        ):
+            call.request_id = message.id
+            self._calls[message.id] = call
+        await self._stream.send(item)
+
+    async def aclose(self) -> None:
+        await self._stream.aclose()
+
+
+class _ToolCallTransport(StreamableHTTPTransport):
+    """Give each call's POST a cancellation scope inside MCP's transport task.
+
+    Cancelling that task directly cancels MCP's whole task group. A local scope releases the
+    response socket when its call ends while leaving other requests and the connection alive.
+    """
+
+    def __init__(self, url: str, calls: dict[types.RequestId, _ToolCall]) -> None:
+        super().__init__(url)
+        self._calls = calls
+
+    async def _handle_post_request(self, ctx: RequestContext) -> None:
+        message = ctx.session_message.message.root
+        call = (
+            self._calls.get(message.id)
+            if isinstance(message, types.JSONRPCRequest) and message.method == "tools/call"
+            else None
+        )
+        if call is None:
+            await super()._handle_post_request(ctx)
+            return
+
+        try:
+            with anyio.CancelScope() as http_cancel_scope:
+                call.http_cancel_scope = http_cancel_scope
+                if call.finished:
+                    http_cancel_scope.cancel()
+                await super()._handle_post_request(ctx)
+        finally:
+            if call.request_id is not None:
+                self._calls.pop(call.request_id, None)
+
+
+@asynccontextmanager
+async def streamable_http_client(
+    url: str,
+    *,
+    http_client: httpx.AsyncClient,
+    calls: dict[types.RequestId, _ToolCall],
+    terminate_on_close: bool = False,
+) -> AsyncIterator[
+    tuple[
+        MemoryObjectReceiveStream[SessionMessage | Exception],
+        MemoryObjectSendStream[SessionMessage],
+        Callable[[], str | None],
+    ]
+]:
+    """Use MCP's HTTP readers/writer with call-scoped POST cancellation.
+
+    The upstream factory constructs its transport internally without an injection point.
+    Preserve its stream/task-group lifecycle while selecting our transport specialization.
+    """
+    read_writer, read_stream = anyio.create_memory_object_stream[SessionMessage | Exception](0)
+    write_stream, write_reader = anyio.create_memory_object_stream[SessionMessage](0)
+    transport = _ToolCallTransport(url, calls)
+    async with anyio.create_task_group() as task_group:
+        try:
+
+            def start_get_stream() -> None:
+                task_group.start_soon(transport.handle_get_stream, http_client, read_writer)
+
+            task_group.start_soon(
+                transport.post_writer,
+                http_client,
+                write_reader,
+                read_writer,
+                write_stream,
+                start_get_stream,
+                task_group,
+            )
+            try:
+                yield read_stream, write_stream, transport.get_session_id
+            finally:
+                if terminate_on_close:
+                    await transport.terminate_session(http_client)
+                task_group.cancel_scope.cancel()
+        finally:
+            await read_writer.aclose()
+            await write_stream.aclose()
+
+
+def _validate_response_timeout(seconds: float) -> None:
+    if isinstance(seconds, bool) or not math.isfinite(seconds) or seconds <= 0:
+        raise ValueError("MCP response timeout must be finite and greater than zero")
+
+
 @dataclass(frozen=True)
 class _CallToolCommand:
     name: str
@@ -101,6 +246,7 @@ class MCPConnectionClient:
         read_timeout_seconds: float,
         read_concurrency: int,
     ) -> None:
+        _validate_response_timeout(read_timeout_seconds)
         self.name = name
         self.display_name = display_name
         self.url = url
@@ -115,6 +261,7 @@ class MCPConnectionClient:
         # The results of the calls already handed to the session, so that a failed connection
         # ends them as well as the calls still queued.
         self._in_flight: set[asyncio.Future[Any]] = set()
+        self._http_calls: dict[types.RequestId, _ToolCall] = {}
         self.tools: tuple[types.Tool, ...] = ()
         self.resources: tuple[types.Resource, ...] = ()
         self._parallel_tool_names: frozenset[str] = frozenset()
@@ -156,15 +303,21 @@ class MCPConnectionClient:
             async with httpx.AsyncClient(
                 timeout=self._http_timeout,
                 auth=self._http_auth,
+                event_hooks={"request": [self._prepare_tool_request]},
             ) as http_client:
                 async with streamable_http_client(
                     self.url,
                     http_client=http_client,
+                    calls=self._http_calls,
                     terminate_on_close=False,
                 ) as (read_stream, write_stream, _get_session_id):
                     async with ClientSession(
                         read_stream,
-                        write_stream,
+                        # MCP annotates this as a memory stream, but uses only send/aclose.
+                        cast(
+                            MemoryObjectSendStream[SessionMessage],
+                            _ToolCallWriteStream(write_stream, self._http_calls),
+                        ),
                         read_timeout_seconds=timedelta(seconds=self._read_timeout_seconds),
                     ) as session:
                         with bound_contextvars(**initial_log_context):
@@ -194,6 +347,20 @@ class MCPConnectionClient:
             self._fail_pending_commands(
                 failure or RuntimeError(f"{self.display_name} MCP client closed")
             )
+            self._http_calls.clear()
+
+    async def _prepare_tool_request(self, request: httpx.Request) -> None:
+        if request.method != "POST":
+            return
+        message = types.JSONRPCMessage.model_validate_json(request.content).root
+        if (
+            isinstance(message, types.JSONRPCRequest)
+            and message.method == "tools/call"
+            and message.id in self._http_calls
+        ):
+            # Only this response read follows the finite call deadline. Keep the request's
+            # connect/write/pool limits, without mutating the shared HTTP client defaults.
+            request.extensions["timeout"] = {**request.extensions["timeout"], "read": None}
 
     async def _read_server_catalog(
         self,
@@ -219,25 +386,38 @@ class MCPConnectionClient:
         read_slots = asyncio.Semaphore(self._read_concurrency)
 
         async def execute(command: _CallToolCommand | _ReadResourceCommand) -> None:
+            if command.result.cancelled():
+                return
             self._in_flight.add(command.result)
             try:
                 with bound_contextvars(**command.log_context):
                     if isinstance(command, _CallToolCommand):
-                        if command.timeout_seconds is None:
-                            tool_result = await session.call_tool(
-                                command.name,
-                                command.arguments,
-                                meta=command.meta,
-                            )
-                        else:
-                            tool_result = await session.call_tool(
-                                command.name,
-                                command.arguments,
-                                read_timeout_seconds=timedelta(seconds=command.timeout_seconds),
-                                meta=command.meta,
-                            )
-                        if not command.result.done():
-                            command.result.set_result(tool_result)
+                        with anyio.CancelScope() as cancel_scope:
+                            call = _ToolCall(cancel_scope)
+                            token = _tool_call.set(call)
+                            command.result.add_done_callback(call.cancel_if_abandoned)
+                            try:
+                                if command.timeout_seconds is None:
+                                    tool_result = await session.call_tool(
+                                        command.name,
+                                        command.arguments,
+                                        meta=command.meta,
+                                    )
+                                else:
+                                    tool_result = await session.call_tool(
+                                        command.name,
+                                        command.arguments,
+                                        read_timeout_seconds=timedelta(
+                                            seconds=command.timeout_seconds
+                                        ),
+                                        meta=command.meta,
+                                    )
+                                if not command.result.done():
+                                    command.result.set_result(tool_result)
+                            finally:
+                                command.result.remove_done_callback(call.cancel_if_abandoned)
+                                _tool_call.reset(token)
+                                call.finish()
                     else:
                         resource_result = await session.read_resource(AnyUrl(command.uri))
                         if not command.result.done():
@@ -313,8 +493,16 @@ class MCPConnectionClient:
         meta: dict[str, object] | None = None,
         timeout_seconds: float | None = None,
     ) -> types.CallToolResult:
-        """Call one tool; ``timeout_seconds`` replaces the session's wait for its answer."""
+        """Wait for one tool's answer within its finite, positive per-call response deadline.
+
+        The deadline starts when the queued call reaches the MCP session and replaces the
+        session's default response wait. HTTP read inactivity does not shorten it; connect,
+        write and pool limits still apply. Timeout or cancellation never replays the call and
+        does not establish whether its remote work completed.
+        """
 
+        if timeout_seconds is not None:
+            _validate_response_timeout(timeout_seconds)
         commands = self._require_commands()
         result: asyncio.Future[types.CallToolResult] = asyncio.get_running_loop().create_future()
         commands.put_nowait(

{ms_tau_sdk-2.0.10.dev50 → ms_tau_sdk-2.0.11.dev52}/src/ms_tau_sdk/errors.py

@@ -45,6 +45,22 @@ class BackendTimeoutError(BackendError):
         self.timeout_seconds = timeout_seconds
 
 
+class ApplicationWakingError(BackendError):
+    """The platform accepted access resolution but the application is still starting."""
+
+    def __init__(self, *, retry_after_seconds: float) -> None:
+        super().__init__("Application is waking", detail={"runtime_access_state": "waking"})
+        self.retry_after_seconds = retry_after_seconds
+
+
+class ApplicationReadinessTimeoutError(BackendError):
+    """An application's bounded readiness wait ended before access became ready."""
+
+    def __init__(self, *, timeout_seconds: float) -> None:
+        super().__init__("Application did not become ready")
+        self.timeout_seconds = timeout_seconds
+
+
 class LeaseLostError(TauSDKError):
     code = "runtime_lease_lost"
     status_code = 409

{ms_tau_sdk-2.0.10.dev50 → ms_tau_sdk-2.0.11.dev52}/src/ms_tau_sdk/runtime/requester.py

@@ -16,6 +16,7 @@ credential or an application token to the tool, and a turn's delegation ends wit
 from __future__ import annotations
 
 import asyncio
+import math
 import time
 import uuid
 from collections.abc import Awaitable, Callable, Mapping
@@ -30,7 +31,13 @@ import structlog
 from ms_tau_sdk.backend.auth import AccessToken, _jwt_expiry
 from ms_tau_sdk.backend.client import LeaseProof, answer_without_request_credentials
 from ms_tau_sdk.backend.models import ReleaseRuntimeAccess
-from ms_tau_sdk.errors import BackendError, BackendTimeoutError, TauSDKError
+from ms_tau_sdk.errors import (
+    ApplicationReadinessTimeoutError,
+    ApplicationWakingError,
+    BackendError,
+    BackendTimeoutError,
+    TauSDKError,
+)
 
 logger = structlog.get_logger(__name__)
 
@@ -569,7 +576,12 @@ def _current_turn_binding() -> TurnRequesterBinding | None:
     return _TURN_BINDING.get()
 
 
-async def _turn_application_access(release_uid: str) -> _TurnApplicationAccess:
+async def _turn_application_access(
+    release_uid: str,
+    *,
+    ready_timeout_seconds: float = 120,
+    cancelled: Callable[[], bool] | None = None,
+) -> _TurnApplicationAccess:
     """SDK-private: the current turn's access to one application.
 
     The token acts for the person the turn serves, when it serves one, and is the Agent's own
@@ -579,12 +591,75 @@ async def _turn_application_access(release_uid: str) -> _TurnApplicationAccess:
     binding = _TURN_BINDING.get()
     if binding is None:
         raise RuntimeError("Application tools run only inside a turn")
+    if not binding.active:
+        raise RequesterBindingError("The turn ended while obtaining application access.")
     uid = _canonical_uid(release_uid)
     delegate = binding.serving
-    access = await binding._release_access_for(uid, refresh=False, delegate=delegate)
+
+    async def resolve(*, refresh: bool) -> _ReleaseAccess:
+        # Capture delegation once, including for renewal; an ended turn never falls back to the
+        # Agent's own access. Each poll reacquires the binding lock and current lease proof.
+        started = asyncio.get_running_loop().time()
+        deadline = asyncio.timeout(None)
+        waiting = False
+        try:
+            async with deadline:
+                while True:
+                    if not binding.active:
+                        raise RequesterBindingError(
+                            "The turn ended while obtaining application access."
+                        )
+                    try:
+                        access = await binding._release_access_for(
+                            uid, refresh=refresh, delegate=delegate
+                        )
+                    except ApplicationWakingError as error:
+                        if not waiting:
+                            waiting = True
+                            deadline.reschedule(started + ready_timeout_seconds)
+                        logger.info(
+                            "runtime.application_access.waiting",
+                            resource_release_uid=uid,
+                            runtime_access_state="waking",
+                            retry_after_seconds=error.retry_after_seconds,
+                        )
+                        await asyncio.sleep(error.retry_after_seconds)
+                    else:
+                        if waiting:
+                            logger.info(
+                                "runtime.application_access.ready", resource_release_uid=uid
+                            )
+                        return access
+        except TimeoutError:
+            if not deadline.expired():
+                raise
+        # No transport error or credential-bearing exception is retained as the cause.
+        raise ApplicationReadinessTimeoutError(timeout_seconds=ready_timeout_seconds)
+
+    async def obtain(*, refresh: bool) -> _ReleaseAccess:
+        # ToolCancellationToken exposes only is_cancelled(). Poll it while both the readiness
+        # delay and the platform request are pending, and join cancelled work before returning.
+        task = asyncio.create_task(resolve(refresh=refresh))
+        try:
+            while True:
+                if not binding.active:
+                    raise RequesterBindingError(
+                        "The turn ended while obtaining application access."
+                    )
+                if cancelled is not None and cancelled():
+                    raise asyncio.CancelledError
+                if task.done():
+                    return task.result()
+                await asyncio.wait({task}, timeout=0.1)
+        finally:
+            if not task.done():
+                task.cancel()
+            await asyncio.gather(task, return_exceptions=True)
+
+    access = await obtain(refresh=False)
 
     async def renew() -> str:
-        return (await binding._release_access_for(uid, refresh=True, delegate=delegate)).token.value
+        return (await obtain(refresh=True)).token.value
 
     return _TurnApplicationAccess(rpc_url=access.rpc_url, token=access.token.value, renew=renew)
 
@@ -660,6 +735,17 @@ def _token_access(answer: ReleaseRuntimeAccess) -> _ReleaseAccess:
     grant = answer.access
     if grant is None:
         state = answer.runtime_access.get("state")
+        if state == "waking":
+            retry_ms = answer.runtime_access.get("retry_after_ms")
+            delay = 2.0
+            if isinstance(retry_ms, int | float) and not isinstance(retry_ms, bool):
+                try:
+                    seconds = float(retry_ms) / 1000
+                except OverflowError:
+                    seconds = float("inf")
+                if math.isfinite(seconds) and seconds >= 0:
+                    delay = max(seconds, 0.1)
+            raise ApplicationWakingError(retry_after_seconds=delay)
         raise BackendError(
             f"Release {answer.resource_release_uid} is not ready to be called"
             + (f" (runtime access: {state})" if isinstance(state, str) else ""),

{ms_tau_sdk-2.0.10.dev50 → ms_tau_sdk-2.0.11.dev52}/src/ms_tau_sdk/settings.py

@@ -220,6 +220,7 @@ class TauSDKSettings(BaseSettings):
     backend_read_timeout_seconds: float = Field(
         default=60.0,
         gt=0,
+        allow_inf_nan=False,
         validation_alias="MAINSEQUENCE_TAU_BACKEND_READ_TIMEOUT_SECONDS",
     )
     backend_write_timeout_seconds: float = Field(
@@ -248,6 +249,12 @@ class TauSDKSettings(BaseSettings):
         gt=0,
         validation_alias="TAU_MCP_TOOL_TIMEOUT_SECONDS",
     )
+    mcp_application_ready_timeout_seconds: float = Field(
+        default=120.0,
+        gt=0,
+        allow_inf_nan=False,
+        validation_alias="TAU_MCP_APPLICATION_READY_TIMEOUT_SECONDS",
+    )
     backend_max_response_bytes: int = Field(
         default=10 * 1024 * 1024,
         gt=0,

{ms_tau_sdk-2.0.10.dev50 → ms_tau_sdk-2.0.11.dev52}/src/ms_tau_sdk/tools/mcp_applications.py

@@ -19,7 +19,8 @@ from __future__ import annotations
 import json
 import math
 import re
-from collections.abc import AsyncGenerator, Awaitable, Callable, Mapping, Sequence
+from collections.abc import AsyncGenerator, Mapping, Sequence
+from typing import Protocol
 
 import httpx
 import structlog
@@ -35,7 +36,13 @@ from tau_agent.types import JSONValue
 
 from ms_tau_sdk.backend.mcp import MCPConnectionClient
 from ms_tau_sdk.backend.models import MCPApplication
-from ms_tau_sdk.errors import BackendError, BackendTimeoutError, ConfigurationError
+from ms_tau_sdk.errors import (
+    ApplicationReadinessTimeoutError,
+    ApplicationWakingError,
+    BackendError,
+    BackendTimeoutError,
+    ConfigurationError,
+)
 from ms_tau_sdk.runtime.requester import (
     RequesterBindingError,
     _turn_application_access,
@@ -52,7 +59,11 @@ _RESERVED_NAMES = frozenset({"mainsequence"})
 TIMEOUT_META_KEY = "mainsequence.ai/timeout-seconds/v1"
 """The ``_meta`` key under which an application tool declares how long it may run, in seconds."""
 
-type ApplicationConnector = Callable[[MCPApplication], Awaitable[MCPConnectionClient]]
+
+class ApplicationConnector(Protocol):
+    async def __call__(
+        self, application: MCPApplication, *, signal: ToolCancellationToken | None = None
+    ) -> MCPConnectionClient: ...
 
 
 class _ApplicationTokenAuth(httpx.Auth):
@@ -77,18 +88,24 @@ class _ApplicationTokenAuth(httpx.Auth):
 def application_connector(settings: TauSDKSettings) -> ApplicationConnector:
     """Open an MCP session to one application for the current turn."""
 
-    async def connect(application: MCPApplication) -> MCPConnectionClient:
-        access = await _turn_application_access(application.resource_release_uid)
+    async def connect(
+        application: MCPApplication, *, signal: ToolCancellationToken | None = None
+    ) -> MCPConnectionClient:
+        access = await _turn_application_access(
+            application.resource_release_uid,
+            ready_timeout_seconds=settings.mcp_application_ready_timeout_seconds,
+            cancelled=signal.is_cancelled if signal is not None else None,
+        )
         return await MCPConnectionClient(
             name=application.name,
             display_name=application.name,
             url=f"{str(access.rpc_url).rstrip('/')}/mcp",
             auth=_ApplicationTokenAuth(access),
-            # The session's wait bounds each request: the backend read timeout while the session
-            # opens, the tool's own limit for the call. The HTTP read wait never cuts a call short.
+            # The connection applies the tool's response deadline to its call; these HTTP limits
+            # also bound initialization and catalog requests.
             timeout=httpx.Timeout(
                 connect=settings.backend_connect_timeout_seconds,
-                read=settings.turn_timeout_seconds,
+                read=settings.backend_read_timeout_seconds,
                 write=settings.backend_write_timeout_seconds,
                 pool=settings.backend_pool_timeout_seconds,
             ),
@@ -118,6 +135,23 @@ def _failure(
 
     if isinstance(error, RequesterBindingError):
         return "Your access for this request ended.", {"failure": "access_ended"}
+    if isinstance(error, ApplicationReadinessTimeoutError):
+        return (
+            f"The {name} application did not become ready within "
+            f"{error.timeout_seconds:g} seconds. "
+            "It is still starting; try again shortly.",
+            {
+                "failure": "readiness_timeout",
+                "phase": "readiness",
+                "runtime_access_state": "waking",
+                "timeout_seconds": error.timeout_seconds,
+            },
+        )
+    if isinstance(error, ApplicationWakingError):
+        return (
+            f"The {name} application is still starting; try again shortly.",
+            {"failure": "not_ready", "phase": "readiness", "runtime_access_state": "waking"},
+        )
     if isinstance(error, BackendError):
         if isinstance(error, BackendTimeoutError) or error.backend_status in {408, 504}:
             details: dict[str, JSONValue] = {"failure": "timeout", "phase": "access"}
@@ -217,7 +251,7 @@ def _application_tools(
     async def open_session(signal: ToolCancellationToken | None) -> MCPConnectionClient:
         # Nothing has reached a tool while the session opens, so one more attempt is safe.
         try:
-            return await connect(application)
+            return await connect(application, signal=signal)
         except Exception as error:
             if not _retryable(error) or (signal is not None and signal.is_cancelled()):
                 raise
@@ -226,7 +260,7 @@ def _application_tools(
                 application=name,
                 error_type=type(error).__name__,
             )
-        return await connect(application)
+        return await connect(application, signal=signal)
 
     def failed(
         operation: str,