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=my_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"
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with the /app/env structure
+ENV ENABLE_WEB_INTERFACE=true
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

README.md

@@ -1,10 +1,122 @@
 ---
-title: My Env
-emoji: 🐠
+title: My Env Environment Server
+emoji: 💿
 colorFrom: yellow
-colorTo: blue
+colorTo: green
 sdk: docker
 pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
 ---
+# Maintenance-Bench
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+An **OpenEnv-based reinforcement learning environment for industrial maintenance diagnostics**.
+
+This repository provides the initial implementation of a diagnostic decision-making environment designed to evaluate **AI research agents on industrial troubleshooting tasks**.
+
+The environment is inspired by real-world industrial maintenance logs and is part of the **Maintenance-Bench benchmark**.
+
+---
+
+# Overview
+
+The environment simulates an **industrial diagnostic process** where an agent must decide which diagnostic steps to perform to identify a fault.
+
+Each episode corresponds to a **maintenance case scenario** stored as a JSON file.
+
+A scenario contains:
+
+- machine metadata
+- symptoms
+- possible diagnostic steps
+- observations for each step
+- rewards
+- operational costs
+
+The agent interacts with the environment through a **step-by-step diagnostic process**, receiving observations, rewards, accumulated costs, and the **current health status of the system**.
+
+---
+
+# Environment API
+
+The environment follows the **OpenEnv interface**:
+
+- `reset()` – loads a new diagnostic scenario and initializes an episode
+- `step(action)` – performs a diagnostic action and returns the observation
+
+---
+
+# Episode Flow
+
+1. The environment loads a diagnostic scenario from the `data/` directory.
+2. The agent receives the **initial symptom description**.
+3. The agent chooses a diagnostic action.
+4. The environment returns:
+
+- the observation  
+- reward  
+- accumulated cost  
+- **health status of the system**  
+- history of performed steps  
+
+---
+
+# Example Interaction
+
+Example sequence of actions:
+
+```python
+reset()
+```
+
+Agent observation:
+
+```
+"High Bearing temperature."
+```
+
+Agent performs diagnostic step:
+
+```python
+action = "diagnose:0"
+```
+
+Environment response:
+
+```
+Observation:
+"Overload relay found tripped at the time of breakdown."
+
+Reward: 1
+Total Cost: 5
+done: False #equivalent to health status 0
+
+History:
+[
+  {
+    "action": "Monitored bearing temperatures at DE and NDE using RTD.",
+    "observation": "Overload relay found tripped at the time of breakdown."
+  }
+]
+```
+
+---
+
+# Project Goal
+
+The goal of this project is to provide a **benchmark environment for evaluating deep research agents on industrial maintenance diagnostics tasks**.
+
+This environment supports research in:
+
+- autonomous troubleshooting agents
+- cost-aware reasoning
+- industrial decision making
+- long-horizon diagnostic planning
+
+---
+
+# License
+
+This project builds on **OpenEnv** and follows the license terms of the respective components.

__init__.py

@@ -0,0 +1,16 @@
+# 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.
+
+"""My Env Environment."""
+
+from .client import MyEnv
+from .models import MyAction, MyObservation
+
+__all__ = [
+    "MyAction",
+    "MyObservation",
+    "MyEnv",
+]

client.py

@@ -0,0 +1,102 @@
+# 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.
+
+"""My Env Environment Client."""
+
+from typing import Dict
+
+from openenv.core import EnvClient
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+
+from .models import MyAction, MyObservation
+
+import sys
+
+sys.path.append('.')
+
+class MyEnv(
+    EnvClient[MyAction, MyObservation, State]
+):
+    """
+    Client for the My Env Environment.
+
+    This client maintains a persistent WebSocket connection to the environment server,
+    enabling efficient multi-step interactions with lower latency.
+    Each client instance has its own dedicated environment session on the server.
+
+    Example:
+        >>> # Connect to a running server
+        >>> with MyEnv(base_url="http://localhost:8000") as client:
+        ...     result = client.reset()
+        ...     print(result.observation.echoed_message)
+        ...
+        ...     result = client.step(MyAction(message="Hello!"))
+        ...     print(result.observation.echoed_message)
+
+    Example with Docker:
+        >>> # Automatically start container and connect
+        >>> client = MyEnv.from_docker_image("my_env-env:latest")
+        >>> try:
+        ...     result = client.reset()
+        ...     result = client.step(MyAction(message="Test"))
+        ... finally:
+        ...     client.close()
+    """
+
+    def _step_payload(self, action: MyAction) -> Dict:
+        """
+        Convert MyAction to JSON payload for step message.
+
+        Args:
+            action: MyAction instance
+
+        Returns:
+            Dictionary representation suitable for JSON encoding
+        """
+        return {
+            "message": action.message,
+        }
+
+    def _parse_result(self, payload: Dict) -> StepResult[MyObservation]:
+        """
+        Parse server response into StepResult[MyObservation].
+
+        Args:
+            payload: JSON response data from server
+
+        Returns:
+            StepResult with MyObservation
+        """
+        obs_data = payload.get("observation", {})
+        observation = MyObservation(
+            echoed_message=obs_data.get("echoed_message", ""),
+            message_length=obs_data.get("message_length", 0),
+            done=payload.get("done", False),
+            reward=payload.get("reward"),
+            metadata=obs_data.get("metadata", {}),
+        )
+
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward"),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> State:
+        """
+        Parse server response into State object.
+
+        Args:
+            payload: JSON response from state request
+
+        Returns:
+            State object with episode_id and step_count
+        """
+        return State(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+        )

data/1.json

@@ -0,0 +1,80 @@
+{
+  "case_id": "80",
+  "motor_id": "<<A068>>",
+  "area": "<<HSM>",
+  "line": "<<Furnace Area>>",
+  "rating_kw": 400,
+  "log_book_entry_date": "2024-05-14",
+  "failure_type": "<<Breakdown>>",
+  "symptom_text": "<<High Bearing temperature.>>",
+  "diagnostic_steps": [
+    "Monitored bearing temperatures at DE and NDE using RTD.",
+    "Monitored vibration severity at DE and NDE using vibration meter / physical assessment.",
+    "Checked rotor free movement by manual rotation.",
+    "Inspected coupling condition for seizure, wear, or damage.",
+    "Verified motor-gearbox alignment condition.",
+    "Checked foundation bolts and base plate tightness.",
+    "Inspected bearing lubrication condition and grease contamination."
+  ],
+  "diagnostic_steps_rewards": [
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+  ],
+  "diagnostic_steps_costs": [
+    5, 
+    10, 
+    5, 
+    15, 
+    45, 
+    10, 
+    15
+  ],
+  "observations": [
+    "Overload relay found tripped at the time of breakdown.",
+    "Incoming supply voltage and phase current were normal with no imbalance.",
+    "Insulation resistance (IR) values were within acceptable limits, indicating no electrical fault.",
+    "Normal vibration observed during motor operation.",
+    "NDE bearing temperature was normal when checked using laser thermometer.",
+    "Rotor free movement was ok.",
+    "NDE Bearing fine."
+  ],
+  "root_cause": "Bearing seizure at NDE causing overload trip",
+  "rectification": [
+    "Replaced NDE bearing",
+    "Cleaned and greased housings",
+     "Checked alignment",
+    "Performed no-load and load trials",
+    "Reset motor overload relay",
+    "Replace motor starter contactor",
+    "Reprogram the VFD acceleration ramp time"
+  ],
+  "rectification_rewards": [
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0
+  ],
+  "rectification_costs":[
+    120, 
+    30, 
+    60, 
+    90, 
+    10, 
+    45, 
+    15
+  ],
+  "verification": "Motor tested OK after repair",
+  "reasoning": "<<Electrical causes eliminated as IR and supply were normal. Tight rotor and high bearing temperature indicated mechanical loading. Bearing replacement.>>",
+  "failure_bucket": "Bearing Failure",
+  "severity": " Medium",
+  "repeat_failure": true
+}
+

models.py

@@ -0,0 +1,28 @@
+# 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.
+
+"""
+Data models for the My Env Environment.
+
+The my_env environment is a simple test environment that echoes back messages.
+"""
+
+from openenv.core.env_server.types import Action, Observation
+from pydantic import Field
+from typing import List, Dict
+class MyAction(Action):
+    """Action for the My Env environment - just a message to echo."""
+
+    message: str = Field(..., description="Message to echo back")
+
+
+class MyObservation(Observation):
+    """Observation from the My Env environment - the echoed message."""
+
+    echoed_message: str = Field(default="", description="The echoed message")
+    message_length: int = Field(default=0, description="Length of the echoed message")
+    total_cost: int = Field(default=0, description="Total cost until now in the episode")
+    history: List[Dict] = Field(default_factory=list)

openenv.yaml

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

openenv_my_env.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: openenv-my_env
+Version: 0.1.0
+Summary: My Env environment for OpenEnv
+Requires-Python: >=3.10
+Requires-Dist: openenv-core[core]>=0.2.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

openenv_my_env.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+__init__.py
+client.py
+models.py
+pyproject.toml
+./__init__.py
+./client.py
+./models.py
+openenv_my_env.egg-info/PKG-INFO
+openenv_my_env.egg-info/SOURCES.txt
+openenv_my_env.egg-info/dependency_links.txt
+openenv_my_env.egg-info/entry_points.txt
+openenv_my_env.egg-info/requires.txt
+openenv_my_env.egg-info/top_level.txt
+server/__init__.py
+server/app.py
+server/my_env_environment.py

openenv_my_env.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openenv_my_env.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+server = my_env.server.app:main

openenv_my_env.egg-info/requires.txt

@@ -0,0 +1,5 @@
+openenv-core[core]>=0.2.1
+
+[dev]
+pytest>=8.0.0
+pytest-cov>=4.0.0

openenv_my_env.egg-info/top_level.txt

@@ -0,0 +1 @@
+my_env

pyproject.toml

@@ -0,0 +1,45 @@
+# 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-my_env"
+version = "0.1.0"
+description = "My Env environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    # Core OpenEnv runtime (provides FastAPI server + HTTP client types)
+    # install from github
+    # "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git",
+    "openenv-core[core]>=0.2.1",
+    # Environment-specific dependencies
+    # Add all dependencies needed for your environment here
+    # Examples:
+    # "numpy>=1.19.0",
+    # "torch>=2.0.0",
+    # "gymnasium>=0.29.0",
+    # "openspiel>=1.0.0",
+    # "smolagents>=1.22.0,<2",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+# Server entry point - enables running via: uv run --project . server
+# or: python -m my_env.server.app
+server = "my_env.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["my_env", "my_env.server"]
+package-dir = { "my_env" = ".", "my_env.server" = "server" }

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.
+
+"""My Env environment server components."""
+
+from .my_env_environment import MyEnvironment
+
+__all__ = ["MyEnvironment"]

server/app.py

@@ -0,0 +1,82 @@
+# 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 application for the My Env Environment.
+
+This module creates an HTTP server that exposes the MyEnvironment
+over HTTP and WebSocket endpoints, compatible with EnvClient.
+
+Endpoints:
+    - POST /reset: Reset the environment
+    - POST /step: Execute an action
+    - GET /state: Get current environment state
+    - GET /schema: Get action/observation schemas
+    - WS /ws: WebSocket endpoint for persistent sessions
+
+Usage:
+    # Development (with auto-reload):
+    uvicorn server.app:app --reload --host 0.0.0.0 --port 8000
+
+    # Production:
+    uvicorn server.app:app --host 0.0.0.0 --port 8000 --workers 4
+
+    # Or run directly:
+    python -m server.app
+"""
+
+try:
+    from openenv.core.env_server.http_server import create_app
+except Exception as e:  # pragma: no cover
+    raise ImportError(
+        "openenv is required for the web interface. Install dependencies with '\n    uv sync\n'"
+    ) from e
+
+# Import from local models.py (PYTHONPATH includes /app/env in Docker)
+from models import MyAction, MyObservation
+
+from .my_env_environment import MyEnvironment
+
+
+# Create the app with web interface and README integration
+app = create_app(
+    MyEnvironment,
+    MyAction,
+    MyObservation,
+    env_name="my_env",
+    max_concurrent_envs=1,  # increase this number to allow more concurrent WebSocket sessions
+)
+
+
+def main(host: str = "0.0.0.0", port: int = 8000):
+    """
+    Entry point for direct execution via uv run or python -m.
+
+    This function enables running the server without Docker:
+        uv run --project . server
+        uv run --project . server --port 8001
+        python -m my_env.server.app
+
+    Args:
+        host: Host address to bind to (default: "0.0.0.0")
+        port: Port number to listen on (default: 8000)
+
+    For production deployments, consider using uvicorn directly with
+    multiple workers:
+        uvicorn my_env.server.app:app --workers 4
+    """
+    import uvicorn
+
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--port", type=int, default=8000)
+    args = parser.parse_args()
+    main(port=args.port)

server/my_env_environment.py

@@ -0,0 +1,150 @@
+# 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.
+
+"""
+My Env Environment Implementation.
+
+A simple test environment that echoes back messages sent to it.
+Perfect for testing HTTP server infrastructure.
+"""
+
+from uuid import uuid4
+import os
+import json
+from models import MyAction, MyObservation
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import State
+
+EPISODES = {}
+class MyEnvironment(Environment):
+    """
+    A simple echo environment that echoes back messages.
+
+    This environment is designed for testing the HTTP server infrastructure.
+    It maintains minimal state and simply echoes back whatever message it receives.
+
+    Example:
+        >>> env = MyEnvironment()
+        >>> obs = env.reset()
+        >>> print(obs.echoed_message)  # "My Env environment ready!"
+        >>>
+        >>> obs = env.step(MyAction(message="Hello"))
+        >>> print(obs.echoed_message)  # "Hello"
+        >>> print(obs.message_length)  # 5
+    """
+
+    # Enable concurrent WebSocket sessions.
+    # Set to True if your environment isolates state between instances.
+    # When True, multiple WebSocket clients can connect simultaneously, each
+    # getting their own environment instance (when using factory mode in app.py).
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self):
+
+        self.data_folder = "data"
+
+        self.files = sorted([
+            f for f in os.listdir(self.data_folder)
+            if f.endswith(".json")
+        ])
+
+        self.current_index = -1
+
+        # persistent environment state
+        self._state = State(
+            episode_id=str(uuid4()),
+            step_count=0,
+            data={}
+            )
+    def reset(self, episode_id: str = "default"):
+
+        self.current_index += 1
+        if self.current_index >= len(self.files):
+            self.current_index = 0
+
+        file_path = os.path.join(self.data_folder, self.files[self.current_index])
+
+        with open(file_path) as f:
+            scenario = json.load(f)
+
+        # create episode memory
+        EPISODES[episode_id] = {
+            "scenario": scenario,
+            "history": [],
+            "total_cost": 0,
+            "total_reward": 0,
+            "step_count": 0
+        }
+
+        # reset state metadata
+        self._state = State(
+            episode_id=episode_id,
+            step_count=0,
+            data={}  # not used anymore
+        )
+
+        return MyObservation(
+            echoed_message=scenario["symptom_text"],
+            message_length=len(scenario["symptom_text"]),
+            total_cost=0,
+            history=[],
+            reward=0,
+            done=False
+        )
+    def step(self, action: MyAction, episode_id: str = "default") -> MyObservation:
+
+        data = EPISODES[episode_id]
+
+        scenario = data["scenario"]
+        history = data["history"]
+        total_cost = data["total_cost"]
+        total_reward = data["total_reward"]
+
+        self._state.step_count += 1
+        data["step_count"] += 1
+
+        message = action.message
+
+        if message.startswith("diagnose:"):
+
+            idx = int(message.split(":")[1])
+
+            step = scenario["diagnostic_steps"][idx]
+            obs = scenario["observations"][idx]
+
+            reward = scenario["diagnostic_steps_rewards"][idx]
+            cost = scenario["diagnostic_steps_costs"][idx]
+
+            total_reward += reward
+            total_cost += cost
+
+            history.append({
+                "action": step,
+                "observation": obs
+            })
+
+            # save updates
+            data["history"] = history
+            data["total_cost"] = total_cost
+            data["total_reward"] = total_reward
+
+            return MyObservation(
+                echoed_message=obs,
+                message_length=len(obs),
+                total_cost=total_cost,
+                history=history,
+                reward=reward,
+                done=False
+            )
+    @property
+    def state(self) -> State:
+        """
+        Get the current environment state.
+
+        Returns:
+            Current State with episode_id and step_count
+        """
+        return self._state

server/requirements.txt

@@ -0,0 +1,6 @@
+openenv[core]>=0.2.0
+fastapi>=0.115.0
+uvicorn>=0.24.0
+
+
+