revert(proxy): drop overfit Caido reconnect/HTTPQL band-aids, keep serialization lock (#799)

Co-authored-by: Ahmed Allam <ahmed39652003@gmail.com>

strix/runtime/caido_bootstrap.py

@@ -80,72 +80,30 @@ async def _login_as_guest(
     raise RuntimeError(f"loginAsGuest failed after {attempts} attempts: {last_err}")
 
 
-async def _aclose_quietly(client: Client) -> None:
-    """Best-effort close of a client whose setup failed; never raises."""
-    with contextlib.suppress(Exception):
-        await client.aclose()
-
-
-async def _connect_client(
-    session: BaseSandboxSession,
-    *,
-    host_url: str,
-    container_url: str,
-) -> Client:
-    access_token = await _login_as_guest(session, container_url=container_url)
-    client = Client(host_url, auth=TokenAuthOptions(token=access_token))
-    await client.connect()
-    return client
-
-
 async def bootstrap_caido(
     session: BaseSandboxSession,
     *,
     host_url: str,
     container_url: str,
-) -> tuple[Client, str]:
-    """Connect to the in-container Caido sidecar and select a fresh project.
-
-    Returns the connected client and the id of the temporary project it
-    selected. The project id lets :func:`reconnect_caido` rebuild a dead
-    transport while staying on the *same* project (and its captured traffic)
-    instead of creating a new empty one.
-    """
+) -> Client:
+    """Connect to the in-container Caido sidecar and select a fresh project."""
     logger.info("Bootstrapping Caido client (host=%s, container=%s)", host_url, container_url)
 
-    client = await _connect_client(session, host_url=host_url, container_url=container_url)
+    access_token = await _login_as_guest(session, container_url=container_url)
+
+    client = Client(host_url, auth=TokenAuthOptions(token=access_token))
+    await client.connect()
+
     try:
         project = await client.project.create(
             CreateProjectOptions(name="sandbox", temporary=True),
         )
         await client.project.select(project.id)
     except BaseException:
-        # Don't leak the connected transport if project setup fails.
-        await _aclose_quietly(client)
+        # The connected client never reaches the session bundle if project
+        # setup fails, so close it here to avoid leaking the transport.
+        with contextlib.suppress(Exception):
+            await client.aclose()
         raise
     logger.info("Caido project selected: %s", project.id)
-    return client, str(project.id)
-
-
-async def reconnect_caido(
-    session: BaseSandboxSession,
-    *,
-    host_url: str,
-    container_url: str,
-    project_id: str,
-) -> Client:
-    """Rebuild a Caido client after its transport died, keeping the project.
-
-    Re-authenticates, reconnects, and re-selects the existing project so the
-    caller keeps access to the traffic captured before the disconnect.
-    """
-    logger.info("Reconnecting Caido client (host=%s, project=%s)", host_url, project_id)
-    client = await _connect_client(session, host_url=host_url, container_url=container_url)
-    try:
-        await client.project.select(project_id)
-    except BaseException:
-        # A missing/unavailable project must not leave the freshly-connected
-        # transport dangling — otherwise every retry leaks another one.
-        await _aclose_quietly(client)
-        raise
     return client

strix/runtime/session_manager.py

@@ -5,20 +5,15 @@ from __future__ import annotations
 import logging
 import shutil
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from agents.sandbox.entries import BaseEntry, LocalDir
 from agents.sandbox.manifest import Environment, Manifest
 
 from strix.config import load_settings
 from strix.runtime.backends import get_backend
-from strix.runtime.caido_bootstrap import bootstrap_caido, reconnect_caido
+from strix.runtime.caido_bootstrap import bootstrap_caido
 from strix.runtime.local_dir_staging import stage_symlink_safe_dir
-from strix.tools.proxy.caido_api import SharedCaidoClient
-
-
-if TYPE_CHECKING:
-    from caido_sdk_client import Client as CaidoClient
 
 
 logger = logging.getLogger(__name__)
@@ -136,24 +131,16 @@ async def create_or_reuse(
     host_caido_url = f"{scheme}://{caido_endpoint.host}:{caido_endpoint.port}"
     logger.debug("Caido host endpoint resolved: %s", host_caido_url)
 
-    caido_client, caido_project_id = await bootstrap_caido(
+    caido_client = await bootstrap_caido(
         session,
         host_url=host_caido_url,
         container_url=container_caido_url,
     )
 
-    async def _reconnect_caido() -> CaidoClient:
-        return await reconnect_caido(
-            session,
-            host_url=host_caido_url,
-            container_url=container_caido_url,
-            project_id=caido_project_id,
-        )
-
     bundle = {
         "client": client,
         "session": session,
-        "caido_client": SharedCaidoClient(caido_client, _reconnect_caido),
+        "caido_client": caido_client,
     }
     _SESSION_CACHE[scan_id] = bundle
     logger.info("Sandbox session for scan %s ready and cached", scan_id)