Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,81 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Multi-stage build using openenv-base
+# This Dockerfile is flexible and works for both:
+# - In-repo environments (with local OpenEnv sources)
+# - Standalone environments (with openenv from PyPI/Git)
+# The build script (openenv build) handles context detection and sets appropriate build args.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+# Ensure git is available (required for installing dependencies from VCS)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
+
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=coding_tools_env
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv is already vendored in the build context
+# For standalone builds, openenv will be installed via pyproject.toml
+WORKDIR /app/env
+
+# Ensure uv is available (for local builds where base image lacks it)
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
+    
+# Install dependencies using uv sync
+# If uv.lock exists, use it; otherwise resolve on the fly
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Copy the virtual environment from builder
+COPY --from=builder /app/env/.venv /app/.venv
+
+# Copy the environment code
+COPY --from=builder /app/env /app/env
+
+# Set PATH to use the virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+ENV ENABLE_WEB_INTERFACE=true
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health', timeout=2).read()" || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with the /app/env structure
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

README.md

@@ -1,10 +1,72 @@
 ---
-title: Coding Tools Env
-emoji: 🦀
-colorFrom: yellow
-colorTo: blue
+title: Coding Tools Environment Server
+emoji: 🧰
+colorFrom: green
+colorTo: gray
 sdk: docker
 pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
+  - coding
+  - tools
+  - e2b
+short_description: SETA-style multi-tool coding environment backed by E2B
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Coding Tools Environment
+
+`coding_tools_env` is an E2B-backed multi-tool coding environment with explicit
+filesystem and shell tools.
+
+Each episode creates a fresh E2B sandbox. Reset accepts setup and verify
+commands. Verify commands are used by `submit_solution`.
+
+## Tools
+
+- `bash(command, timeout=30)`
+- `read(file_path, offset=None, limit=None)`
+- `write(file_path, content)`
+- `edit(file_path, old_string, new_string, replace_all=False)`
+- `multi_edit(file_path, edits)`
+- `glob(pattern, path=None)`
+- `grep(pattern, path=None, include=None)`
+- `ls(path=".", ignore=None)`
+- `todo_write(todos)`
+- `submit_solution()`
+
+## Quick Start
+
+```python
+from coding_tools_env import CodingToolsEnv
+
+with CodingToolsEnv(base_url="http://localhost:8000").sync() as env:
+    env.reset(
+        setup=["mkdir -p /home/user/work"],
+        verify=["test -f /home/user/work/answer.txt"],
+    )
+    print(env.call_tool("write", file_path="/home/user/work/answer.txt", content="done\n"))
+    print(env.call_tool("submit_solution"))
+```
+
+## Local Server
+
+```bash
+cd envs/coding_tools_env
+E2B_API_KEY=e2b_... uv run --project . server
+```
+
+## Docker
+
+```bash
+cd envs/coding_tools_env
+openenv build -t coding-tools-env
+docker run -p 8000:8000 -e E2B_API_KEY=e2b_... coding-tools-env
+```
+
+## Configuration
+
+- `E2B_API_KEY`: required when resetting an episode.
+- `MAX_CONCURRENT_ENVS`: max concurrent sessions (default `4`).
+

__init__.py

@@ -0,0 +1,22 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Coding Tools Environment for OpenEnv."""
+
+from openenv.core.env_server.mcp_types import CallToolAction, ListToolsAction
+
+from .client import CodingToolsEnv
+from .models import CodingToolsState, CommandResult, EditSpec, TodoItem
+
+__all__ = [
+    "CodingToolsEnv",
+    "CodingToolsState",
+    "CommandResult",
+    "TodoItem",
+    "EditSpec",
+    "CallToolAction",
+    "ListToolsAction",
+]

client.py

@@ -0,0 +1,15 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Client for coding_tools_env."""
+
+from openenv.core.mcp_client import MCPToolClient
+
+
+class CodingToolsEnv(MCPToolClient):
+    """MCP client for coding_tools_env."""
+
+    pass

models.py

@@ -0,0 +1,55 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Models for coding_tools_env."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from openenv.core.env_server.types import State
+from pydantic import BaseModel, Field
+
+
+class CommandResult(BaseModel):
+    """Normalized result for one tool execution."""
+
+    tool: str
+    ok: bool
+    output: str = ""
+    error: str | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class TodoItem(BaseModel):
+    """Todo item tracked by todo_write."""
+
+    id: str
+    content: str
+    status: str
+    priority: str
+
+
+class CodingToolsState(State):
+    """Per-session state for coding_tools_env."""
+
+    sandbox_id: str | None = None
+    setup_results: list[CommandResult] = Field(default_factory=list)
+    verify_commands: list[str] = Field(default_factory=list)
+    verify_results: list[CommandResult] = Field(default_factory=list)
+    todos: list[TodoItem] = Field(default_factory=list)
+    tool_history: list[CommandResult] = Field(default_factory=list)
+    submitted: bool = False
+    last_reward: float | None = None
+    last_error: str | None = None
+
+
+class EditSpec(BaseModel):
+    """One edit operation for multi_edit."""
+
+    old_string: str
+    new_string: str
+    replace_all: bool = False

openenv.yaml

@@ -0,0 +1,7 @@
+spec_version: 1
+name: coding_tools_env
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000
+

pyproject.toml

@@ -0,0 +1,42 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-coding_tools_env"
+version = "0.1.0"
+description = "SETA-style coding tools environment for OpenEnv backed by E2B"
+requires-python = ">=3.10"
+dependencies = [
+    "openenv-core[core]>=0.2.2",
+    "e2b-code-interpreter>=1.0.0",
+    "fastapi>=0.115.0",
+    "fastmcp>=3.0.0",
+    "gradio>=4.0.0",
+    "pydantic>=2.0.0",
+    "requests>=2.31.0",
+    "uvicorn>=0.24.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+server = "coding_tools_env.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["coding_tools_env", "coding_tools_env.server"]
+package-dir = { "coding_tools_env" = ".", "coding_tools_env.server" = "server" }
+
+[tool.setuptools.package-data]
+coding_tools_env = ["**/*.txt", "**/*.yaml"]

server/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Coding Tools Env environment server components."""
+
+from .coding_tools_env_environment import CodingToolsEnvironment
+
+__all__ = ["CodingToolsEnvironment"]

server/app.py

@@ -0,0 +1,60 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""FastAPI app for coding_tools_env."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from openenv.core.env_server.http_server import create_app
+from openenv.core.env_server.mcp_types import CallToolAction, CallToolObservation
+
+try:
+    from .coding_tools_env_environment import CodingToolsEnvironment
+    from .gradio_ui import coding_tools_ui_builder
+except ImportError:  # pragma: no cover
+    from server.coding_tools_env_environment import CodingToolsEnvironment  # type: ignore
+    from server.gradio_ui import coding_tools_ui_builder  # type: ignore
+
+
+def _load_env_file() -> None:
+    candidate = Path(__file__).resolve().parents[1] / ".env"
+    if not candidate.exists():
+        return
+    for raw in candidate.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        key = key.strip()
+        value = value.strip().strip('"').strip("'")
+        if key and key not in os.environ:
+            os.environ[key] = value
+
+
+_load_env_file()
+os.environ.setdefault("ENABLE_WEB_INTERFACE", "true")
+
+app = create_app(
+    CodingToolsEnvironment,
+    CallToolAction,
+    CallToolObservation,
+    env_name="coding_tools_env",
+    max_concurrent_envs=int(os.getenv("MAX_CONCURRENT_ENVS", "4")),
+    gradio_builder=coding_tools_ui_builder,
+)
+
+
+def main(host: str = "0.0.0.0", port: int = 8000) -> None:
+    import uvicorn
+
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

server/coding_tools_env_environment.py

@@ -0,0 +1,407 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""SETA-style multi-tool coding environment backed by E2B."""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Optional
+from uuid import uuid4
+
+from fastmcp import FastMCP
+from openenv.core.env_server.mcp_environment import MCPEnvironment
+from openenv.core.env_server.types import Action, Observation
+
+try:
+    from .e2b_sandbox import E2BSandbox
+    from ..models import CodingToolsState, CommandResult, EditSpec, TodoItem
+except ImportError:  # pragma: no cover
+    from models import CodingToolsState, CommandResult, EditSpec, TodoItem
+    from server.e2b_sandbox import E2BSandbox
+
+
+REWARD_FILE = "/home/user/logs/verifier/reward.txt"
+
+
+class CodingToolsEnvironment(MCPEnvironment):
+    """Tool-centric coding environment with one sandbox per episode."""
+
+    SUPPORTS_CONCURRENT_SESSIONS = True
+
+    def __init__(self):
+        self._sandbox: Optional[E2BSandbox] = None
+        self._state = CodingToolsState(episode_id=str(uuid4()), step_count=0)
+
+        mcp = FastMCP("coding_tools_env")
+
+        @mcp.tool
+        def bash(command: str, timeout: float | None = 30) -> str:
+            """Execute bash commands using the computer instance."""
+            if not self._sandbox:
+                return "Error: environment not reset. Call reset() first."
+            timeout_value = 30 if timeout is None else float(timeout)
+            result = self._sandbox.run_shell(command, timeout_s=timeout_value)
+            self._record("bash", result.ok, result.output, result.error, result.metadata)
+            return result.output if result.ok else f"ERROR: {result.error}\n{result.output}".strip()
+
+        @mcp.tool
+        def read(file_path: str, offset: int | None = None, limit: int | None = None) -> str:
+            """Read file contents using computer instance."""
+            if not self._sandbox:
+                return "Error: environment not reset. Call reset() first."
+            result = self._sandbox.read_file(file_path=file_path, offset=offset, limit=limit)
+            self._record("read", result.ok, result.output, result.error, result.metadata)
+            return result.output if result.ok else f"ERROR: {result.error}"
+
+        @mcp.tool
+        def write(file_path: str, content: str) -> str:
+            """Write content to a file using computer instance."""
+            if not self._sandbox:
+                return "Error: environment not reset. Call reset() first."
+            result = self._sandbox.write_file(file_path=file_path, content=content)
+            self._record("write", result.ok, result.output, result.error, result.metadata)
+            return result.output if result.ok else f"ERROR: {result.error}"
+
+        @mcp.tool
+        def edit(
+            file_path: str,
+            old_string: str,
+            new_string: str,
+            replace_all: bool = False,
+        ) -> str:
+            """Perform exact string replacement in a file."""
+            if not self._sandbox:
+                return "Error: environment not reset. Call reset() first."
+            read_result = self._sandbox.read_file(file_path=file_path)
+            if not read_result.ok:
+                self._record("edit", False, "", read_result.error, None)
+                return f"ERROR: {read_result.error}"
+            original = read_result.output
+            if old_string not in original:
+                self._record("edit", False, "", "old_string not found", None)
+                return "ERROR: old_string not found"
+            if replace_all:
+                updated = original.replace(old_string, new_string)
+            else:
+                updated = original.replace(old_string, new_string, 1)
+            write_result = self._sandbox.write_file(file_path=file_path, content=updated)
+            ok = write_result.ok
+            msg = "edit ok" if ok else ""
+            self._record("edit", ok, msg, write_result.error, {"replace_all": replace_all})
+            return msg if ok else f"ERROR: {write_result.error}"
+
+        @mcp.tool
+        def multi_edit(file_path: str, edits: list[dict[str, Any]]) -> str:
+            """Perform multiple edits on a single file."""
+            if not self._sandbox:
+                return "Error: environment not reset. Call reset() first."
+            read_result = self._sandbox.read_file(file_path=file_path)
+            if not read_result.ok:
+                self._record("multi_edit", False, "", read_result.error, None)
+                return f"ERROR: {read_result.error}"
+            text = read_result.output
+            applied = 0
+            for raw in edits:
+                spec = EditSpec.model_validate(raw)
+                if spec.old_string not in text:
+                    self._record(
+                        "multi_edit",
+                        False,
+                        "",
+                        f"old_string not found: {spec.old_string[:80]}",
+                        {"applied": applied},
+                    )
+                    return f"ERROR: old_string not found: {spec.old_string[:80]}"
+                if spec.replace_all:
+                    text = text.replace(spec.old_string, spec.new_string)
+                else:
+                    text = text.replace(spec.old_string, spec.new_string, 1)
+                applied += 1
+            write_result = self._sandbox.write_file(file_path=file_path, content=text)
+            self._record(
+                "multi_edit",
+                write_result.ok,
+                f"applied {applied} edits" if write_result.ok else "",
+                write_result.error,
+                {"applied": applied},
+            )
+            return f"applied {applied} edits" if write_result.ok else f"ERROR: {write_result.error}"
+
+        @mcp.tool
+        def glob(pattern: str, path: str | None = None) -> str:
+            """Find files matching a glob pattern."""
+            if not self._sandbox:
+                return "Error: environment not reset. Call reset() first."
+            result = self._sandbox.glob_files(pattern=pattern, path=path)
+            self._record("glob", result.ok, result.output, result.error, result.metadata)
+            return result.output if result.ok else f"ERROR: {result.error}"
+
+        @mcp.tool
+        def grep(pattern: str, path: str | None = None, include: str | None = None) -> str:
+            """Search for patterns in files."""
+            if not self._sandbox:
+                return "Error: environment not reset. Call reset() first."
+            result = self._sandbox.grep(pattern=pattern, path=path, include=include)
+            self._record("grep", result.ok, result.output, result.error, result.metadata)
+            return result.output if result.ok else f"ERROR: {result.error}\n{result.output}".strip()
+
+        @mcp.tool
+        def ls(path: str = ".", ignore: list[str] | None = None) -> str:
+            """List files and directories."""
+            if not self._sandbox:
+                return "Error: environment not reset. Call reset() first."
+            result = self._sandbox.list_dir(path=path, ignore=ignore)
+            self._record("ls", result.ok, result.output, result.error, result.metadata)
+            return result.output if result.ok else f"ERROR: {result.error}"
+
+        @mcp.tool
+        def todo_write(todos: list[dict[str, Any]]) -> str:
+            """Manage todo list for planning and progress tracking."""
+            validated = [TodoItem.model_validate(todo) for todo in todos]
+            in_progress = [item for item in validated if item.status == "in_progress"]
+            if len(in_progress) > 1:
+                msg = "ERROR: only one todo item can be in_progress"
+                self._record("todo_write", False, "", msg, None)
+                return msg
+            for item in validated:
+                if item.status not in {"pending", "in_progress", "completed"}:
+                    msg = f"ERROR: invalid status {item.status}"
+                    self._record("todo_write", False, "", msg, None)
+                    return msg
+                if item.priority not in {"high", "medium", "low"}:
+                    msg = f"ERROR: invalid priority {item.priority}"
+                    self._record("todo_write", False, "", msg, None)
+                    return msg
+            self._state.todos = validated
+            self._record("todo_write", True, f"stored {len(validated)} todos", None, None)
+            return f"stored {len(validated)} todos"
+
+        @mcp.tool
+        def submit_solution() -> str:
+            """Submit solution and run test suite via verify commands."""
+            if not self._sandbox:
+                return "Error: environment not reset. Call reset() first."
+            self._state.submitted = True
+            if not self._state.verify_commands:
+                self._state.last_reward = 0.0
+                self._record(
+                    "submit_solution",
+                    True,
+                    "No verify commands configured. reward=0.0",
+                    None,
+                    {"reward": 0.0, "finished": True},
+                )
+                return "No verify commands configured. reward=0.0"
+            summary = self._run_verify_commands()
+            self._record(
+                "submit_solution",
+                True,
+                (
+                    f"Verification: {summary['passed']}/{summary['total']} passed; "
+                    f"reward={summary['reward']}"
+                ),
+                None,
+                {"reward": summary["reward"], "finished": True},
+            )
+            return (
+                f"Verification: {summary['passed']}/{summary['total']} passed; "
+                f"reward={summary['reward']}"
+            )
+
+        super().__init__(mcp)
+
+    def reset(
+        self,
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+        **kwargs: Any,
+    ) -> Observation:
+        if self._sandbox:
+            self._sandbox.kill()
+            self._sandbox = None
+
+        api_key = os.environ.get("E2B_API_KEY")
+        self._state = CodingToolsState(
+            episode_id=episode_id or str(uuid4()),
+            step_count=0,
+        )
+        if not api_key:
+            return Observation(
+                done=True,
+                reward=None,
+                metadata={
+                    "status": "error",
+                    "error": "E2B_API_KEY is not set. Configure it before reset.",
+                },
+            )
+
+        try:
+            self._sandbox = E2BSandbox(api_key=api_key)
+        except Exception as exc:  # noqa: BLE001
+            return Observation(
+                done=True,
+                reward=None,
+                metadata={
+                    "status": "error",
+                    "error": f"failed to create E2B sandbox: {type(exc).__name__}: {exc}",
+                },
+            )
+
+        self._state.sandbox_id = self._sandbox.sandbox_id
+        setup_commands = _coerce_commands(
+            kwargs.get("setup", kwargs.get("setup_scripts", []))
+        )
+        verify_commands = _coerce_commands(
+            kwargs.get("verify", kwargs.get("verify_scripts", []))
+        )
+        self._state.verify_commands = verify_commands
+
+        self._sandbox.run_shell("mkdir -p /home/user/logs/verifier")
+        if setup_commands:
+            for command in setup_commands:
+                result = self._sandbox.run_shell(command, timeout_s=60)
+                command_result = CommandResult(
+                    tool="setup",
+                    ok=result.ok,
+                    output=result.output,
+                    error=result.error,
+                    metadata={"command": command},
+                )
+                self._state.setup_results.append(command_result)
+                if not result.ok:
+                    return Observation(
+                        done=True,
+                        reward=None,
+                        metadata={
+                            "status": "error",
+                            "sandbox_id": self._state.sandbox_id,
+                            "message": "Setup command failed.",
+                            "setup_results": [
+                                entry.model_dump() for entry in self._state.setup_results
+                            ],
+                        },
+                    )
+
+        return Observation(
+            done=False,
+            reward=None,
+            metadata={
+                "status": "ready",
+                "sandbox_id": self._state.sandbox_id,
+                "message": "coding_tools_env ready.",
+                "verify_commands": verify_commands,
+                "setup_results": [
+                    entry.model_dump() for entry in self._state.setup_results
+                ],
+            },
+        )
+
+    def _step_impl(
+        self,
+        action: Action,
+        timeout_s: Optional[float] = None,
+        **_: Any,
+    ) -> Observation:
+        return Observation(
+            done=False,
+            reward=None,
+            metadata={
+                "error": (
+                    f"Unknown action type: {type(action).__name__}. "
+                    "Use ListToolsAction or CallToolAction for MCP interactions."
+                )
+            },
+        )
+
+    def step(
+        self,
+        action: Action,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> Observation:
+        self._state.step_count += 1
+        return super().step(action, timeout_s=timeout_s, **kwargs)
+
+    async def step_async(
+        self,
+        action: Action,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> Observation:
+        self._state.step_count += 1
+        return await super().step_async(action, timeout_s=timeout_s, **kwargs)
+
+    @property
+    def state(self) -> CodingToolsState:
+        return self._state
+
+    def close(self) -> None:
+        if self._sandbox:
+            self._sandbox.kill()
+            self._sandbox = None
+
+    def _record(
+        self,
+        tool: str,
+        ok: bool,
+        output: str,
+        error: str | None,
+        metadata: dict[str, Any] | None,
+    ) -> None:
+        result = CommandResult(
+            tool=tool,
+            ok=ok,
+            output=output,
+            error=error,
+            metadata=metadata or {},
+        )
+        self._state.tool_history.append(result)
+        self._state.last_error = error
+
+    def _run_verify_commands(self) -> dict[str, Any]:
+        self._sandbox.run_shell("mkdir -p /home/user/logs/verifier")
+        self._state.verify_results = []
+        passed = 0
+        for command in self._state.verify_commands:
+            result = self._sandbox.run_shell(command, timeout_s=120)
+            record = CommandResult(
+                tool="verify",
+                ok=result.ok,
+                output=result.output,
+                error=result.error,
+                metadata={"command": command},
+            )
+            self._state.verify_results.append(record)
+            if result.ok:
+                passed += 1
+        total = len(self._state.verify_commands)
+        reward = _read_reward_override(self._sandbox)
+        if reward is None:
+            reward = (passed / total) if total else 0.0
+        self._state.last_reward = reward
+        return {"passed": passed, "total": total, "reward": reward}
+
+
+def _coerce_commands(value: Any) -> list[str]:
+    if value is None:
+        return []
+    if isinstance(value, str):
+        return [value] if value.strip() else []
+    return [str(item) for item in value if str(item).strip()]
+
+
+def _read_reward_override(sandbox: E2BSandbox) -> float | None:
+    result = sandbox.read_file(REWARD_FILE)
+    if not result.ok:
+        return None
+    raw = (result.output or "").strip()
+    if not raw:
+        return None
+    try:
+        return float(raw)
+    except ValueError:
+        return None

server/e2b_sandbox.py

@@ -0,0 +1,215 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""E2B sandbox wrapper with shell and file-operation helpers."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any
+
+_E2B_IMPORT_ERROR: ImportError | None = None
+
+try:
+    from e2b_code_interpreter import Sandbox
+except ImportError as _e2b_import_error:  # pragma: no cover
+    _E2B_IMPORT_ERROR = _e2b_import_error
+    Sandbox = None  # type: ignore[assignment]
+
+
+@dataclass
+class ToolResult:
+    ok: bool
+    output: str = ""
+    error: str | None = None
+    metadata: dict[str, Any] | None = None
+
+
+class E2BSandbox:
+    """One E2B sandbox per OpenEnv episode."""
+
+    def __init__(self, api_key: str):
+        if Sandbox is None:
+            raise ImportError(
+                "e2b-code-interpreter is not installed. Install coding_tools_env "
+                f"dependencies. Original import error: {_E2B_IMPORT_ERROR}"
+            )
+        self._sbx = Sandbox.create(api_key=api_key)
+        self.sandbox_id: str = self._sbx.sandbox_id
+        self.run_shell("mkdir -p /home/user/work")
+
+    def run_shell(self, command: str, timeout_s: float = 30) -> ToolResult:
+        code = (
+            "import subprocess, json\n"
+            f"_r = subprocess.run({command!r}, shell=True, capture_output=True, text=True, timeout={float(timeout_s)!r})\n"
+            "print(json.dumps({'returncode': _r.returncode, 'stdout': _r.stdout, 'stderr': _r.stderr}))\n"
+        )
+        execution = self._sbx.run_code(code)
+        result = _decode_json_line(execution.logs.stdout)
+        if result is None:
+            return ToolResult(ok=False, error=_format_error(execution))
+        rc = int(result.get("returncode", 1))
+        stdout = str(result.get("stdout", ""))
+        stderr = str(result.get("stderr", ""))
+        ok = rc == 0
+        return ToolResult(
+            ok=ok,
+            output=(stdout + stderr).strip(),
+            error=None if ok else f"exit_code={rc}",
+            metadata={"exit_code": rc},
+        )
+
+    def read_file(
+        self, file_path: str, offset: int | None = None, limit: int | None = None
+    ) -> ToolResult:
+        code = (
+            "from pathlib import Path\n"
+            "import json\n"
+            f"_p = Path({file_path!r})\n"
+            "if not _p.exists():\n"
+            "    print(json.dumps({'ok': False, 'error': 'file not found'}))\n"
+            "else:\n"
+            "    _t = _p.read_text(encoding='utf-8')\n"
+            f"    _o = {offset if offset is not None else 'None'}\n"
+            f"    _l = {limit if limit is not None else 'None'}\n"
+            "    if _o is not None:\n"
+            "        _t = _t[_o:]\n"
+            "    if _l is not None:\n"
+            "        _t = _t[:_l]\n"
+            "    print(json.dumps({'ok': True, 'content': _t}))\n"
+        )
+        execution = self._sbx.run_code(code)
+        result = _decode_json_line(execution.logs.stdout)
+        if result is None:
+            return ToolResult(ok=False, error=_format_error(execution))
+        if not result.get("ok", False):
+            return ToolResult(ok=False, error=str(result.get("error", "read failed")))
+        return ToolResult(ok=True, output=str(result.get("content", "")))
+
+    def write_file(self, file_path: str, content: str) -> ToolResult:
+        code = (
+            "from pathlib import Path\n"
+            "import json\n"
+            f"_p = Path({file_path!r})\n"
+            "_p.parent.mkdir(parents=True, exist_ok=True)\n"
+            f"_p.write_text({content!r}, encoding='utf-8')\n"
+            "print(json.dumps({'ok': True, 'bytes': len(_p.read_bytes())}))\n"
+        )
+        execution = self._sbx.run_code(code)
+        result = _decode_json_line(execution.logs.stdout)
+        if result is None:
+            return ToolResult(ok=False, error=_format_error(execution))
+        return ToolResult(ok=True, output="write ok", metadata={"bytes": result.get("bytes", 0)})
+
+    def glob_files(self, pattern: str, path: str | None = None) -> ToolResult:
+        code = (
+            "from pathlib import Path\n"
+            "import json\n"
+            f"_root = Path({(path or '.')!r})\n"
+            f"_matches = sorted(str(p) for p in _root.glob({pattern!r}))\n"
+            "print(json.dumps({'ok': True, 'matches': _matches}))\n"
+        )
+        execution = self._sbx.run_code(code)
+        result = _decode_json_line(execution.logs.stdout)
+        if result is None:
+            return ToolResult(ok=False, error=_format_error(execution))
+        matches = result.get("matches", [])
+        return ToolResult(ok=True, output="\n".join(matches), metadata={"matches": matches})
+
+    def list_dir(self, path: str = ".", ignore: list[str] | None = None) -> ToolResult:
+        ignore = ignore or []
+        code = (
+            "from pathlib import Path\n"
+            "import json\n"
+            f"_ignore = set({ignore!r})\n"
+            f"_p = Path({path!r})\n"
+            "if not _p.exists():\n"
+            "    print(json.dumps({'ok': False, 'error': 'path not found'}))\n"
+            "else:\n"
+            "    _items = []\n"
+            "    for _x in sorted(_p.iterdir()):\n"
+            "        if _x.name in _ignore:\n"
+            "            continue\n"
+            "        _items.append({'name': _x.name, 'is_dir': _x.is_dir()})\n"
+            "    print(json.dumps({'ok': True, 'items': _items}))\n"
+        )
+        execution = self._sbx.run_code(code)
+        result = _decode_json_line(execution.logs.stdout)
+        if result is None:
+            return ToolResult(ok=False, error=_format_error(execution))
+        if not result.get("ok", False):
+            return ToolResult(ok=False, error=str(result.get("error", "ls failed")))
+        items = result.get("items", [])
+        lines = [f"{'[dir]' if item['is_dir'] else '[file]'} {item['name']}" for item in items]
+        return ToolResult(ok=True, output="\n".join(lines), metadata={"items": items})
+
+    def grep(self, pattern: str, path: str | None = None, include: str | None = None) -> ToolResult:
+        root = path or "."
+        code = (
+            "from pathlib import Path\n"
+            "import fnmatch, json, re\n"
+            f"_root = Path({root!r})\n"
+            f"_pat = re.compile({pattern!r})\n"
+            f"_include = {include!r}\n"
+            "_out = []\n"
+            "if not _root.exists():\n"
+            "    print(json.dumps({'ok': False, 'error': 'path not found'}))\n"
+            "else:\n"
+            "    for _p in _root.rglob('*'):\n"
+            "        if not _p.is_file():\n"
+            "            continue\n"
+            "        if _include and not fnmatch.fnmatch(_p.name, _include):\n"
+            "            continue\n"
+            "        try:\n"
+            "            _lines = _p.read_text(encoding='utf-8').splitlines()\n"
+            "        except Exception:\n"
+            "            continue\n"
+            "        for _i, _line in enumerate(_lines, start=1):\n"
+            "            if _pat.search(_line):\n"
+            "                _out.append(f'{_p}:{_i}:{_line}')\n"
+            "    print(json.dumps({'ok': True, 'matches': _out}))\n"
+        )
+        execution = self._sbx.run_code(code)
+        result = _decode_json_line(execution.logs.stdout)
+        if result is None:
+            return ToolResult(ok=False, error=_format_error(execution))
+        if not result.get("ok", False):
+            return ToolResult(ok=False, error=str(result.get("error", "grep failed")))
+        matches = result.get("matches", [])
+        return ToolResult(ok=True, output="\n".join(matches), metadata={"matches": matches})
+
+    def kill(self) -> None:
+        try:
+            self._sbx.kill()
+        except Exception:
+            try:
+                self._sbx.close()
+            except Exception:
+                pass
+
+
+def _decode_json_line(lines: list[str] | None) -> dict[str, Any] | None:
+    if not lines:
+        return None
+    for raw in reversed(lines):
+        raw = raw.strip()
+        if not raw:
+            continue
+        try:
+            value = json.loads(raw)
+        except Exception:
+            continue
+        if isinstance(value, dict):
+            return value
+    return None
+
+
+def _format_error(execution: Any) -> str:
+    if execution.error:
+        return f"{execution.error.name}: {execution.error.value}"
+    stderr = "\n".join(execution.logs.stderr or [])
+    return stderr or "sandbox execution failed"

server/gradio_ui.py

@@ -0,0 +1,217 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Custom Gradio UI for coding_tools_env."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Optional
+
+import gradio as gr
+
+
+def _lines(value: str) -> list[str]:
+    return [line.strip() for line in value.splitlines() if line.strip()]
+
+
+def _extract_tool_text(result: dict[str, Any]) -> str:
+    obs = result.get("observation", {})
+    if not isinstance(obs, dict):
+        return ""
+    tool_result = obs.get("result", {})
+    if not isinstance(tool_result, dict):
+        return ""
+    content = tool_result.get("content", [])
+    if isinstance(content, list) and content:
+        first = content[0]
+        if isinstance(first, dict):
+            return str(first.get("text", ""))
+    return str(tool_result.get("data", ""))
+
+
+def coding_tools_ui_builder(
+    web_manager,
+    action_fields: list[dict[str, Any]],
+    metadata: Optional[Any],
+    is_chat_env: bool,
+    title: str,
+    quick_start_md: Optional[str],
+) -> gr.Blocks:
+    def state_payload() -> dict[str, Any]:
+        try:
+            return web_manager.get_state()
+        except RuntimeError:
+            return {}
+
+    with gr.Blocks(title=f"{title} - Coding Tools") as demo:
+        gr.Markdown(f"# {title}")
+        gr.Markdown("E2B-backed coding tools environment with SETA-style tool surface.")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### Session")
+                setup_input = gr.Textbox(
+                    label="Setup commands",
+                    value="mkdir -p /home/user/work",
+                    lines=4,
+                )
+                verify_input = gr.Textbox(
+                    label="Verify commands",
+                    value="pytest -q",
+                    lines=3,
+                )
+                reset_btn = gr.Button("Reset sandbox", variant="primary")
+                close_btn = gr.Button("Stop / Close session", variant="secondary")
+
+                gr.Markdown("### Bash")
+                bash_input = gr.Textbox(label="Command", value="pwd && ls -la", lines=3)
+                timeout_input = gr.Number(label="Timeout (seconds)", value=30)
+                bash_btn = gr.Button("Run bash", variant="primary")
+
+                gr.Markdown("### Submit")
+                submit_btn = gr.Button("Submit solution", variant="primary")
+
+            with gr.Column(scale=1):
+                gr.Markdown("### File tools")
+                file_path = gr.Textbox(label="File path", value="/home/user/work/main.py")
+                read_btn = gr.Button("Read")
+                write_content = gr.Textbox(label="Write content", lines=5)
+                write_btn = gr.Button("Write")
+                old_string = gr.Textbox(label="Old string", lines=2)
+                new_string = gr.Textbox(label="New string", lines=2)
+                replace_all = gr.Checkbox(label="Replace all", value=False)
+                edit_btn = gr.Button("Edit")
+
+                gr.Markdown("### Search tools")
+                glob_pattern = gr.Textbox(label="Glob pattern", value="**/*.py")
+                glob_path = gr.Textbox(label="Glob path", value="/home/user/work")
+                glob_btn = gr.Button("Glob")
+                grep_pattern = gr.Textbox(label="Grep pattern", value="TODO")
+                grep_path = gr.Textbox(label="Grep path", value="/home/user/work")
+                grep_include = gr.Textbox(label="Grep include (optional)")
+                grep_btn = gr.Button("Grep")
+
+            with gr.Column(scale=1):
+                gr.Markdown("### Directory and Todo")
+                ls_path = gr.Textbox(label="LS path", value="/home/user/work")
+                ls_ignore = gr.Textbox(label="LS ignore (comma-separated)")
+                ls_btn = gr.Button("LS")
+                todos_json = gr.Code(
+                    label="Todos JSON",
+                    language="json",
+                    value='[{"id":"1","content":"Inspect files","status":"in_progress","priority":"high"}]',
+                    lines=8,
+                )
+                todo_btn = gr.Button("Update todos")
+                state_view = gr.JSON(label="Session state", value={})
+
+        output = gr.Textbox(label="Tool output", lines=12, interactive=False)
+        status = gr.Textbox(label="Status", value="Ready.", interactive=False)
+
+        async def on_reset(setup_text: str, verify_text: str):
+            result = await web_manager.reset_environment(
+                {"setup": _lines(setup_text), "verify": _lines(verify_text)}
+            )
+            state = state_payload()
+            return state, json.dumps(result, indent=2), "Sandbox reset."
+
+        async def on_close():
+            await web_manager._run_sync_in_thread_pool(web_manager.env.close)
+            return {}, "Session closed.", "Session closed."
+
+        async def on_bash(command: str, timeout: float):
+            result = await web_manager.step_environment(
+                {
+                    "tool_name": "bash",
+                    "arguments": {"command": command, "timeout": timeout},
+                }
+            )
+            return state_payload(), _extract_tool_text(result), "bash executed."
+
+        async def on_read(path: str):
+            result = await web_manager.step_environment(
+                {"tool_name": "read", "arguments": {"file_path": path}}
+            )
+            return state_payload(), _extract_tool_text(result), "read executed."
+
+        async def on_write(path: str, content: str):
+            result = await web_manager.step_environment(
+                {
+                    "tool_name": "write",
+                    "arguments": {"file_path": path, "content": content},
+                }
+            )
+            return state_payload(), _extract_tool_text(result), "write executed."
+
+        async def on_edit(path: str, old: str, new: str, all_matches: bool):
+            result = await web_manager.step_environment(
+                {
+                    "tool_name": "edit",
+                    "arguments": {
+                        "file_path": path,
+                        "old_string": old,
+                        "new_string": new,
+                        "replace_all": all_matches,
+                    },
+                }
+            )
+            return state_payload(), _extract_tool_text(result), "edit executed."
+
+        async def on_glob(pattern: str, path: str):
+            result = await web_manager.step_environment(
+                {"tool_name": "glob", "arguments": {"pattern": pattern, "path": path}}
+            )
+            return state_payload(), _extract_tool_text(result), "glob executed."
+
+        async def on_grep(pattern: str, path: str, include: str):
+            args: dict[str, Any] = {"pattern": pattern, "path": path}
+            if include.strip():
+                args["include"] = include
+            result = await web_manager.step_environment(
+                {"tool_name": "grep", "arguments": args}
+            )
+            return state_payload(), _extract_tool_text(result), "grep executed."
+
+        async def on_ls(path: str, ignore_csv: str):
+            ignore = [item.strip() for item in ignore_csv.split(",") if item.strip()]
+            result = await web_manager.step_environment(
+                {"tool_name": "ls", "arguments": {"path": path, "ignore": ignore or None}}
+            )
+            return state_payload(), _extract_tool_text(result), "ls executed."
+
+        async def on_todo(todo_raw: str):
+            todos = json.loads(todo_raw)
+            result = await web_manager.step_environment(
+                {"tool_name": "todo_write", "arguments": {"todos": todos}}
+            )
+            return state_payload(), _extract_tool_text(result), "todo_write executed."
+
+        async def on_submit():
+            result = await web_manager.step_environment(
+                {"tool_name": "submit_solution", "arguments": {}}
+            )
+            return state_payload(), _extract_tool_text(result), "submit_solution executed."
+
+        reset_btn.click(on_reset, [setup_input, verify_input], [state_view, output, status])
+        close_btn.click(on_close, outputs=[state_view, output, status])
+        bash_btn.click(on_bash, [bash_input, timeout_input], [state_view, output, status])
+        read_btn.click(on_read, [file_path], [state_view, output, status])
+        write_btn.click(on_write, [file_path, write_content], [state_view, output, status])
+        edit_btn.click(
+            on_edit,
+            [file_path, old_string, new_string, replace_all],
+            [state_view, output, status],
+        )
+        glob_btn.click(on_glob, [glob_pattern, glob_path], [state_view, output, status])
+        grep_btn.click(
+            on_grep, [grep_pattern, grep_path, grep_include], [state_view, output, status]
+        )
+        ls_btn.click(on_ls, [ls_path, ls_ignore], [state_view, output, status])
+        todo_btn.click(on_todo, [todos_json], [state_view, output, status])
+        submit_btn.click(on_submit, outputs=[state_view, output, status])
+
+    return demo

server/requirements.txt

@@ -0,0 +1,10 @@
+openenv-core[core]>=0.2.2
+e2b-code-interpreter>=1.0.0
+fastapi>=0.115.0
+fastmcp>=3.0.0
+gradio>=4.0.0
+pydantic>=2.0.0
+requests>=2.31.0
+uvicorn>=0.24.0
+
+