Upload folder using huggingface_hub

Dockerfile

@@ -1,35 +1,14 @@
-# Use public Python base image for HuggingFace compatibility
-FROM python:3.11-slim
+# Use the matching Playwright Python image for browsergym-core 0.14.3.
+FROM mcr.microsoft.com/playwright/python:v1.44.0-jammy
 
 # Set working directory
 WORKDIR /app/env
 
-# Install system dependencies for Playwright and browsers
+# Install only the extra packages this env still needs on top of the Playwright image.
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    # Playwright browser dependencies
-    libnss3 \
-    libnspr4 \
-    libatk1.0-0 \
-    libatk-bridge2.0-0 \
-    libcups2 \
-    libdrm2 \
-    libdbus-1-3 \
-    libxkbcommon0 \
-    libatspi2.0-0 \
-    libxcomposite1 \
-    libxdamage1 \
-    libxfixes3 \
-    libxrandr2 \
-    libgbm1 \
-    libpango-1.0-0 \
-    libcairo2 \
-    libasound2 \
-    libxshmfence1 \
     fonts-unifont \
     fonts-noto-color-emoji \
-    # Additional dependencies
     git \
-    wget \
     curl \
     && rm -rf /var/lib/apt/lists/*
 
@@ -40,15 +19,17 @@ COPY . .
 # Make start script executable
 RUN chmod +x /app/env/server/start.sh
 
-# Install Python dependencies using pip install -e . (from pyproject.toml)
-RUN pip install --no-cache-dir -e .
+RUN pip install --no-cache-dir uv
+RUN uv pip install --system --no-cache -e .
 
-# Install Playwright browsers (Chromium by default)
-# Use python -m since playwright command might not be in PATH
+# Ensure the installed Playwright package has a matching Chromium runtime.
 RUN python -m playwright install chromium
 
-# Install MiniWoB++ tasks
-RUN git clone --depth 1 https://github.com/Farama-Foundation/miniwob-plusplus.git /app/miniwob-plusplus
+# Install MiniWoB++ from a pinned snapshot to avoid flaky Hub-time git clones.
+ARG MINIWOB_COMMIT=7fd85d71a4b60325c6585396ec4f48377d049838
+RUN mkdir -p /app/miniwob-plusplus && \
+    curl -L "https://github.com/Farama-Foundation/miniwob-plusplus/archive/${MINIWOB_COMMIT}.tar.gz" \
+    | tar -xz --strip-components=1 -C /app/miniwob-plusplus
 
 # Set environment variables
 ENV PYTHONUNBUFFERED=1

README.md

@@ -73,6 +73,38 @@ for episode in range(1000):
 env.close()
 ```
 
+## Harness Sessions for TRL
+
+If you want BrowserGym to participate in a tool-driven harness instead of a
+hand-written `env.reset()` / `env.step()` loop, use the BrowserGym session
+factory:
+
+```python
+from browsergym_env import BrowserGymEnv
+from browsergym_env.harness import BrowserGymSessionFactory
+from openenv.core.harness import (
+    HarnessRunLimits,
+    MCPHarnessAdapter,
+    build_harness_rollout_func,
+)
+
+session_factory = BrowserGymSessionFactory(
+    client_factory=lambda: BrowserGymEnv(base_url="https://openenv-browsergym-env.hf.space"),
+)
+
+rollout_func = build_harness_rollout_func(
+    session_factory=session_factory,
+    harness_adapter=MCPHarnessAdapter(),
+    model_step_builder=...,  # trainer-owned model sampling
+    limits=HarnessRunLimits(max_turns=10),
+)
+```
+
+BrowserGym exposes `click`, `fill`, `send_keys`, `scroll`, and `noop` as MCP-style
+tools while still translating them back into the underlying `BrowserGymAction`
+strings. See [examples/browsergym_harness.py](https://github.com/meta-pytorch/OpenEnv/blob/main/examples/browsergym_harness.py)
+for a full TRL-oriented example.
+
 ### Available Tasks by Benchmark
 
 #### MiniWoB++ Tasks (Training - 100+ tasks)

__init__.py

@@ -61,12 +61,45 @@ Evaluation Example (WebArena - requires backend):
     ```
 """
 
+from __future__ import annotations
+
+from importlib import import_module
+from typing import TYPE_CHECKING
+
 from .client import BrowserGymEnv
 from .models import BrowserGymAction, BrowserGymObservation, BrowserGymState
 
+if TYPE_CHECKING:
+    from .harness import BrowserGymSessionFactory, build_browsergym_action_tool_call
+
 __all__ = [
     "BrowserGymEnv",
     "BrowserGymAction",
     "BrowserGymObservation",
     "BrowserGymState",
+    "BrowserGymSessionFactory",
+    "build_browsergym_action_tool_call",
 ]
+
+_LAZY_ATTRS = {
+    "BrowserGymSessionFactory": (".harness", "BrowserGymSessionFactory"),
+    "build_browsergym_action_tool_call": (
+        ".harness",
+        "build_browsergym_action_tool_call",
+    ),
+}
+
+
+def __getattr__(name: str):
+    if name not in _LAZY_ATTRS:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+    module_path, attr_name = _LAZY_ATTRS[name]
+    module = import_module(module_path, __name__)
+    value = getattr(module, attr_name)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals().keys()) | set(__all__))

harness.py

@@ -0,0 +1,290 @@
+"""Harness-oriented BrowserGym session adapters."""
+
+from __future__ import annotations
+
+import ast
+import json
+from typing import Any
+
+from openenv.core.env_server.mcp_types import Tool
+from openenv.core.harness import (
+    ResourceSessionFactory,
+    StepEnvSessionAdapter,
+    ToolResult,
+    VerifyResult,
+)
+from openenv.core.llm_client import ToolCall
+
+from .models import BrowserGymAction
+
+_BROWSERGYM_TOOLS = [
+    Tool(
+        name="click",
+        description="Click an element by BrowserGym bid.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "bid": {"type": "string"},
+            },
+            "required": ["bid"],
+        },
+    ),
+    Tool(
+        name="fill",
+        description="Fill an input field by bid.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "bid": {"type": "string"},
+                "text": {"type": "string"},
+            },
+            "required": ["bid", "text"],
+        },
+    ),
+    Tool(
+        name="send_keys",
+        description="Send keyboard input to the page.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "text": {"type": "string"},
+            },
+            "required": ["text"],
+        },
+    ),
+    Tool(
+        name="scroll",
+        description="Scroll the page up or down.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "direction": {"type": "string", "enum": ["up", "down"]},
+            },
+            "required": ["direction"],
+        },
+    ),
+    Tool(
+        name="noop",
+        description="Take no action on the current page.",
+        input_schema={"type": "object", "properties": {}},
+    ),
+]
+
+
+def _quote(value: str) -> str:
+    return json.dumps(value, ensure_ascii=False)
+
+
+def build_browsergym_action_str(tool_name: str, arguments: dict[str, Any]) -> str:
+    """Convert a BrowserGym tool call into the action string the env expects."""
+
+    if tool_name == "click":
+        return f"click({_quote(str(arguments['bid']))})"
+    if tool_name == "fill":
+        return (
+            f"fill({_quote(str(arguments['bid']))}, {_quote(str(arguments['text']))})"
+        )
+    if tool_name == "send_keys":
+        return f"send_keys({_quote(str(arguments['text']))})"
+    if tool_name == "scroll":
+        return f"scroll({_quote(str(arguments['direction']))})"
+    if tool_name == "noop":
+        return "noop()"
+
+    raise KeyError(f"Unsupported BrowserGym tool: {tool_name}")
+
+
+def _format_browsergym_prompt(observation: Any, task: Any) -> str:
+    goal = getattr(observation, "goal", "") or (task or "")
+    page_text = getattr(observation, "axtree_txt", "") or getattr(
+        observation, "text", ""
+    )
+    error = getattr(observation, "error", "")
+
+    parts = []
+    if goal:
+        parts.append(f"Goal: {goal}")
+    if error:
+        parts.append(f"Previous action error: {error}")
+    if page_text:
+        parts.append(f"Page structure:\n{page_text}")
+    parts.append("Choose the next browser action.")
+    return "\n\n".join(parts)
+
+
+def _build_browsergym_tool_result(
+    task: Any,
+):
+    def builder(
+        tool_name: str,
+        arguments: dict[str, Any],
+        result: Any,
+        state: Any,
+    ) -> ToolResult:
+        observation = result.observation
+        data = {
+            "tool_name": tool_name,
+            "arguments": dict(arguments),
+            "goal": getattr(observation, "goal", "") or (task or ""),
+            "observation_text": getattr(observation, "axtree_txt", "")
+            or getattr(observation, "text", ""),
+            "url": getattr(observation, "url", ""),
+            "error": getattr(observation, "error", ""),
+            "last_action_error": getattr(observation, "last_action_error", False),
+            "reward": result.reward,
+            "done": result.done,
+        }
+        metadata = {
+            "reward": result.reward,
+            "state": state.model_dump() if hasattr(state, "model_dump") else state,
+        }
+        return ToolResult(data=data, done=bool(result.done), metadata=metadata)
+
+    return builder
+
+
+def _build_browsergym_verify(
+    transcript: list[dict[str, Any]],
+    final_state: Any | None,
+    last_result: Any | None,
+    state: Any,
+) -> VerifyResult:
+    reward = None if last_result is None else last_result.reward
+    done = False if last_result is None else bool(last_result.done)
+    metrics = {
+        "step_count": getattr(state, "step_count", 0),
+        "cum_reward": getattr(state, "cum_reward", reward or 0.0),
+        "benchmark": getattr(state, "benchmark", ""),
+        "task_name": getattr(state, "task_name", ""),
+    }
+    artifacts = {
+        "final_state": state.model_dump() if hasattr(state, "model_dump") else state,
+        "final_rollout": final_state,
+        "transcript_length": len(transcript),
+    }
+    return VerifyResult(
+        env_reward=reward,
+        done=done,
+        metrics=metrics,
+        artifacts=artifacts,
+    )
+
+
+class BrowserGymSessionFactory(ResourceSessionFactory):
+    """Create BrowserGym-backed resource sessions from client factories."""
+
+    def __init__(self, client_factory, *, default_task: str | None = None):
+        self._client_factory = client_factory
+        self._default_task = default_task
+
+    def create(
+        self,
+        task: Any,
+        seed: int | None = None,
+        episode_id: str | None = None,
+    ) -> StepEnvSessionAdapter:
+        session_task = task if task is not None else self._default_task
+        client = self._client_factory()
+
+        reset_kwargs = {}
+        if session_task is not None:
+            reset_kwargs["task_name"] = session_task
+
+        return StepEnvSessionAdapter(
+            client=client,
+            task=session_task,
+            seed=seed,
+            episode_id=episode_id,
+            tool_specs=list(_BROWSERGYM_TOOLS),
+            action_builder=lambda name, arguments: BrowserGymAction(
+                action_str=build_browsergym_action_str(name, arguments)
+            ),
+            initial_messages_builder=lambda result, current_task: [
+                {
+                    "role": "user",
+                    "content": _format_browsergym_prompt(
+                        result.observation,
+                        current_task,
+                    ),
+                }
+            ],
+            tool_result_builder=_build_browsergym_tool_result(session_task),
+            verify_builder=_build_browsergym_verify,
+            reset_kwargs=reset_kwargs,
+        )
+
+
+def _parse_action_call(action_text: str) -> tuple[str, list[Any]]:
+    try:
+        expression = ast.parse(action_text.strip(), mode="eval").body
+    except SyntaxError as exc:
+        raise ValueError(f"Unsupported BrowserGym action: {action_text}") from exc
+
+    if not isinstance(expression, ast.Call) or not isinstance(
+        expression.func, ast.Name
+    ):
+        raise ValueError(f"Unsupported BrowserGym action: {action_text}")
+    if expression.keywords:
+        raise ValueError("BrowserGym action arguments must be positional")
+
+    args: list[Any] = []
+    for arg in expression.args:
+        try:
+            args.append(ast.literal_eval(arg))
+        except (SyntaxError, ValueError) as exc:
+            raise ValueError("BrowserGym action arguments must be literals") from exc
+
+    return expression.func.id, args
+
+
+def _expect_str(value: Any, argument_name: str) -> str:
+    if not isinstance(value, str):
+        raise ValueError(f"BrowserGym {argument_name} argument must be a string")
+    return value
+
+
+def build_browsergym_action_tool_call(action_text: str) -> ToolCall:
+    """Parse a text BrowserGym action into a structured tool call."""
+
+    name, args = _parse_action_call(action_text)
+    if name == "click" and len(args) == 1:
+        return ToolCall(
+            id="browsergym-click",
+            name="click",
+            args={"bid": _expect_str(args[0], "bid")},
+        )
+    if name == "fill" and len(args) == 2:
+        return ToolCall(
+            id="browsergym-fill",
+            name="fill",
+            args={
+                "bid": _expect_str(args[0], "bid"),
+                "text": _expect_str(args[1], "text"),
+            },
+        )
+    if name == "send_keys" and len(args) == 1:
+        return ToolCall(
+            id="browsergym-send_keys",
+            name="send_keys",
+            args={"text": _expect_str(args[0], "text")},
+        )
+    if name == "scroll" and len(args) == 1:
+        direction = _expect_str(args[0], "direction")
+        if direction not in {"up", "down"}:
+            raise ValueError("BrowserGym scroll direction must be 'up' or 'down'")
+        return ToolCall(
+            id="browsergym-scroll",
+            name="scroll",
+            args={"direction": direction},
+        )
+    if name == "noop" and not args:
+        return ToolCall(id="browsergym-noop", name="noop", args={})
+
+    raise ValueError(f"Unsupported BrowserGym action: {action_text}")
+
+
+__all__ = [
+    "BrowserGymSessionFactory",
+    "build_browsergym_action_str",
+    "build_browsergym_action_tool_call",
+]

models.py

@@ -21,7 +21,7 @@ class BrowserGymAction(Action):
     - "click('Submit button')"
     - "fill('username', 'john@example.com')"
     - "goto('https://example.com')"
-    - "scroll(down)"
+    - "scroll('down')"
     - "send_keys('Enter')"
     """
 

pyproject.toml

@@ -8,23 +8,18 @@ version = "0.1.0"
 description = "BrowserGym Environment for OpenEnv - Web automation using Playwright"
 requires-python = ">=3.10"
 dependencies = [
-    "openenv-core[core]>=0.2.1",
-    "fastapi>=0.104.0",
-    "uvicorn[standard]>=0.24.0",
-    "pydantic>=2.0.0",
-    "requests>=2.25.0",
-    "browsergym-core>=0.2.0",
-    "browsergym-miniwob>=0.2.0",
-    "browsergym-webarena>=0.2.0",
+    "openenv-core[core]>=0.2.3",
+    "browsergym-core==0.14.3",
+    "browsergym-miniwob==0.14.3",
     "gymnasium>=0.29.0",
-    "playwright>=1.40.0",
-    "greenlet>=3.1.0",  # Required for Python 3.13 compatibility
+    "playwright==1.44.0",
+    "greenlet==3.0.3",
     "Pillow>=10.0.0",
 ]
 
 [project.optional-dependencies]
 dev = [
-    "pytest>=8.0.0",
+    "pytest>=9.0.3",
     "pytest-cov>=4.0.0",
     "ipykernel>=6.29.5",
 ]

server/app.py

@@ -1,6 +1,7 @@
 """FastAPI server for the BrowserGym environment."""
 
 import os
+from functools import partial
 
 from browsergym_env.models import BrowserGymAction, BrowserGymObservation
 from browsergym_env.server.browsergym_environment import BrowserGymEnvironment
@@ -15,28 +16,22 @@ viewport_height = int(os.environ.get("BROWSERGYM_VIEWPORT_HEIGHT", "720"))
 timeout = float(os.environ.get("BROWSERGYM_TIMEOUT", "10000"))
 port = int(os.environ.get("BROWSERGYM_PORT", "8000"))
 
+max_concurrent = int(os.environ.get("MAX_CONCURRENT_ENVS", "8"))
 
-# Factory function to create BrowserGymEnvironment instances
-def create_browsergym_environment():
-    """Factory function that creates BrowserGymEnvironment with config."""
-    return BrowserGymEnvironment(
+app = create_app(
+    partial(
+        BrowserGymEnvironment,
         benchmark=benchmark,
         task_name=task_name,
         headless=headless,
         viewport_width=viewport_width,
         viewport_height=viewport_height,
         timeout=timeout,
-    )
-
-
-# Create the FastAPI app
-# Pass the factory function instead of an instance for WebSocket session support
-app = create_app(
-    create_browsergym_environment,
+    ),
     BrowserGymAction,
     BrowserGymObservation,
     env_name="browsergym_env",
-    max_concurrent_envs=64
+    max_concurrent_envs=max_concurrent,
 )
 
 

server/browsergym_environment.py

@@ -95,8 +95,9 @@ class BrowserGymEnvironment(Environment):
     provide unified access to multiple web navigation benchmarks.
     """
 
-    SUPPORTS_CONCURRENT_SESSIONS: bool = True
-    
+    SUPPORTS_CONCURRENT_SESSIONS = True
+    REQUIRES_SINGLE_THREAD_EXECUTOR = True
+
     def __init__(
         self,
         benchmark: str = "miniwob",
@@ -386,8 +387,5 @@ class BrowserGymEnvironment(Environment):
         if hasattr(self, "gym_env"):
             try:
                 self.gym_env.close()
-            except Exception:
-                # Playwright's sync API uses greenlets that can fail when close()
-                # is called from a different thread (e.g. async server cleanup).
-                # Swallow the error to avoid crashing the server.
-                pass
+            except Exception as exc:  # noqa: BLE001 - browsergym/playwright cleanup
+                logger.warning("BrowserGym cleanup failed: %s", exc)

server/requirements.txt

@@ -1,10 +1,7 @@
-browsergym>=0.10.0
-browsergym-core>=0.10.0
-browsergym-miniwob>=0.10.0
-browsergym-webarena>=0.10.0
+browsergym-core==0.14.3
+browsergym-miniwob==0.14.3
 gymnasium>=0.29.0
-playwright>=1.40.0
+playwright==1.44.0
+greenlet==3.0.3
 Pillow>=10.0.0
 beautifulsoup4>=4.12.0
-fastapi>=0.104.0
-uvicorn[standard]>=0.24.0