Remove ~900 lines of dead code across agent, backend, and frontend (#318)

* Remove dead code across agent, backend, and frontend

A vulture/knip audit with manual repo-wide verification found ~900 lines
of dead code:

- Delete agent/tools/private_hf_repo_tools.py (650 lines): disabled when
hf_repo_files/hf_repo_git replaced it, never imported since.
- Drop orphaned functions, constants, and type aliases across agent/ and
backend/ (record_jobs_access_blocked, last_fetch_error,
update_local_save_status, verify_session_access, OperationType aliases,
OpType.INTERRUPT in both enums, etc.).
- Trim unused Sandbox client surface (pause/restart/to_dict/
tool_definitions and unused constants); keep Sandbox.connect, which the
live auth integration test uses.
- Remove production code only its own tests kept alive: _needs_approval
(tests retargeted to _base_needs_approval / production path),
fetch_hf_user_plan, _cleanup_user_orphan_sandboxes (superseded by
scripts/sweep_orphan_sandboxes.py), DEFAULT_MODEL_ID alias.
- Drop unused boto3 dependency (still available transitively via the
eval extra for inspect-ai).
- Frontend: delete unused ThinkingIndicator component, 12 orphaned event
payload interfaces, ToolApproval interface, and the duplicate theme
default export.

No behavior change. ruff, 485 unit tests, tsc build, and eslint all pass.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Drop stale INTERRUPT reference from agent README

Addresses PR #318 review: OpType.INTERRUPT no longer exists, so remove
it from the handled-operations list in the architecture notes.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

agent/README.md

@@ -7,7 +7,7 @@ Async agent loop with LiteLLM.
 **Queue-based async system:**
 - Submissions in (user input) → Agent Loop → Events output for possible UI updates
 - Session maintains state (context + tools) for possible future Context Engineering
-- Handlers operations like (USER_INPUT, INTERRUPT, COMPACT, UNDO, SHUTDOWN) for possible UI control
+- Handlers operations like (USER_INPUT, COMPACT, UNDO, SHUTDOWN) for possible UI control
 
 ## Components
 

agent/core/agent_loop.py

@@ -324,17 +324,6 @@ def _base_needs_approval(
     return False
 
 
-def _needs_approval(
-    tool_name: str, tool_args: dict, config: Config | None = None
-) -> bool:
-    """Legacy sync approval predicate used by tests and CLI display helpers."""
-    if _is_scheduled_hf_job_run(tool_name, tool_args):
-        return True
-    if config and config.yolo_mode:
-        return False
-    return _base_needs_approval(tool_name, tool_args, config)
-
-
 def _session_auto_approval_enabled(session: Session | None) -> bool:
     return bool(session and getattr(session, "auto_approval_enabled", False))
 

agent/core/hf_access.py

@@ -21,7 +21,6 @@ HF_BILLING_URL = "https://huggingface.co/settings/billing"
 HF_PRO_SUBSCRIBE_URL = "https://huggingface.co/subscribe/pro"
 
 HfUserPlan = Literal["free", "pro"]
-HfUserPlanStatus = Literal["free", "pro", "unknown"]
 
 
 @dataclass(frozen=True)
@@ -32,7 +31,6 @@ class JobsAccess:
     org_names: list[str]
     eligible_namespaces: list[str]
     default_namespace: str | None
-    access_known: bool = True
 
 
 class JobsAccessError(Exception):
@@ -126,17 +124,6 @@ async def fetch_whoami_v2(token: str, timeout: float = 5.0) -> dict[str, Any] |
             return None
 
 
-async def fetch_hf_user_plan(
-    token: str | None,
-    timeout: float = 5.0,
-) -> HfUserPlanStatus:
-    """Return the token owner's HF plan, or ``unknown`` if lookup fails."""
-    if not token:
-        return "unknown"
-    whoami = await fetch_whoami_v2(token, timeout=timeout)
-    return normalize_hf_user_plan(whoami) or "unknown"
-
-
 async def get_jobs_access(token: str) -> JobsAccess | None:
     whoami = await fetch_whoami_v2(token)
     if whoami is None:

agent/core/hf_router_catalog.py

@@ -7,7 +7,6 @@ pricing, context length, and tool-use support. We use it to:
   • Validate ``/model`` switches with live data instead of a hard-coded allowlist.
   • Show the user which providers serve a model, at what price, and whether they
     support tool calls.
-  • Derive a reasonable context-window limit for any routed model.
 
 The listing is cached in-memory for a few minutes so repeated lookups during a
 session are free. On fetch failure we return stale data if we have it, or an
@@ -42,7 +41,6 @@ class ProviderInfo:
     input_price: Optional[float]
     output_price: Optional[float]
     supports_tools: bool
-    supports_structured_output: bool
 
 
 @dataclass
@@ -54,11 +52,6 @@ class ModelInfo:
     def live_providers(self) -> list[ProviderInfo]:
         return [p for p in self.providers if p.status == "live"]
 
-    @property
-    def max_context_length(self) -> Optional[int]:
-        lengths = [p.context_length for p in self.live_providers if p.context_length]
-        return max(lengths) if lengths else None
-
     @property
     def any_supports_tools(self) -> bool:
         return any(p.supports_tools for p in self.live_providers)
@@ -97,9 +90,6 @@ def _parse_entry(entry: dict) -> ModelInfo:
                 input_price=pricing.get("input"),
                 output_price=pricing.get("output"),
                 supports_tools=bool(p.get("supports_tools", False)),
-                supports_structured_output=bool(
-                    p.get("supports_structured_output", False)
-                ),
             )
         )
     return ModelInfo(id=entry.get("id", ""), providers=providers)
@@ -119,10 +109,6 @@ def lookup(model_id: str) -> Optional[ModelInfo]:
     return None
 
 
-def last_fetch_error() -> Optional[str]:
-    return _last_fetch_error
-
-
 def fuzzy_suggest(model_id: str, limit: int = 3) -> list[str]:
     """Return the closest model ids from the catalog."""
     bare = model_id.split(":", 1)[0]

agent/core/model_ids.py

@@ -10,8 +10,6 @@ MINIMAX_M27_MODEL_ID = "MiniMaxAI/MiniMax-M2.7:novita"
 GLM_51_MODEL_ID = "zai-org/GLM-5.1:novita"
 DEEPSEEK_V4_PRO_MODEL_ID = "deepseek-ai/DeepSeek-V4-Pro:novita"
 
-DEFAULT_MODEL_ID = CLAUDE_OPUS_48_MODEL_ID
-
 HOSTED_MODEL_IDS = {
     CLAUDE_OPUS_48_MODEL_ID,
     GPT_55_MODEL_ID,

agent/core/session.py

@@ -80,7 +80,6 @@ def _get_max_tokens_safe(model_name: str) -> int:
 class OpType(Enum):
     USER_INPUT = "user_input"
     EXEC_APPROVAL = "exec_approval"
-    INTERRUPT = "interrupt"
     UNDO = "undo"
     COMPACT = "compact"
     NEW = "new"
@@ -631,26 +630,6 @@ class Session:
             logger.error(f"Failed to save session locally: {e}")
             return None
 
-    def update_local_save_status(
-        self, filepath: str, upload_status: str, dataset_url: Optional[str] = None
-    ) -> bool:
-        """Update the upload status of an existing local save file"""
-        try:
-            with open(filepath, "r") as f:
-                data = json.load(f)
-
-            data["upload_status"] = upload_status
-            data["upload_url"] = dataset_url
-            data["last_save_time"] = datetime.now().isoformat()
-
-            with open(filepath, "w") as f:
-                json.dump(data, f, indent=2)
-
-            return True
-        except Exception as e:
-            logger.error(f"Failed to update local save status: {e}")
-            return False
-
     def _personal_trace_repo_id(self) -> Optional[str]:
         """Resolve the per-user trace repo id from config + HF username.
 

agent/core/session_persistence.py

@@ -518,10 +518,3 @@ def get_session_store() -> NoopSessionStore | MongoSessionStore:
         db_name = os.environ.get("MONGODB_DB", "ml-intern")
         _store = MongoSessionStore(uri, db_name) if uri else NoopSessionStore()
     return _store
-
-
-def _reset_store_for_tests(
-    store: NoopSessionStore | MongoSessionStore | None = None,
-) -> None:
-    global _store
-    _store = store

agent/core/telemetry.py

@@ -326,30 +326,6 @@ async def record_feedback(
         logger.debug("record_feedback failed (non-fatal): %s", e)
 
 
-async def record_jobs_access_blocked(
-    session: Any,
-    *,
-    tool_call_ids: list[str],
-    plan: str,
-    eligible_namespaces: list[str],
-) -> None:
-    from agent.core.session import Event
-
-    try:
-        await session.send_event(
-            Event(
-                event_type="jobs_access_blocked",
-                data={
-                    "tool_call_ids": tool_call_ids,
-                    "plan": plan,
-                    "eligible_namespaces": eligible_namespaces,
-                },
-            )
-        )
-    except Exception as e:
-        logger.debug("record_jobs_access_blocked failed (non-fatal): %s", e)
-
-
 async def record_pro_cta_click(
     session: Any,
     *,

agent/core/tools.py

@@ -51,12 +51,6 @@ from agent.tools.research_tool import RESEARCH_TOOL_SPEC, research_handler
 from agent.tools.sandbox_tool import get_sandbox_tools
 from agent.tools.web_search_tool import WEB_SEARCH_TOOL_SPEC, web_search_handler
 
-# NOTE: Private HF repo tool disabled - replaced by hf_repo_files and hf_repo_git
-# from agent.tools.private_hf_repo_tools import (
-#     PRIVATE_HF_REPO_TOOL_SPEC,
-#     private_hf_repo_handler,
-# )
-
 # Suppress aiohttp deprecation warning
 warnings.filterwarnings(
     "ignore", category=DeprecationWarning, module="aiohttp.connector"

agent/core/usage_thresholds.py

@@ -1,13 +1,11 @@
 """Helpers for session usage-threshold approval warnings."""
 
-from typing import Any, Literal
+from typing import Any
 
 USAGE_THRESHOLD_TOOL_NAME = "usage_threshold"
 USAGE_WARNING_FIRST_THRESHOLD_USD = 5.0
 USAGE_WARNING_MULTIPLIER = 2.0
 
-UsageApprovalContinuation = Literal["continue_agent", "complete_turn"]
-
 
 def normalize_usage_threshold(value: Any) -> float:
     """Return a usable positive threshold, defaulting to the first warning."""

agent/tools/hf_repo_files_tool.py

@@ -5,7 +5,7 @@ Operations: list, read, upload, delete
 """
 
 import asyncio
-from typing import Any, Dict, Literal, Optional
+from typing import Any, Dict, Optional
 
 from huggingface_hub import HfApi, hf_hub_download
 from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError
@@ -13,8 +13,6 @@ from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError
 from agent.core.hub_artifacts import is_known_hub_artifact, register_hub_artifact
 from agent.tools.types import ToolResult
 
-OperationType = Literal["list", "read", "upload", "delete"]
-
 
 async def _async_call(func, *args, **kwargs):
     """Wrap synchronous HfApi calls for async context."""

agent/tools/hf_repo_git_tool.py

@@ -5,7 +5,7 @@ Operations: branches, tags, PRs, repo management
 """
 
 import asyncio
-from typing import Any, Dict, Literal, Optional
+from typing import Any, Dict, Optional
 
 from huggingface_hub import HfApi
 from huggingface_hub.utils import RepositoryNotFoundError
@@ -13,23 +13,6 @@ from huggingface_hub.utils import RepositoryNotFoundError
 from agent.core.hub_artifacts import register_hub_artifact
 from agent.tools.types import ToolResult
 
-OperationType = Literal[
-    "create_branch",
-    "delete_branch",
-    "create_tag",
-    "delete_tag",
-    "list_refs",
-    "create_pr",
-    "list_prs",
-    "get_pr",
-    "merge_pr",
-    "close_pr",
-    "comment_pr",
-    "change_pr_status",
-    "create_repo",
-    "update_repo",
-]
-
 
 async def _async_call(func, *args, **kwargs):
     """Wrap synchronous HfApi calls for async context."""

agent/tools/jobs_tool.py

@@ -10,7 +10,7 @@ import http.client
 import logging
 import re
 import shlex
-from typing import Any, Awaitable, Callable, Dict, Literal, Optional
+from typing import Any, Awaitable, Callable, Dict, Optional
 
 import httpx
 from huggingface_hub import HfApi
@@ -63,24 +63,6 @@ GPU_FLAVORS_DESC = (
     "l4x1(8vCPU/30GB/GPU 24GB), l4x4(48vCPU/186GB/GPU 96GB), "
     "l40sx1(8vCPU/62GB/GPU 48GB), l40sx4(48vCPU/382GB/GPU 192GB), l40sx8(192vCPU/1534GB/GPU 384GB)"
 )
-SPECIALIZED_FLAVORS = ["inf2x6"]
-ALL_FLAVORS = CPU_FLAVORS + GPU_FLAVORS + SPECIALIZED_FLAVORS
-
-# Operation names
-OperationType = Literal[
-    "run",
-    "ps",
-    "logs",
-    "inspect",
-    "cancel",
-    "scheduled run",
-    "scheduled ps",
-    "scheduled inspect",
-    "scheduled delete",
-    "scheduled suspend",
-    "scheduled resume",
-]
-
 # Constants
 UV_DEFAULT_IMAGE = "ghcr.io/astral-sh/uv:python3.12-bookworm"
 

agent/tools/papers_tool.py

@@ -120,19 +120,6 @@ async def _s2_get_json(
     return None
 
 
-async def _s2_get_paper(
-    client: httpx.AsyncClient,
-    arxiv_id: str,
-    fields: str,
-) -> dict | None:
-    """Fetch a single paper from S2 by arxiv ID. Returns None on failure."""
-    return await _s2_get_json(
-        client,
-        f"/graph/v1/paper/{_s2_paper_id(arxiv_id)}",
-        {"fields": fields},
-    )
-
-
 # ---------------------------------------------------------------------------
 # HTML paper parsing
 # ---------------------------------------------------------------------------

agent/tools/private_hf_repo_tools.py

@@ -1,650 +0,0 @@
-"""
-Private HF Repos Tool - Manage private Hugging Face repositories
-
-PRIMARY USE: Store job outputs, training scripts, and logs from HF Jobs.
-Since job results are ephemeral, this tool provides persistent storage in private repos.
-
-SECONDARY USE: Read back stored files and list repo contents.
-"""
-
-import asyncio
-from typing import Any, Dict, Literal, Optional
-
-from huggingface_hub import HfApi, hf_hub_download
-from huggingface_hub.utils import HfHubHTTPError
-
-from agent.tools.types import ToolResult
-
-# Operation names
-OperationType = Literal[
-    "upload_file", "create_repo", "check_repo", "list_files", "read_file"
-]
-
-
-async def _async_call(func, *args, **kwargs):
-    """Wrap synchronous HfApi calls for async context."""
-    return await asyncio.to_thread(func, *args, **kwargs)
-
-
-def _build_repo_url(repo_id: str, repo_type: str = "dataset") -> str:
-    """Build the Hub URL for a repository."""
-    type_path = "" if repo_type == "model" else f"{repo_type}s"
-    return f"https://huggingface.co/{type_path}/{repo_id}".replace("//", "/")
-
-
-def _content_to_bytes(content: str | bytes) -> bytes:
-    """Convert string or bytes content to bytes."""
-    if isinstance(content, str):
-        return content.encode("utf-8")
-    return content
-
-
-class PrivateHfRepoTool:
-    """Tool for managing private Hugging Face repositories."""
-
-    def __init__(self, hf_token: Optional[str] = None):
-        self.api = HfApi(token=hf_token)
-
-    async def execute(self, params: Dict[str, Any]) -> ToolResult:
-        """Execute the specified upload operation."""
-        operation = params.get("operation")
-        args = params.get("args", {})
-
-        # If no operation provided, return usage instructions
-        if not operation:
-            return self._show_help()
-
-        # Normalize operation name
-        operation = operation.lower()
-
-        # Check if help is requested
-        if args.get("help"):
-            return self._show_operation_help(operation)
-
-        try:
-            # Route to appropriate handler
-            if operation == "upload_file":
-                return await self._upload_file(args)
-            elif operation == "create_repo":
-                return await self._create_repo(args)
-            elif operation == "check_repo":
-                return await self._check_repo(args)
-            elif operation == "list_files":
-                return await self._list_files(args)
-            elif operation == "read_file":
-                return await self._read_file(args)
-            else:
-                return {
-                    "formatted": f'Unknown operation: "{operation}"\n\n'
-                    "Available operations: upload_file, create_repo, check_repo, list_files, read_file\n\n"
-                    "Call this tool with no operation for full usage instructions.",
-                    "totalResults": 0,
-                    "resultsShared": 0,
-                    "isError": True,
-                }
-
-        except HfHubHTTPError as e:
-            return {
-                "formatted": f"API Error: {str(e)}",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-        except Exception as e:
-            return {
-                "formatted": f"Error executing {operation}: {str(e)}",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-
-    def _show_help(self) -> ToolResult:
-        """Show usage instructions when tool is called with no arguments."""
-        usage_text = """# Private HF Repos Tool
-
-**PRIMARY USE:** Store job outputs, scripts, and logs from HF Jobs to private repos.
-Since job results are ephemeral, use this tool for persistent storage.
-
-**SECONDARY USE:** Read back stored files and list repo contents.
-
-## Available Commands
-
-### Write Operations
-- **upload_file** - Upload file content to a repository
-- **create_repo** - Create a new private repository
-
-### Read Operations
-- **list_files** - List all files in a repository
-- **read_file** - Read content of a specific file from a repository
-- **check_repo** - Check if a repository exists
-
-## Examples
-
-### Upload a script to a dataset repo
-Call this tool with:
-```json
-{
-  "operation": "upload_file",
-  "args": {
-    "file_content": "import pandas as pd\\nprint('Hello from HF!')",
-    "path_in_repo": "scripts/hello.py",
-    "repo_id": "my-dataset",
-    "repo_type": "dataset",
-    "create_if_missing": true,
-    "commit_message": "Add hello script"
-  }
-}
-```
-
-### Upload logs from a job
-Call this tool with:
-```json
-{
-  "operation": "upload_file",
-  "args": {
-    "file_content": "Job started...\\nJob completed successfully!",
-    "path_in_repo": "jobs/job-abc123/logs.txt",
-    "repo_id": "job-results",
-    "create_if_missing": true
-  }
-}
-```
-
-### Create a repository
-Call this tool with:
-```json
-{
-  "operation": "create_repo",
-  "args": {
-    "repo_id": "my-results",
-    "repo_type": "dataset"
-  }
-}
-```
-
-### Create a Space
-Call this tool with:
-```json
-{
-  "operation": "create_repo",
-  "args": {
-    "repo_id": "my-gradio-app",
-    "repo_type": "space",
-    "space_sdk": "gradio"
-  }
-}
-```
-Note: Repositories are always created as private. For spaces, `space_sdk` is required (gradio, streamlit, static, or docker).
-
-### Check if a repository exists
-Call this tool with:
-```json
-{
-  "operation": "check_repo",
-  "args": {
-    "repo_id": "my-dataset",
-    "repo_type": "dataset"
-  }
-}
-```
-
-### List files in a repository
-Call this tool with:
-```json
-{
-  "operation": "list_files",
-  "args": {
-    "repo_id": "job-results",
-    "repo_type": "dataset"
-  }
-}
-```
-
-### Read a file from a repository
-Call this tool with:
-```json
-{
-  "operation": "read_file",
-  "args": {
-    "repo_id": "job-results",
-    "path_in_repo": "jobs/job-abc123/script.py",
-    "repo_type": "dataset"
-  }
-}
-```
-
-## Repository Types
-
-- **dataset** (default) - For storing data, results, logs, scripts
-- **model** - For ML models and related artifacts
-- **space** - For Spaces and applications
-
-## Tips
-
-- **Content-based**: Pass file content directly as strings or bytes, not file paths
-- **Repo ID format**: Use just the repo name (e.g., "my-dataset"). Username is automatically inferred from HF_TOKEN
-- **Automatic repo creation**: Set `create_if_missing: true` to auto-create repos (requires user approval)
-- **Organization**: Use path_in_repo to organize files (e.g., "jobs/job-123/script.py")
-- **After jobs**: Upload job scripts and logs after compute jobs complete for reproducibility
-"""
-        return {"formatted": usage_text, "totalResults": 1, "resultsShared": 1}
-
-    def _show_operation_help(self, operation: str) -> ToolResult:
-        """Show help for a specific operation."""
-        help_text = f"Help for operation: {operation}\n\nCall with appropriate arguments. Use the main help for examples."
-        return {"formatted": help_text, "totalResults": 1, "resultsShared": 1}
-
-    async def _upload_file(self, args: Dict[str, Any]) -> ToolResult:
-        """Upload file content to a Hub repository."""
-        # Validate required arguments
-        file_content = args.get("file_content")
-        path_in_repo = args.get("path_in_repo")
-        repo_id = args.get("repo_id")
-
-        if not file_content:
-            return {
-                "formatted": "file_content is required",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-
-        if not path_in_repo:
-            return {
-                "formatted": "path_in_repo is required",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-
-        if not repo_id:
-            return {
-                "formatted": "repo_id is required",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-
-        repo_type = args.get("repo_type", "dataset")
-        create_if_missing = args.get("create_if_missing", False)
-
-        # Check if repo exists
-        try:
-            repo_exists = await _async_call(
-                self.api.repo_exists, repo_id=repo_id, repo_type=repo_type
-            )
-
-            # Create repo if needed
-            if not repo_exists and create_if_missing:
-                create_args = {
-                    "repo_id": repo_id,
-                    "repo_type": repo_type,
-                    "private": True,
-                }
-                # Pass through space_sdk if provided (required for spaces)
-                if "space_sdk" in args:
-                    create_args["space_sdk"] = args["space_sdk"]
-                await self._create_repo(create_args)
-            elif not repo_exists:
-                return {
-                    "formatted": f"Repository {repo_id} does not exist. Set create_if_missing: true to create it.",
-                    "totalResults": 0,
-                    "resultsShared": 0,
-                    "isError": True,
-                }
-
-        except Exception as e:
-            return {
-                "formatted": f"Failed to check repository: {str(e)}",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-
-        # Convert content to bytes
-        file_bytes = _content_to_bytes(file_content)
-
-        # Upload file
-        try:
-            await _async_call(
-                self.api.upload_file,
-                path_or_fileobj=file_bytes,
-                path_in_repo=path_in_repo,
-                repo_id=repo_id,
-                repo_type=repo_type,
-                commit_message=args.get("commit_message", f"Upload {path_in_repo}"),
-            )
-
-            repo_url = _build_repo_url(repo_id, repo_type)
-            file_url = f"{repo_url}/blob/main/{path_in_repo}"
-
-            response = f"""✓ File uploaded successfully!
-
-**Repository:** {repo_id}
-**File:** {path_in_repo}
-**View at:** {file_url}
-**Browse repo:** {repo_url}"""
-
-            return {"formatted": response, "totalResults": 1, "resultsShared": 1}
-
-        except Exception as e:
-            return {
-                "formatted": f"Failed to upload file: {str(e)}",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-
-    async def _create_repo(self, args: Dict[str, Any]) -> ToolResult:
-        """Create a new Hub repository."""
-        repo_id = args.get("repo_id")
-
-        if not repo_id:
-            return {
-                "formatted": "repo_id is required",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-
-        repo_type = args.get("repo_type", "dataset")
-        private = True  # Always create private repos
-        space_sdk = args.get("space_sdk")  # Required if repo_type is "space"
-
-        try:
-            # Check if repo already exists
-            repo_exists = await _async_call(
-                self.api.repo_exists, repo_id=repo_id, repo_type=repo_type
-            )
-
-            if repo_exists:
-                repo_url = _build_repo_url(repo_id, repo_type)
-                return {
-                    "formatted": f"Repository {repo_id} already exists.\n**View at:** {repo_url}",
-                    "totalResults": 1,
-                    "resultsShared": 1,
-                }
-
-            # Validate space_sdk for spaces
-            if repo_type == "space" and not space_sdk:
-                return {
-                    "formatted": "space_sdk is required when creating a space. Valid values: gradio, streamlit, static, docker",
-                    "totalResults": 0,
-                    "resultsShared": 0,
-                    "isError": True,
-                }
-
-            # Create repository
-            create_kwargs = {
-                "repo_id": repo_id,
-                "repo_type": repo_type,
-                "private": private,
-                "exist_ok": True,
-            }
-            # Add space_sdk only for spaces
-            if repo_type == "space" and space_sdk:
-                create_kwargs["space_sdk"] = space_sdk
-
-            repo_url = await _async_call(self.api.create_repo, **create_kwargs)
-
-            response = f"""✓ Repository created successfully!
-
-**Repository:** {repo_id}
-**Type:** {repo_type}
-**Private:** Yes
-**View at:** {repo_url}"""
-
-            return {"formatted": response, "totalResults": 1, "resultsShared": 1}
-
-        except Exception as e:
-            return {
-                "formatted": f"Failed to create repository: {str(e)}",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-
-    async def _check_repo(self, args: Dict[str, Any]) -> ToolResult:
-        """Check if a Hub repository exists."""
-        repo_id = args.get("repo_id")
-
-        if not repo_id:
-            return {
-                "formatted": "repo_id is required",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-
-        repo_type = args.get("repo_type", "dataset")
-
-        try:
-            repo_exists = await _async_call(
-                self.api.repo_exists, repo_id=repo_id, repo_type=repo_type
-            )
-
-            if repo_exists:
-                repo_url = _build_repo_url(repo_id, repo_type)
-                response = f"""✓ Repository exists!
-
-**Repository:** {repo_id}
-**Type:** {repo_type}
-**View at:** {repo_url}"""
-            else:
-                response = f"""Repository does not exist: {repo_id}
-
-To create it, call this tool with:
-```json
-{{
-  "operation": "create_repo",
-  "args": {{
-    "repo_id": "{repo_id}",
-    "repo_type": "{repo_type}"
-  }}
-}}
-```"""
-
-            return {
-                "formatted": response,
-                "totalResults": 1 if repo_exists else 0,
-                "resultsShared": 1 if repo_exists else 0,
-            }
-
-        except Exception as e:
-            return {
-                "formatted": f"Failed to check repository: {str(e)}",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-
-    async def _list_files(self, args: Dict[str, Any]) -> ToolResult:
-        """List all files in a Hub repository."""
-        repo_id = args.get("repo_id")
-
-        if not repo_id:
-            return {
-                "formatted": "repo_id is required",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-
-        repo_type = args.get("repo_type", "dataset")
-
-        try:
-            # List all files in the repository
-            files = await _async_call(
-                self.api.list_repo_files, repo_id=repo_id, repo_type=repo_type
-            )
-
-            if not files:
-                return {
-                    "formatted": f"No files found in repository: {repo_id}",
-                    "totalResults": 0,
-                    "resultsShared": 0,
-                }
-
-            # Format file list
-            file_list = "\n".join(f"- {f}" for f in sorted(files))
-            repo_url = _build_repo_url(repo_id, repo_type)
-
-            response = f"""✓ Files in repository: {repo_id}
-
-**Total files:** {len(files)}
-**Repository URL:** {repo_url}
-
-**Files:**
-{file_list}"""
-
-            return {
-                "formatted": response,
-                "totalResults": len(files),
-                "resultsShared": len(files),
-            }
-
-        except Exception as e:
-            return {
-                "formatted": f"Failed to list files: {str(e)}",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-
-    async def _read_file(self, args: Dict[str, Any]) -> ToolResult:
-        """Read content of a specific file from a Hub repository."""
-        repo_id = args.get("repo_id")
-        path_in_repo = args.get("path_in_repo")
-
-        if not repo_id:
-            return {
-                "formatted": "repo_id is required",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-
-        if not path_in_repo:
-            return {
-                "formatted": "path_in_repo is required",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-
-        repo_type = args.get("repo_type", "dataset")
-
-        try:
-            # Download file to cache and read it
-            file_path = await _async_call(
-                hf_hub_download,
-                repo_id=repo_id,
-                filename=path_in_repo,
-                repo_type=repo_type,
-                token=self.api.token,
-            )
-
-            # Read file content
-            with open(file_path, "r", encoding="utf-8") as f:
-                content = f.read()
-
-            repo_url = _build_repo_url(repo_id, repo_type)
-            file_url = f"{repo_url}/blob/main/{path_in_repo}"
-
-            response = f"""✓ File read successfully!
-
-**Repository:** {repo_id}
-**File:** {path_in_repo}
-**Size:** {len(content)} characters
-**View at:** {file_url}
-
-**Content:**
-```
-{content}
-```"""
-
-            return {"formatted": response, "totalResults": 1, "resultsShared": 1}
-
-        except UnicodeDecodeError:
-            # If file is binary, return size info instead
-            try:
-                with open(file_path, "rb") as f:
-                    binary_content = f.read()
-
-                return {
-                    "formatted": f"File is binary ({len(binary_content)} bytes). Cannot display as text.",
-                    "totalResults": 1,
-                    "resultsShared": 1,
-                }
-            except Exception as e:
-                return {
-                    "formatted": f"Failed to read binary file: {str(e)}",
-                    "totalResults": 0,
-                    "resultsShared": 0,
-                    "isError": True,
-                }
-        except Exception as e:
-            return {
-                "formatted": f"Failed to read file: {str(e)}",
-                "totalResults": 0,
-                "resultsShared": 0,
-                "isError": True,
-            }
-
-
-# Tool specification for agent registration
-PRIVATE_HF_REPO_TOOL_SPEC = {
-    "name": "hf_private_repos",
-    "description": (
-        "Manage private HF repositories - create, upload, read, list files in models/datasets/spaces. "
-        "⚠️ PRIMARY USE: Store job outputs persistently (job storage is EPHEMERAL - everything deleted after completion). "
-        "**Use when:** (1) Job completes and need to store logs/scripts/results, (2) Creating repos for training outputs, "
-        "(3) Reading back stored files, (4) Managing Space files, (5) Organizing job artifacts by path. "
-        "**Pattern:** hf_jobs (ephemeral) → hf_private_repos upload_file (persistent) → can read_file later. "
-        "ALWAYS pass file_content as string/bytes (✓), never file paths (✗) - this is content-based, no filesystem access. "
-        "**Operations:** create_repo (new private repo), upload_file (store content), read_file (retrieve content), list_files (browse), check_repo (verify exists). "
-        "**Critical for reliability:** Jobs lose all files after completion - use this tool to preserve important outputs. "
-        "Repositories created are ALWAYS private by default (good for sensitive training data/models). "
-        "For Spaces: must provide space_sdk ('gradio', 'streamlit', 'static', 'docker') when creating. "
-        "**Then:** After uploading, provide user with repository URL for viewing/sharing."
-    ),
-    "parameters": {
-        "type": "object",
-        "properties": {
-            "operation": {
-                "type": "string",
-                "enum": [
-                    "upload_file",
-                    "create_repo",
-                    "check_repo",
-                    "list_files",
-                    "read_file",
-                ],
-                "description": (
-                    "Operation to execute. Valid values: [upload_file, create_repo, check_repo, list_files, read_file]"
-                ),
-            },
-            "args": {
-                "type": "object",
-                "description": (
-                    "Operation-specific arguments as a JSON object. "
-                    "Write ops: file_content (string/bytes), path_in_repo (string), repo_id (string), "
-                    "repo_type (dataset/model/space), create_if_missing (boolean), commit_message (string), "
-                    "space_sdk (gradio/streamlit/static/docker - required when repo_type=space). "
-                    "Read ops: repo_id (string), path_in_repo (for read_file), repo_type (optional)."
-                ),
-                "additionalProperties": True,
-            },
-        },
-    },
-}
-
-
-async def private_hf_repo_handler(arguments: Dict[str, Any]) -> tuple[str, bool]:
-    """Handler for agent tool router."""
-    try:
-        tool = PrivateHfRepoTool()
-        result = await tool.execute(arguments)
-        return result["formatted"], not result.get("isError", False)
-    except Exception as e:
-        return f"Error executing Private HF Repo tool: {str(e)}", False

agent/tools/sandbox_client.py

@@ -48,17 +48,6 @@ import httpx
 from huggingface_hub import CommitOperationAdd, HfApi
 
 TEMPLATE_SPACE = "burtenshaw/sandbox"
-HARDWARE_OPTIONS = [
-    "cpu-basic",
-    "cpu-upgrade",
-    "t4-small",
-    "t4-medium",
-    "a10g-small",
-    "a10g-large",
-    "a100-large",
-]
-OUTPUT_LIMIT = 25000
-LINE_LIMIT = 4000
 DEFAULT_READ_LIMIT = 2000
 DEFAULT_TIMEOUT = 240
 MAX_TIMEOUT = 1200
@@ -497,9 +486,6 @@ class ToolResult:
             return self.output or "(no output)"
         return f"ERROR: {self.error}"
 
-    def to_dict(self) -> dict:
-        return {"success": self.success, "output": self.output, "error": self.error}
-
 
 @dataclass
 class Sandbox:
@@ -794,15 +780,6 @@ class Sandbox:
         if log:
             log("Deleted.")
 
-    def pause(self):
-        """Pause the Space (stops billing, preserves state)."""
-        self._hf_api.pause_space(self.space_id)
-
-    def restart(self):
-        """Restart the Space."""
-        self._hf_api.restart_space(self.space_id)
-        self._wait_for_api()
-
     @property
     def url(self) -> str:
         """Public URL of the Space."""
@@ -1131,10 +1108,6 @@ class Sandbox:
         },
     }
 
-    @classmethod
-    def tool_definitions(cls) -> list[dict]:
-        return [{"name": name, **spec} for name, spec in cls.TOOLS.items()]
-
     def call_tool(self, name: str, arguments: dict[str, Any]) -> ToolResult:
         dispatch = {
             "bash": lambda a: self.bash(

agent/tools/sandbox_tool.py

@@ -18,7 +18,7 @@ import threading
 import uuid
 import weakref
 from collections.abc import Callable
-from datetime import datetime, timedelta, timezone
+from datetime import datetime, timezone
 from typing import Any
 
 from huggingface_hub import HfApi, SpaceHardware
@@ -42,11 +42,6 @@ DEFAULT_CPU_SANDBOX_HARDWARE = "cpu-basic"
 # user-renamed lookalikes).
 SANDBOX_SPACE_NAME_RE = re.compile(r"^sandbox-[a-f0-9]{8}$")
 
-# How stale a sandbox must be before we treat it as definitely orphan.
-# Anything more recent could be tied to a still-live session in another tab,
-# so we leave it alone.
-_ORPHAN_STALE_AFTER = timedelta(hours=1)
-
 # HF Space duplication/build APIs can behave poorly when multiple private
 # sandboxes are created concurrently for the same namespace. Keep session
 # creation non-blocking, but serialize the actual Hub create path per owner.
@@ -344,64 +339,6 @@ async def _clear_persisted_sandbox(session: Any) -> None:
 # ── Tool name mapping (short agent names → Sandbox client names) ──────
 
 
-def _cleanup_user_orphan_sandboxes(
-    api: HfApi,
-    owner: str,
-    log: Any,
-) -> int:
-    """Delete stale ``sandbox-<8hex>`` Spaces in ``owner``'s account.
-
-    "Stale" = not modified in the last hour. The naming pattern + staleness
-    filter together make this safe:
-
-    * Naming: only matches ``sandbox-<exactly 8 lowercase hex>``, the
-      pattern Sandbox.create produces. Won't touch user-renamed Spaces.
-    * Staleness: anything modified in the last hour might still be tied
-      to a live session in another tab/replica, so we leave it alone.
-
-    Runs blocking — call via ``asyncio.to_thread``. Best-effort: failures
-    are logged but never raised, so a flaky HF API never blocks creation.
-    """
-    cutoff = datetime.now(timezone.utc) - _ORPHAN_STALE_AFTER
-    deleted = 0
-    try:
-        spaces = list(api.list_spaces(author=owner, limit=200, full=True))
-    except Exception as e:
-        log(f"orphan sweep: list_spaces failed: {e}")
-        return 0
-
-    for space in spaces:
-        space_name = space.id.rsplit("/", 1)[-1]
-        if not SANDBOX_SPACE_NAME_RE.match(space_name):
-            continue
-
-        last_mod = getattr(space, "lastModified", None) or getattr(
-            space, "last_modified", None
-        )
-        if isinstance(last_mod, str):
-            try:
-                last_mod = datetime.fromisoformat(last_mod.replace("Z", "+00:00"))
-            except ValueError:
-                last_mod = None
-        if last_mod is None:
-            log(f"orphan sweep: skipping {space.id}; missing lastModified")
-            continue
-        if last_mod and last_mod > cutoff:
-            # Recent — could be a concurrent live session. Skip.
-            continue
-
-        try:
-            api.delete_repo(repo_id=space.id, repo_type="space")
-            deleted += 1
-            log(f"orphan sweep: deleted {space.id}")
-        except Exception as e:
-            log(f"orphan sweep: failed to delete {space.id}: {e}")
-
-    if deleted:
-        log(f"orphan sweep: cleaned up {deleted} stale sandbox(es) before create")
-    return deleted
-
-
 async def _ensure_sandbox(
     session: Any,
     hardware: str = DEFAULT_CPU_SANDBOX_HARDWARE,

agent/utils/particle_logo.py

@@ -59,10 +59,6 @@ class Particle:
         self.x += self.vx
         self.y += self.vy
 
-    @property
-    def at_target(self) -> bool:
-        return abs(self.x - self.target_x) < 1.5 and abs(self.y - self.target_y) < 1.5
-
 
 def run_particle_logo(console: Console, hold_seconds: float = 1.5) -> None:
     """Run the particle coalesce effect."""

backend/dependencies.py

@@ -22,15 +22,11 @@ logger = logging.getLogger(__name__)
 
 OPENID_PROVIDER_URL = os.environ.get("OPENID_PROVIDER_URL", "https://huggingface.co")
 AUTH_ENABLED = bool(os.environ.get("OAUTH_CLIENT_ID", ""))
-HF_EMPLOYEE_ORG = os.environ.get("HF_EMPLOYEE_ORG", "huggingface")
 
 # Simple in-memory token cache: token -> (user_info, expiry_time)
 _token_cache: dict[str, tuple[dict[str, Any], float]] = {}
 TOKEN_CACHE_TTL = 300  # 5 minutes
 
-# Org membership cache: key -> expiry_time (only caches positive results)
-_org_member_cache: dict[str, float] = {}
-
 DEV_USER: dict[str, Any] = {
     "user_id": "dev",
     "username": "dev",
@@ -211,31 +207,6 @@ async def _dev_user_from_env() -> dict[str, Any]:
     }
 
 
-async def check_org_membership(token: str, org_name: str) -> bool:
-    """Check if the token owner belongs to an HF org. Only caches positive results."""
-    now = time.time()
-    key = token + org_name
-    cached = _org_member_cache.get(key)
-    if cached and cached > now:
-        return True
-
-    async with httpx.AsyncClient(timeout=10.0) as client:
-        try:
-            resp = await client.get(
-                f"{OPENID_PROVIDER_URL}/api/whoami-v2",
-                headers={"Authorization": f"Bearer {token}"},
-            )
-            if resp.status_code != 200:
-                return False
-            orgs = {o.get("name") for o in resp.json().get("orgs", [])}
-            if org_name in orgs:
-                _org_member_cache[key] = now + TOKEN_CACHE_TTL
-                return True
-            return False
-        except httpx.HTTPError:
-            return False
-
-
 async def get_current_user(request: Request) -> dict[str, Any]:
     """FastAPI dependency: extract and validate the current user.
 
@@ -277,27 +248,3 @@ async def get_current_user(request: Request) -> dict[str, Any]:
         detail="Not authenticated. Please log in via /auth/login.",
         headers={"WWW-Authenticate": "Bearer"},
     )
-
-
-def _extract_token(request: Request) -> str | None:
-    """Pull the HF access token from the Authorization header or cookie.
-
-    Mirrors the lookup order used by ``get_current_user``.
-    """
-    token = bearer_token_from_header(request.headers.get("Authorization", ""))
-    if token:
-        return token
-    return request.cookies.get("hf_access_token")
-
-
-async def require_huggingface_org_member(request: Request) -> bool:
-    """Return True if the caller is a member of the ``huggingface`` org.
-
-    Returns True unconditionally in dev mode so local testing isn't blocked.
-    """
-    if not AUTH_ENABLED:
-        return True
-    token = _extract_token(request)
-    if not token:
-        return False
-    return await check_org_membership(token, HF_EMPLOYEE_ORG)

backend/models.py

@@ -11,7 +11,6 @@ class OpType(str, Enum):
 
     USER_INPUT = "user_input"
     EXEC_APPROVAL = "exec_approval"
-    INTERRUPT = "interrupt"
     UNDO = "undo"
     COMPACT = "compact"
     SHUTDOWN = "shutdown"

backend/session_manager.py

@@ -1957,27 +1957,6 @@ class SessionManager:
             self._touch(agent_session)
         return self._auto_approval_summary(session)
 
-    def get_session_owner(self, session_id: str) -> str | None:
-        """Get the user_id that owns a session, or None if session doesn't exist."""
-        agent_session = self.sessions.get(session_id)
-        if not agent_session:
-            return None
-        return agent_session.user_id
-
-    def verify_session_access(self, session_id: str, user_id: str) -> bool:
-        """Check if a user has access to a session.
-
-        Returns True if:
-        - The session exists AND the user owns it
-        - The user_id is "dev" (dev mode bypass)
-        """
-        owner = self.get_session_owner(session_id)
-        if owner is None:
-            return False
-        if user_id == "dev" or owner == "dev":
-            return True
-        return owner == user_id
-
     def get_session_info(self, session_id: str) -> dict[str, Any] | None:
         """Get information about a session."""
         agent_session = self.sessions.get(session_id)

frontend/src/components/Chat/ThinkingIndicator.tsx

@@ -1,48 +0,0 @@
-import { Box, Typography } from '@mui/material';
-
-/** Pulsing dots shown while the agent is processing. */
-export default function ThinkingIndicator() {
-  return (
-    <Box sx={{ pt: 0.75 }}>
-      <Typography
-        variant="caption"
-        sx={{
-          fontWeight: 700,
-          fontSize: '0.72rem',
-          color: 'var(--muted-text)',
-          textTransform: 'uppercase',
-          letterSpacing: '0.04em',
-          display: 'flex',
-          alignItems: 'center',
-          gap: 0.75,
-        }}
-      >
-        Thinking
-        <Box
-          component="span"
-          sx={{
-            display: 'inline-flex',
-            gap: '3px',
-            '& span': {
-              width: 4,
-              height: 4,
-              borderRadius: '50%',
-              bgcolor: 'primary.main',
-              animation: 'dotPulse 1.4s ease-in-out infinite',
-            },
-            '& span:nth-of-type(2)': { animationDelay: '0.2s' },
-            '& span:nth-of-type(3)': { animationDelay: '0.4s' },
-            '@keyframes dotPulse': {
-              '0%, 80%, 100%': { opacity: 0.25, transform: 'scale(0.8)' },
-              '40%': { opacity: 1, transform: 'scale(1)' },
-            },
-          }}
-        >
-          <span />
-          <span />
-          <span />
-        </Box>
-      </Typography>
-    </Box>
-  );
-}

frontend/src/theme.ts

@@ -218,6 +218,3 @@ export const lightTheme = createTheme({
   },
   shape: sharedShape,
 });
-
-// Keep default export for backwards compat
-export default darkTheme;

frontend/src/types/agent.ts

@@ -36,13 +36,6 @@ export interface SessionMeta {
   autoApprovalRemainingUsd?: number | null;
 }
 
-export interface ToolApproval {
-  tool_call_id: string;
-  approved: boolean;
-  feedback?: string | null;
-  namespace?: string | null;
-}
-
 export interface User {
   authenticated: boolean;
   username?: string;

frontend/src/types/events.ts

@@ -31,68 +31,3 @@ export interface AgentEvent {
   data?: Record<string, unknown>;
   seq?: number;
 }
-
-export interface ReadyEventData {
-  message: string;
-}
-
-export interface ProcessingEventData {
-  message: string;
-}
-
-export interface AssistantMessageEventData {
-  content: string;
-}
-
-export interface ToolCallEventData {
-  tool: string;
-  arguments: Record<string, unknown>;
-}
-
-export interface ToolOutputEventData {
-  tool: string;
-  output: string;
-  success: boolean;
-}
-
-export interface ToolLogEventData {
-  tool: string;
-  log: string;
-}
-
-export interface PlanUpdateEventData {
-  plan: Array<{ id: string; content: string; status: 'pending' | 'in_progress' | 'completed' }>;
-}
-
-export interface ApprovalRequiredEventData {
-  tools: ApprovalToolItem[];
-  count: number;
-  yolo_budget?: boolean;
-  auto_approval_blocked?: boolean;
-  block_reason?: string | null;
-  estimated_cost_usd?: number | null;
-  remaining_cap_usd?: number | null;
-}
-
-export interface ApprovalToolItem {
-  tool: string;
-  arguments: Record<string, unknown>;
-  tool_call_id: string;
-  auto_approval_blocked?: boolean;
-  block_reason?: string | null;
-  estimated_cost_usd?: number | null;
-  remaining_cap_usd?: number | null;
-}
-
-export interface TurnCompleteEventData {
-  history_size: number;
-}
-
-export interface CompactedEventData {
-  old_tokens: number;
-  new_tokens: number;
-}
-
-export interface ErrorEventData {
-  error: string;
-}

pyproject.toml

@@ -12,7 +12,6 @@ dependencies = [
     # Agent runtime dependencies
     "requests>=2.33.0",
     "litellm>=1.83.0",
-    "boto3>=1.35.0",
     "huggingface-hub>=1.12.0",
     "fastmcp>=3.2.0",
     "prompt-toolkit>=3.0.0",

scripts/sweep_orphan_sandboxes.py

@@ -69,7 +69,6 @@ from huggingface_hub import HfApi
 from huggingface_hub.utils import HfHubHTTPError
 
 SANDBOX_NAME_RE = re.compile(r"^[^/]+/sandbox-[a-f0-9]{8}$")
-TEMPLATE_REPO = "burtenshaw/sandbox"
 
 
 def log(record: dict) -> None:

tests/integration/test_live_thinking_models.py

@@ -20,7 +20,7 @@ from agent.core.agent_loop import (
     _call_llm_streaming,
 )
 from agent.core.llm_params import _resolve_llm_params
-from agent.core.model_ids import DEFAULT_MODEL_ID
+from agent.core.model_ids import CLAUDE_OPUS_48_MODEL_ID
 
 
 if env_file := os.environ.get("ML_INTERN_LIVE_ENV_FILE"):
@@ -77,9 +77,9 @@ async def test_live_default_router_model_does_not_replay_reasoning_metadata():
     _skip_without_live_flag()
     _skip_without_hf_token()
 
-    session = _session(DEFAULT_MODEL_ID)
+    session = _session(CLAUDE_OPUS_48_MODEL_ID)
     llm_params = _resolve_llm_params(
-        DEFAULT_MODEL_ID,
+        CLAUDE_OPUS_48_MODEL_ID,
         os.environ["HF_TOKEN"],
         reasoning_effort="low",
     )

tests/unit/test_auto_approval_policy.py

@@ -74,9 +74,6 @@ async def test_scheduled_hf_jobs_always_require_manual_approval(operation):
     assert decision.requires_approval is True
     assert decision.auto_approval_blocked is True
     assert "Scheduled HF jobs" in decision.block_reason
-    assert agent_loop._needs_approval(
-        "hf_jobs", {"operation": operation}, session.config
-    )
 
 
 @pytest.mark.asyncio

tests/unit/test_hf_access.py

@@ -1,7 +1,4 @@
-import pytest
-
 from agent.core.hf_access import (
-    fetch_hf_user_plan,
     is_billing_error,
     is_inference_billing_error,
     jobs_access_from_whoami,
@@ -97,28 +94,3 @@ def test_normalize_hf_user_plan_uses_ispro_only():
     assert normalize_hf_user_plan({"isPro": False}) == "free"
     assert normalize_hf_user_plan({"plan": "HF Pro"}) == "free"
     assert normalize_hf_user_plan(None) is None
-
-
-@pytest.mark.asyncio
-async def test_fetch_hf_user_plan_returns_unknown_without_token():
-    assert await fetch_hf_user_plan(None) == "unknown"
-
-
-@pytest.mark.asyncio
-async def test_fetch_hf_user_plan_returns_unknown_when_whoami_unavailable(monkeypatch):
-    async def fake_fetch_whoami_v2(_token, timeout=5.0):
-        return None
-
-    monkeypatch.setattr("agent.core.hf_access.fetch_whoami_v2", fake_fetch_whoami_v2)
-
-    assert await fetch_hf_user_plan("hf-token") == "unknown"
-
-
-@pytest.mark.asyncio
-async def test_fetch_hf_user_plan_normalizes_whoami(monkeypatch):
-    async def fake_fetch_whoami_v2(_token, timeout=5.0):
-        return {"isPro": True}
-
-    monkeypatch.setattr("agent.core.hf_access.fetch_whoami_v2", fake_fetch_whoami_v2)
-
-    assert await fetch_hf_user_plan("hf-token") == "pro"

tests/unit/test_sandbox_auto_start.py

@@ -6,7 +6,7 @@ import pytest
 
 from agent.config import Config
 from agent.core import agent_loop
-from agent.core.agent_loop import _needs_approval
+from agent.core.agent_loop import _base_needs_approval
 from agent.core.session import OpType
 from agent.core.tools import create_builtin_tools
 from agent.tools.jobs_tool import HF_JOBS_TOOL_SPEC
@@ -16,17 +16,23 @@ from agent.tools.sandbox_tool import get_sandbox_tools
 def test_default_cpu_sandbox_create_does_not_require_approval():
     config = SimpleNamespace(yolo_mode=False)
 
-    assert _needs_approval("sandbox_create", {}, config) is False
-    assert _needs_approval("sandbox_create", {"hardware": "cpu-basic"}, config) is False
+    assert _base_needs_approval("sandbox_create", {}, config) is False
+    assert (
+        _base_needs_approval("sandbox_create", {"hardware": "cpu-basic"}, config)
+        is False
+    )
 
 
 def test_non_default_sandbox_create_still_requires_approval():
     config = SimpleNamespace(yolo_mode=False)
 
     assert (
-        _needs_approval("sandbox_create", {"hardware": "cpu-upgrade"}, config) is True
+        _base_needs_approval("sandbox_create", {"hardware": "cpu-upgrade"}, config)
+        is True
+    )
+    assert (
+        _base_needs_approval("sandbox_create", {"hardware": "t4-small"}, config) is True
     )
-    assert _needs_approval("sandbox_create", {"hardware": "t4-small"}, config) is True
 
 
 def test_prompt_and_tool_specs_do_not_require_cpu_sandbox_create():

tests/unit/test_sandbox_private_spaces.py

@@ -332,31 +332,6 @@ def test_sandbox_tool_forces_private_spaces(monkeypatch):
     assert "Visibility: private" in out
 
 
-def test_orphan_sweep_preserves_spaces_without_last_modified():
-    deleted: list[str] = []
-    logs: list[str] = []
-
-    class FakeApi:
-        def list_spaces(self, **kwargs):
-            assert kwargs["full"] is True
-            return [SimpleNamespace(id="alice/sandbox-12345678")]
-
-        def delete_repo(self, repo_id, repo_type):
-            deleted.append(repo_id)
-
-    count = sandbox_tool._cleanup_user_orphan_sandboxes(
-        FakeApi(),
-        "alice",
-        logs.append,
-    )
-
-    assert count == 0
-    assert deleted == []
-    assert logs == [
-        "orphan sweep: skipping alice/sandbox-12345678; missing lastModified"
-    ]
-
-
 def test_ensure_sandbox_overrides_private_argument(monkeypatch):
     captured_kwargs = {}
     persisted: list[dict] = []
@@ -398,7 +373,6 @@ def test_ensure_sandbox_overrides_private_argument(monkeypatch):
         pass
 
     monkeypatch.setattr(sandbox_tool, "HfApi", FakeApi)
-    monkeypatch.setattr(sandbox_tool, "_cleanup_user_orphan_sandboxes", lambda *args: 0)
     monkeypatch.setattr(Sandbox, "create", staticmethod(fake_create))
     monkeypatch.setattr(telemetry, "record_sandbox_create", fake_record_sandbox_create)
     monkeypatch.setattr("huggingface_hub.metadata_update", _fail_metadata_update)
@@ -524,7 +498,6 @@ def test_sandbox_creation_is_serialized_per_owner(monkeypatch):
         pass
 
     monkeypatch.setattr(sandbox_tool, "HfApi", FakeApi)
-    monkeypatch.setattr(sandbox_tool, "_cleanup_user_orphan_sandboxes", lambda *args: 0)
     monkeypatch.setattr(Sandbox, "create", staticmethod(fake_create))
     monkeypatch.setattr(telemetry, "record_sandbox_create", fake_record_sandbox_create)
     monkeypatch.setattr("huggingface_hub.metadata_update", _fail_metadata_update)

uv.lock

@@ -1775,7 +1775,6 @@ version = "0.1.0"
 source = { editable = "." }
 dependencies = [
     { name = "apscheduler" },
-    { name = "boto3" },
     { name = "datasets" },
     { name = "fastapi" },
     { name = "fastmcp" },
@@ -1822,7 +1821,6 @@ eval = [
 [package.metadata]
 requires-dist = [
     { name = "apscheduler", specifier = ">=3.10,<4" },
-    { name = "boto3", specifier = ">=1.35.0" },
     { name = "datasets", specifier = ">=4.4.1" },
     { name = "datasets", marker = "extra == 'eval'", specifier = ">=4.3.0" },
     { name = "fastapi", specifier = ">=0.115.0" },