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=openenv_jayesh
+
+# 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"]

__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.
+
+"""Openenv Jayesh Environment."""
+
+from .client import OpenenvJayeshEnv
+from .models import OpenenvJayeshAction, OpenenvJayeshObservation
+
+__all__ = [
+    "OpenenvJayeshAction",
+    "OpenenvJayeshObservation",
+    "OpenenvJayeshEnv",
+]

client.py

@@ -0,0 +1,54 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+"""Openenv Jayesh 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
+
+try:
+    from .models import TaskManagerAction, TaskManagerObservation
+except ImportError:
+    from models import TaskManagerAction, TaskManagerObservation
+
+
+class OpenenvJayeshEnv(
+    EnvClient[TaskManagerAction, TaskManagerObservation, State]
+):
+    """Client for the Task Manager Environment."""
+
+    def _step_payload(self, action: TaskManagerAction) -> Dict:
+        """Convert TaskManagerAction to JSON payload."""
+        return {
+            "command": action.command,
+            "title": action.title,
+            "priority": action.priority,
+            "deadline": action.deadline
+        }
+
+    def _parse_result(self, payload: Dict) -> StepResult[TaskManagerObservation]:
+        """Parse server response."""
+        obs_data = payload.get("observation", {})
+        observation = TaskManagerObservation(
+            success=obs_data.get("success", True),
+            message=obs_data.get("message", ""),
+            tasks=obs_data.get("tasks", []),
+            done=payload.get("done", False),
+            reward=payload.get("reward", 0.0),
+            metadata=obs_data.get("metadata", {}),
+        )
+
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward", 0.0),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> State:
+        return State(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+        )

inference.py

@@ -0,0 +1,66 @@
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from client import OpenenvJayeshEnv
+from models import TaskManagerAction
+
+def run_easy_task(client):
+    print("\n=== Scenario: Easy ===")
+    res = client.reset()
+    default_msg = res.observation.message if hasattr(res.observation, 'message') else "No message"
+    print(f"Goal: {default_msg}")
+
+    res = client.step(TaskManagerAction(command="add", title="Buy groceries", priority="Normal"))
+    print(f"Action 'add 1': {res.observation.message} | Score: {res.reward}")
+    res = client.step(TaskManagerAction(command="add", title="Do laundry", priority="Low"))
+    print(f"Action 'add 2': {res.observation.message} | Score: {res.reward}")
+    res = client.step(TaskManagerAction(command="list"))
+    print(f"Action 'list': {res.observation.message} | Score: {res.reward} | Done: {res.done}")
+
+def run_medium_task(client):
+    print("\n=== Scenario: Medium ===")
+    res = client.reset()
+    default_msg = res.observation.message if hasattr(res.observation, 'message') else "No message"
+    print(f"Goal: {default_msg}")
+    
+    res = client.step(TaskManagerAction(command="add", title="Write code", priority="Normal"))
+    print(f"Action 'add Normal': {res.observation.message} | Score: {res.reward}")
+    res = client.step(TaskManagerAction(command="add", title="Review PR", priority="High"))
+    print(f"Action 'add High': {res.observation.message} | Score: {res.reward}")
+    res = client.step(TaskManagerAction(command="add", title="Check emails", priority="Low"))
+    print(f"Action 'add Low': {res.observation.message} | Score: {res.reward}")
+    
+    res = client.step(TaskManagerAction(command="complete", title="Review PR"))
+    print(f"Action 'complete High': {res.observation.message} | Score: {res.reward} | Done: {res.done}")
+
+def run_hard_task(client):
+    print("\n=== Scenario: Hard ===")
+    res = client.reset()
+    default_msg = res.observation.message if hasattr(res.observation, 'message') else "No message"
+    print(f"Goal: {default_msg}")
+    
+    res = client.step(TaskManagerAction(command="add", title="Fix prod bug", priority="High"))
+    print(f"Action 'add High 1': {res.observation.message} | Score: {res.reward}")
+    res = client.step(TaskManagerAction(command="add", title="Write incident report", priority="High"))
+    print(f"Action 'add High 2': {res.observation.message} | Score: {res.reward}")
+    res = client.step(TaskManagerAction(command="add", title="Refactor", priority="Normal"))
+    print(f"Action 'add Normal': {res.observation.message} | Score: {res.reward}")
+    res = client.step(TaskManagerAction(command="add", title="Update docs", priority="Low"))
+    print(f"Action 'add Low': {res.observation.message} | Score: {res.reward}")
+    
+    res = client.step(TaskManagerAction(command="complete", title="Fix prod bug"))
+    print(f"Action 'complete High 1': {res.observation.message} | Score: {res.reward}")
+    res = client.step(TaskManagerAction(command="complete", title="Write incident report"))
+    print(f"Action 'complete High 2': {res.observation.message} | Score: {res.reward} | Done: {res.done}")
+
+
+if __name__ == "__main__":
+    print("Connecting to OpenEnv Task Manager Server on http://127.0.0.1:8000...")
+    try:
+        with OpenenvJayeshEnv(base_url="http://127.0.0.1:8000").sync() as client:
+            run_easy_task(client)
+            run_medium_task(client)
+            run_hard_task(client)
+    except Exception as e:
+        print(f"Error connecting to server. Is it running? {e}")

models.py

@@ -0,0 +1,23 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+"""
+Data models for the Openenv Jayesh Task Manager Environment.
+"""
+
+from typing import Optional, List, Dict, Any
+from openenv.core.env_server.types import Action, Observation
+from pydantic import Field
+
+class TaskManagerAction(Action):
+    """Action for the Task Manager."""
+    command: str = Field(..., description="The command to execute: 'add', 'complete', 'list'")
+    title: Optional[str] = Field(default=None, description="Task title (for 'add' or 'complete')")
+    priority: Optional[str] = Field(default="Normal", description="Task priority (for 'add')")
+    deadline: Optional[str] = Field(default=None, description="Task deadline (for 'add')")
+
+class TaskManagerObservation(Observation):
+    """Observation from the Task Manager."""
+    success: bool = Field(default=True, description="Whether the action succeeded")
+    message: str = Field(default="", description="System message or error")
+    tasks: List[Dict[str, Any]] = Field(default_factory=list, description="List of tasks in the system")

openenv.yaml

@@ -0,0 +1,11 @@
+spec_version: 1
+name: task-manager-openenv
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000
+description: "OpenEnv Hackathon Task Manager: AI agent environment tracking task states through Easy, Medium, and Hard dynamic constraints."
+tags:
+  - task-manager
+  - productivity
+  - openenv

openenv_openenv_jayesh.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: openenv-openenv_jayesh
+Version: 0.1.0
+Summary: Openenv Jayesh 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_openenv_jayesh.egg-info/SOURCES.txt

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

openenv_openenv_jayesh.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openenv_openenv_jayesh.egg-info/entry_points.txt

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

openenv_openenv_jayesh.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_openenv_jayesh.egg-info/top_level.txt

@@ -0,0 +1 @@
+openenv_jayesh

out.py

@@ -0,0 +1,201 @@
+class Environment(ABC, Generic[ActT, ObsT, StateT]):
+    """Base class for all environment servers following Gym/Gymnasium API.
+
+    Args:
+        transform: Optional transform to apply to observations
+        rubric: Optional rubric for reward computation. When provided, the
+            rubric's output can be used to set the observation's reward in step().
+
+    Class Attributes:
+        SUPPORTS_CONCURRENT_SESSIONS: Whether this environment supports concurrent sessions.
+            When True, multiple WebSocket connections can each have their own
+            environment instance (up to max_concurrent_envs). When False (default),
+            the environment should only be used with a single session at a time.
+
+            Set this to True in your Environment subclass if:
+            - The environment uses proper session isolation (e.g., unique working dirs)
+            - No shared mutable state exists between instances
+            - External resources (databases, APIs) can handle concurrent access
+
+    Attributes:
+        rubric: Optional rubric for computing rewards. Environments can set this
+            in __init__ and use it in step() to compute observation rewards.
+            Training infrastructure can access it for introspection:
+                for name, r in env.rubric.named_rubrics():
+                    print(f"{name}: {r.last_score}")
+
+    See RFC 004 for rubric design: rfcs/004-rubrics.md
+    """
+
+    # Class-level flag indicating whether this environment supports concurrent sessions
+    SUPPORTS_CONCURRENT_SESSIONS: bool = False
+
+    # Optional rubric for reward computation
+    rubric: Optional["Rubric"]
+
+    def __init__(
+        self,
+        transform: Optional[Transform[ObsT]] = None,
+        rubric: Optional["Rubric"] = None,
+    ):
+        self.transform = transform
+        self.rubric = rubric
+
+    @abstractmethod
+    def reset(
+        self,
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+        **kwargs: Any,
+    ) -> ObsT:
+        """Reset the environment and return initial observation."""
+        pass
+
+    async def reset_async(
+        self,
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+        **kwargs: Any,
+    ) -> ObsT:
+        """Async version of reset. Default implementation calls sync reset.
+
+        Override to provide true async implementation.
+        """
+        return self.reset(seed=seed, episode_id=episode_id, **kwargs)
+
+    @abstractmethod
+    def step(
+        self,
+        action: ActT,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> ObsT:
+        """Take a step in the environment."""
+        pass
+
+    async def step_async(
+        self,
+        action: ActT,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> ObsT:
+        """Async version of step. Default implementation calls sync step.
+
+        Override to provide true async implementation.
+        """
+        return self.step(action, timeout_s=timeout_s, **kwargs)
+
+    @property
+    @abstractmethod
+    def state(self) -> StateT:
+        """Get the current environment state."""
+        pass
+
+    def get_metadata(self) -> EnvironmentMetadata:
+        """
+        Get metadata about this environment.
+
+        Override this method to provide custom metadata for the environment.
+        Default implementation returns basic metadata derived from class name.
+
+        Returns:
+            EnvironmentMetadata with environment information
+        """
+        return EnvironmentMetadata(
+            name=self.__class__.__name__,
+            description=f"{self.__class__.__name__} environment",
+            version="1.0.0",
+        )
+
+    def _apply_transform(self, observation: ObsT) -> ObsT:
+        """Apply transform if one is provided."""
+        if self.transform is not None:
+            return self.transform(observation)
+        return observation
+
+    def _apply_rubric(self, action: ActT, observation: ObsT) -> float:
+        """Apply rubric if one is provided.
+
+        Args:
+            action: The action taken by the agent.
+            observation: The resulting observation.
+
+        Returns:
+            Reward value from the rubric, or 0.0 if no rubric is set.
+
+        Usage in step():
+            def step(self, action: MyAction, ...) -> MyObservation:
+                # ... execute action and create observation ...
+                observation.reward = self._apply_rubric(action, observation)
+                return observation
+        """
+        if self.rubric is not None:
+            return self.rubric(action, observation)
+        return 0.0
+
+    async def _apply_rubric_async(self, action: ActT, observation: ObsT) -> float:
+        """Apply rubric asynchronously if one is provided.
+
+        Args:
+            action: The action taken by the agent.
+            observation: The resulting observation.
+
+        Returns:
+            Reward value from the rubric, or 0.0 if no rubric is set.
+
+        Usage in step_async():
+            async def step_async(self, action: MyAction, ...) -> MyObservation:
+                # ... execute action and create observation ...
+                observation.reward = await self._apply_rubric_async(action, observation)
+                return observation
+        """
+        if self.rubric is not None:
+            result = self.rubric(action, observation)
+            # If rubric returns a coroutine, await it
+            if inspect.iscoroutine(result):
+                return await result
+            return result
+        return 0.0
+
+    def _reset_rubric(self) -> None:
+        """Reset the rubric state if one is provided.
+
+        Call this in reset() to clear any trajectory state in the rubric.
+
+        Usage in reset():
+            def reset(self, ...) -> MyObservation:
+                self._reset_rubric()
+                # ... create initial observation ...
+                return observation
+        """
+        if self.rubric is not None:
+            self.rubric.reset()
+
+    async def _reset_rubric_async(self) -> None:
+        """Reset the rubric state asynchronously if one is provided.
+
+        Call this in reset_async() to clear any trajectory state in the rubric.
+
+        Usage in reset_async():
+            async def reset_async(self, ...) -> MyObservation:
+                await self._reset_rubric_async()
+                # ... create initial observation ...
+                return observation
+        """
+        if self.rubric is not None:
+            # Check if rubric has async reset method
+            if hasattr(self.rubric, "reset_async"):
+                result = self.rubric.reset_async()
+                if inspect.iscoroutine(result):
+                    await result
+            else:
+                self.rubric.reset()
+
+    def close(self) -> None:
+        """Clean up resources used by the environment.
+
+        Override this method to implement custom cleanup logic.
+        Called when the environment is being destroyed or reset.
+        """
+        pass
+

out_utf8.txt

@@ -0,0 +1,23 @@
+Connecting to OpenEnv Task Manager Server on http://127.0.0.1:8000...
+
+=== Scenario: Easy ===
+Goal: Task Manager started in Easy mode. Goal: Add 2 tasks and list them.
+Action 'add 1': Task 'Buy groceries' added successfully. (Priority: Normal) | Score: 0.4
+Action 'add 2': Task 'Do laundry' added successfully. (Priority: Low) | Score: 0.8
+Action 'list': Listed 2 current tasks. | Score: 1.0 | Done: True
+
+=== Scenario: Medium ===
+Goal: Task Manager started in Medium mode. Goal: Add 3 tasks (mixed priorities) and complete all High priority ones.
+Action 'add Normal': Task 'Write code' added successfully. (Priority: Normal) | Score: 0.2
+Action 'add High': Task 'Review PR' added successfully. (Priority: High) | Score: 0.5
+Action 'add Low': Task 'Check emails' added successfully. (Priority: Low) | Score: 0.7
+Action 'complete High': Task 'Review PR' marked as completed. | Score: 1.0 | Done: True
+
+=== Scenario: Hard ===
+Goal: Task Manager started in Hard mode. Goal: Add 4 tasks (at least 2 High) and complete at least 2 High priority tasks.
+Action 'add High 1': Task 'Fix prod bug' added successfully. (Priority: High) | Score: 0.2
+Action 'add High 2': Task 'Write incident report' added successfully. (Priority: High) | Score: 0.4
+Action 'add Normal': Task 'Refactor' added successfully. (Priority: Normal) | Score: 0.5
+Action 'add Low': Task 'Update docs' added successfully. (Priority: Low) | Score: 0.6
+Action 'complete High 1': Task 'Fix prod bug' marked as completed. | Score: 0.8
+Action 'complete High 2': Task 'Write incident report' marked as completed. | Score: 1.0 | Done: True

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-openenv_jayesh"
+version = "0.1.0"
+description = "Openenv Jayesh 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 openenv_jayesh.server.app
+server = "openenv_jayesh.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["openenv_jayesh", "openenv_jayesh.server"]
+package-dir = { "openenv_jayesh" = ".", "openenv_jayesh.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.
+
+"""Openenv Jayesh environment server components."""
+
+from .openenv_jayesh_environment import OpenenvJayeshEnvironment
+
+__all__ = ["OpenenvJayeshEnvironment"]

server/app.py

@@ -0,0 +1,42 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+"""
+FastAPI application for the Openenv Jayesh Environment.
+"""
+
+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
+
+try:
+    from ..models import TaskManagerAction, TaskManagerObservation
+    from .openenv_jayesh_environment import OpenenvJayeshEnvironment
+except (ModuleNotFoundError, ImportError):
+    from models import TaskManagerAction, TaskManagerObservation
+    from server.openenv_jayesh_environment import OpenenvJayeshEnvironment
+
+
+app = create_app(
+    OpenenvJayeshEnvironment,
+    TaskManagerAction,
+    TaskManagerObservation,
+    env_name="openenv_jayesh",
+    max_concurrent_envs=1,
+)
+
+def main(host: str = "0.0.0.0", port: int = 8000):
+    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/openenv_jayesh_environment.py

@@ -0,0 +1,185 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+"""
+Openenv Jayesh Environment Implementation.
+A Simple Task Manager Environment.
+"""
+
+from typing import Optional, Any
+from uuid import uuid4
+
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import State
+
+try:
+    from ..models import TaskManagerAction, TaskManagerObservation
+except (ModuleNotFoundError, ImportError):
+    from models import TaskManagerAction, TaskManagerObservation
+
+
+class OpenenvJayeshEnvironment(Environment):
+    """A Task Manager environment with 3 difficulty modes."""
+
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self):
+        super().__init__()
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self._reset_count = 0
+        self._scenarios = ["Easy", "Medium", "Hard"]
+        
+        # Internal state
+        self.tasks = []
+        self.difficulty = "Easy"
+        self.goal_completed = False
+        self.tasks_added = 0
+        self.high_priority_added = 0
+        self.high_priority_completed = 0
+        self.list_called = False
+
+    def reset(
+        self,
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+        **kwargs: Any,
+    ) -> TaskManagerObservation:
+        """Reset the environment."""
+        self._state = State(episode_id=episode_id or str(uuid4()), step_count=0)
+        
+        idx = self._reset_count % len(self._scenarios)
+        self.difficulty = self._scenarios[idx]
+        self._reset_count += 1
+        
+        self.tasks = []
+        self.goal_completed = False
+        self.tasks_added = 0
+        self.high_priority_added = 0
+        self.high_priority_completed = 0
+        self.list_called = False
+        
+        message = f"Task Manager started in {self.difficulty} mode. "
+        if self.difficulty == "Easy":
+            message += "Goal: Add 2 tasks and list them."
+        elif self.difficulty == "Medium":
+            message += "Goal: Add 3 tasks (mixed priorities) and complete all High priority ones."
+        elif self.difficulty == "Hard":
+            message += "Goal: Add 4 tasks (at least 2 High) and complete at least 2 High priority tasks."
+            
+        return TaskManagerObservation(
+            success=True,
+            message=message,
+            tasks=self.tasks,
+            done=False,
+            reward=0.0
+        )
+
+    def step(
+        self,
+        action: TaskManagerAction,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> TaskManagerObservation:  # type: ignore[override]
+        """Execute a step."""
+        self._state.step_count += 1
+        
+        cmd = action.command.lower()
+        success = True
+        message = ""
+        
+        if cmd == "add":
+            if not action.title:
+                success = False
+                message = "Title is required to add a task."
+            else:
+                prio = action.priority or "Normal"
+                new_task = {
+                    "title": action.title,
+                    "priority": prio,
+                    "deadline": action.deadline or "N/A",
+                    "completed": False
+                }
+                self.tasks.append(new_task)
+                self.tasks_added += 1
+                if prio == "High":
+                    self.high_priority_added += 1
+                message = f"Task '{action.title}' added successfully. (Priority: {prio})"
+        elif cmd == "complete":
+            if not action.title:
+                success = False
+                message = "Title is required to complete a task."
+            else:
+                found = False
+                for t in self.tasks:
+                    if t["title"] == action.title:
+                        if not t["completed"]:
+                            t["completed"] = True
+                            if t["priority"] == "High":
+                                self.high_priority_completed += 1
+                        found = True
+                        message = f"Task '{action.title}' marked as completed."
+                        break
+                if not found:
+                    success = False
+                    message = f"Task '{action.title}' not found."
+        elif cmd == "list":
+            self.list_called = True
+            message = f"Listed {len(self.tasks)} current tasks."
+        else:
+            success = False
+            message = f"Unknown command: '{cmd}'"
+            
+        reward = self._calculate_reward()
+        done = self.goal_completed
+        
+        return TaskManagerObservation(
+            success=success,
+            message=message,
+            tasks=self.tasks,
+            done=done,
+            reward=reward,
+            metadata={"difficulty": self.difficulty, "step": self._state.step_count}
+        )
+
+    def _calculate_reward(self) -> float:
+        reward = 0.0
+        self.goal_completed = False
+        
+        if self.difficulty == "Easy":
+            # Add 2 tasks (0.4 each) + list them (0.2)
+            reward += min(0.8, self.tasks_added * 0.4)
+            if self.list_called:
+                reward += 0.2
+                
+            if self.tasks_added >= 2 and self.list_called:
+                reward = 1.0
+                self.goal_completed = True
+                
+        elif self.difficulty == "Medium":
+            # Add 3 tasks (0.2 each) + Add High (0.1) + Complete High (0.3 ratio)
+            reward += min(0.6, self.tasks_added * 0.2)
+            if self.high_priority_added >= 1:
+                reward += 0.1
+                completion_ratio = self.high_priority_completed / self.high_priority_added
+                reward += min(0.3, completion_ratio * 0.3)
+                    
+            if self.tasks_added >= 3 and self.high_priority_added >= 1:
+                if self.high_priority_completed >= self.high_priority_added:
+                    reward = 1.0
+                    self.goal_completed = True
+                    
+        elif self.difficulty == "Hard":
+            # Add 4 tasks (0.1 each) + Add 2 High (0.1 each) + Complete 2 High (0.2 each)
+            reward += min(0.4, self.tasks_added * 0.1)
+            reward += min(0.2, self.high_priority_added * 0.1)
+            reward += min(0.4, self.high_priority_completed * 0.2)
+            
+            if self.tasks_added >= 4 and self.high_priority_added >= 2 and self.high_priority_completed >= 2:
+                reward = 1.0
+                self.goal_completed = True
+        
+        return round(min(1.0, reward), 2)
+
+    @property
+    def state(self) -> State:
+        return self._state

server/requirements.txt

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