Drop the sync client's socket-level wait deadlines

Interrupting an in-flight HTTPX request needed a timer thread that shut
down sockets through trace hooks, with special cases for shared HTTP/2
connections, TLS stream swaps and trickled responses, plus deadline-aware
copies of the token refresh and control request paths.

The sync secret process wait now checks its limit between requests and
caps each request's HTTP timeouts at the time left, like the async
client's transport. A trickled response or a token refresh can overrun
the limit; the README points to the async client for a strict one. The
control request path is back to master's.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: AHarmlessPyro

README.md

@@ -331,9 +331,9 @@ Things to know:
   the total local wait and raises `TimeoutError` (`asyncio.TimeoutError` for
   async handles); the process continues and the handle can be used to wait
   again. The start's timeout limits the command's execution separately.
-  For strict cancellation timing, use the async client: blocking DNS, custom
-  transports or hooks, shared HTTP/2 control connections, and trickled headers
-  on a reused control connection can delay cancellation in the sync client.
+  The sync client checks the limit between requests and caps each request's
+  HTTP timeouts at the time left, so a slow response or a runtime token
+  refresh can overrun it; use the async client for a strict limit.
 - A process start with secrets that times out, or whose result the API can't
   confirm, raises a non-retryable error with code
   `secret_process_outcome_unknown`: the command may be running, so check

hyperbrowser/client/managers/sync_manager/sandbox.py

@@ -2,8 +2,6 @@
 from pathlib import Path
 from typing import Dict, Optional, Union
 
-import httpx
-
 from ..._request import coerce_request, dump_request
 from ....exceptions import HyperbrowserError
 from ....models.sandbox import (
@@ -115,7 +113,7 @@
     SandboxTerminalConnection,
     SandboxTerminalHandle,
 )
-from .sandboxes.sandbox_transport import RuntimeTransport, _RequestDeadline
+from .sandboxes.sandbox_transport import RuntimeTransport
 
 __all__ = [
     "DEFAULT_PROCESS_KILL_WAIT_SECONDS",
@@ -144,7 +142,6 @@ def __init__(self, service: "SandboxManager", detail: SandboxDetail):
             self._resolve_runtime_connection,
             service.runtime_timeout,
             service.runtime_proxy_override,
-            self._resolve_runtime_connection_with_deadline,
         )
         self.processes = SandboxProcessesApi(
             self._transport,
@@ -294,11 +291,6 @@ def get_exposed_url(self, port: int) -> str:
 
     def create_runtime_session(
         self, force_refresh: bool = False
-    ) -> SandboxRuntimeSession:
-        return self._create_runtime_session(force_refresh)
-
-    def _create_runtime_session(
-        self, force_refresh: bool, deadline: Optional[float] = None
     ) -> SandboxRuntimeSession:
         self._assert_runtime_available()
         if (
@@ -308,11 +300,7 @@ def _create_runtime_session(
         ):
             return _copy_model(self._runtime_session)
 
-        detail = (
-            self._service.get_detail(self.id)
-            if deadline is None
-            else self._service._get_detail_with_deadline(self.id, deadline)
-        )
+        detail = self._service.get_detail(self.id)
         self._hydrate(detail)
         if self._runtime_session is None:
             raise HyperbrowserError(
@@ -383,16 +371,6 @@ def _resolve_runtime_socket_info(self) -> RuntimeConnection:
             token=session.token,
         )
 
-    def _resolve_runtime_connection_with_deadline(
-        self, force_refresh: bool, deadline: float
-    ) -> RuntimeConnection:
-        session = self._create_runtime_session(force_refresh, deadline)
-        return RuntimeConnection(
-            sandbox_id=self.id,
-            base_url=session.runtime.base_url,
-            token=session.token,
-        )
-
     def _apply_runtime_session(self, session: SandboxRuntimeSession) -> None:
         self._runtime_session = _copy_model(session)
         self._detail = self._detail.model_copy(
@@ -1092,14 +1070,6 @@ def get_detail(self, sandbox_id: str) -> SandboxDetail:
         payload = self._request("GET", f"/sandbox/{sandbox_id}")
         return SandboxDetail(**payload)
 
-    def _get_detail_with_deadline(
-        self, sandbox_id: str, deadline: float
-    ) -> SandboxDetail:
-        payload = self._request(
-            "GET", f"/sandbox/{sandbox_id}", request_deadline=deadline
-        )
-        return SandboxDetail(**payload)
-
     def attach(self, detail: SandboxDetail) -> SandboxHandle:
         return SandboxHandle(self, detail)
 
@@ -1203,38 +1173,22 @@ def _request(
         *,
         params: Optional[Dict[str, object]] = None,
         data: Optional[Dict[str, object]] = None,
-        request_deadline: Optional[float] = None,
     ):
         failed_attempt = 1
         while True:
             try:
-                request_params = {
-                    key: value
-                    for key, value in (params or {}).items()
-                    if value is not None
-                }
-                if request_deadline is None:
-                    response = self._client.transport.client.request(
-                        method,
-                        self._client._build_url(path),
-                        params=request_params,
-                        json=data,
-                    )
-                else:
-                    response = self._request_with_deadline(
-                        method, path, request_params, data, request_deadline
-                    )
+                response = self._client.transport.client.request(
+                    method,
+                    self._client._build_url(path),
+                    params={
+                        key: value
+                        for key, value in (params or {}).items()
+                        if value is not None
+                    },
+                    json=data,
+                )
                 ensure_response_ok(response, "control")
             except BaseException as cause:
-                if not isinstance(cause, Exception):
-                    raise
-                if (
-                    request_deadline is not None
-                    and time.monotonic() >= request_deadline
-                ):
-                    raise TimeoutError(
-                        "Timed out waiting for command output"
-                    ) from cause
                 error = normalize_network_error(
                     cause,
                     "control",
@@ -1243,39 +1197,8 @@ def _request(
                 )
                 if not should_retry_get(method, error, failed_attempt):
                     raise error
-                delay = get_retry_delay_seconds(failed_attempt)
-                if request_deadline is not None:
-                    delay = min(delay, max(0, request_deadline - time.monotonic()))
-                time.sleep(delay)
+                time.sleep(get_retry_delay_seconds(failed_attempt))
                 failed_attempt += 1
                 continue
 
             return parse_json_response(response, "control")
-
-    def _request_with_deadline(self, method, path, params, data, deadline):
-        budget = _RequestDeadline(deadline, shared_connection=True)
-        response = None
-        try:
-            client = self._client.transport.client
-            remaining = budget.remaining()
-            timeouts = {
-                key: min(value, remaining) if value is not None else remaining
-                for key, value in client.timeout.as_dict().items()
-            }
-            request = client.build_request(
-                method,
-                self._client._build_url(path),
-                params=params,
-                json=data,
-                timeout=httpx.Timeout(**timeouts),
-                extensions={"trace": budget.trace},
-            )
-            response = client.send(request, stream=True)
-            budget.capture_response(response)
-            response.read()
-            budget.remaining()
-            return response
-        finally:
-            budget.close()
-            if response is not None:
-                response.close()

hyperbrowser/client/managers/sync_manager/sandboxes/sandbox_processes.py

@@ -109,7 +109,7 @@ def _wait_with_secrets(
             chunk_ms, request_timeout, _ = wait.request_budget()
             started_at = time.monotonic()
             try:
-                result = self._wait_once(chunk_ms, None, request_timeout, wait.deadline)
+                result = self._wait_once(chunk_ms, None, request_timeout)
                 wait.remaining()
                 return result
             except TimeoutError as error:
@@ -133,13 +133,10 @@ def _wait_once(
         timeout_ms: Optional[int],
         timeout_sec: Optional[int],
         request_timeout: Optional[float] = None,
-        request_deadline: Optional[float] = None,
     ) -> SandboxProcessResult:
         request_options: Dict[str, Any] = {}
         if request_timeout is not None:
             request_options["request_timeout"] = request_timeout
-        if request_deadline is not None:
-            request_options["request_deadline"] = request_deadline
         payload = self._transport.request_json(
             f"/sandbox/processes/{self.id}/wait",
             method="POST",