feat: cancel sandbox creation on user interrupt

Sandbox.create() now accepts a cancel_event checked during polling loops.
When set, the partially-created Space is deleted and Sandbox.Cancelled is
raised. _ensure_sandbox bridges the asyncio cancel signal to a threading
event so the blocking create call can respond within ~5s.

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

agent/tools/sandbox_client.py

@@ -287,6 +287,9 @@ class Sandbox:
 
     # ── Lifecycle ─────────────────────────────────────────────────
 
+    class Cancelled(Exception):
+        """Raised when sandbox creation is cancelled by the user."""
+
     @classmethod
     def create(
         cls,
@@ -300,6 +303,7 @@ class Sandbox:
         token: str | None = None,
         wait_timeout: int = WAIT_TIMEOUT,
         log: "Callable[[str], object] | None" = None,
+        cancel_event: "Any | None" = None,
     ) -> Sandbox:
         """
         Create a new sandbox by duplicating the template Space.
@@ -317,6 +321,9 @@ class Sandbox:
             sleep_time: Auto-sleep after N seconds of inactivity.
             token: HF API token (from user's OAuth session).
             wait_timeout: Max seconds to wait for Space to start (default: 300).
+            cancel_event: A threading.Event (or compatible) checked during
+                          polling loops.  When set, the Space is deleted and
+                          Sandbox.Cancelled is raised.
 
         Returns:
             A Sandbox instance connected to the running Space.
@@ -324,6 +331,16 @@ class Sandbox:
         _log = log or print
         api = HfApi(token=token)
 
+        def _check_cancel():
+            if cancel_event and cancel_event.is_set():
+                _log("Sandbox creation cancelled by user, cleaning up...")
+                try:
+                    api.delete_repo(space_id, repo_type="space")
+                    _log(f"Deleted Space {space_id}")
+                except Exception:
+                    pass
+                raise cls.Cancelled(f"Sandbox creation cancelled: {space_id}")
+
         base = name or "sandbox"
         suffix = uuid.uuid4().hex[:8]
         space_id = f"{owner}/{base}-{suffix}"
@@ -342,13 +359,18 @@ class Sandbox:
         api.duplicate_space(**kwargs)
         _log(f"Space created: https://huggingface.co/spaces/{space_id}")
 
+        _check_cancel()
+
         # Upload sandbox server and Dockerfile (triggers rebuild)
         cls._setup_server(space_id, api, log=_log)
 
+        _check_cancel()
+
         # Wait for it to come online (rebuild + start)
         _log(f"Waiting for Space to start (timeout: {wait_timeout}s)...")
         deadline = time.time() + wait_timeout
         while time.time() < deadline:
+            _check_cancel()
             runtime = api.get_space_runtime(space_id)
             if runtime.stage == "RUNNING":
                 _log(f"Space is running (hardware: {runtime.hardware})")
@@ -366,6 +388,8 @@ class Sandbox:
                 f"Check https://huggingface.co/spaces/{space_id}"
             )
 
+        _check_cancel()
+
         # Wait for the API server to be responsive (non-fatal)
         sb = cls(space_id=space_id, token=token, _owns_space=True)
         try:

agent/tools/sandbox_tool.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 import asyncio
 import shlex
+import threading
 from typing import Any
 
 from huggingface_hub import HfApi, SpaceHardware
@@ -103,16 +104,33 @@ async def _ensure_sandbox(
             Event(event_type="tool_log", data={"tool": "sandbox", "log": msg}),
         )
 
+    # Bridge asyncio cancel event to a threading.Event for the blocking create call.
+    # We poll session._cancelled from the main loop in a background task and set
+    # a threading.Event that Sandbox.create checks during its polling loops.
+    cancel_flag = threading.Event()
+
+    async def _watch_cancel():
+        await session._cancelled.wait()
+        cancel_flag.set()
+
+    watcher_task = asyncio.create_task(_watch_cancel())
+
     kwargs = {
         "owner": owner,
         "hardware": hardware,
         "token": token,
         "log": _log,
+        "cancel_event": cancel_flag,
         **create_kwargs,
     }
     if hardware != "cpu-basic":
         kwargs["sleep_time"] = 2700
-    sb = await asyncio.to_thread(Sandbox.create, **kwargs)
+    try:
+        sb = await asyncio.to_thread(Sandbox.create, **kwargs)
+    except Sandbox.Cancelled:
+        return None, "Sandbox creation cancelled by user."
+    finally:
+        watcher_task.cancel()
     session.sandbox = sb
 
     # Set a descriptive title (template title is inherited on duplicate)