move dockerfile and app to root

Dockerfile

@@ -0,0 +1,80 @@
+# 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 src/core)
+# - Standalone environments (with openenv-core from pip)
+# 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
+
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv-core is already in the pyproject.toml dependencies
+# For standalone builds, openenv-core will be installed from pip 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 git for building from git repos (build-time only)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install dependencies using uv sync
+# First pass: install dependencies without the project (for better caching)
+# Second pass: install the project itself
+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 using Python (more portable than curl/wget)
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')" || 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"]

__init__.py

@@ -4,26 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
-"""
-Echo Environment - A pure MCP environment for testing and demonstration.
+"""Echo environment server components."""
 
-This environment exposes all functionality through MCP tools:
-- `echo_message(message)`: Echo back the provided message
-- `echo_with_length(message)`: Echo back the message with its length
+from .echo_environment import EchoEnvironment
 
-Example:
-    >>> from echo_env import EchoEnv
-    >>>
-    >>> with EchoEnv(base_url="http://localhost:8000") as env:
-    ...     env.reset()
-    ...     tools = env.list_tools()
-    ...     result = env.call_tool("echo_message", message="Hello!")
-    ...     print(result)  # "Hello!"
-"""
-
-# Re-export MCP types for convenience
-from openenv.core.env_server.mcp_types import CallToolAction, ListToolsAction
-
-from .client import EchoEnv
-
-__all__ = ["EchoEnv", "CallToolAction", "ListToolsAction"]
+__all__ = ["EchoEnvironment"]

app.py

@@ -0,0 +1,61 @@
+# 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 Echo Environment.
+
+This module creates an HTTP server that exposes the EchoEnvironment
+over HTTP and WebSocket endpoints, compatible with MCPToolClient.
+
+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:
+    uv run --project . server
+"""
+
+# Support both in-repo and standalone imports
+try:
+    # In-repo imports (when running from OpenEnv repository)
+    from openenv.core.env_server.http_server import create_app
+    from openenv.core.env_server.mcp_types import CallToolAction, CallToolObservation
+
+    from .echo_environment import EchoEnvironment
+except ImportError:
+    # Standalone imports (when environment is standalone with openenv from pip)
+    from openenv.core.env_server.http_server import create_app
+    from openenv.core.env_server.mcp_types import CallToolAction, CallToolObservation
+    from server.echo_environment import EchoEnvironment
+
+# Create the app with web interface and README integration
+# Pass the class (factory) instead of an instance for WebSocket session support
+# Use MCP types for action/observation since this is a pure MCP environment
+app = create_app(
+    EchoEnvironment, CallToolAction, CallToolObservation, env_name="echo_env"
+)
+
+
+def main():
+    """
+    Entry point for direct execution via uv run or python -m.
+
+    This function enables running the server without Docker:
+        uv run --project . server
+        python -m envs.echo_env.server.app
+        openenv serve echo_env
+
+    """
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+
+if __name__ == "__main__":
+    main()

echo_environment.py

@@ -0,0 +1,196 @@
+# 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.
+
+"""
+Echo Environment Implementation.
+
+A pure MCP environment that echoes back messages sent to it.
+This demonstrates how to build an MCPEnvironment with inline FastMCP tools.
+
+All interactions happen through MCP tools:
+- `echo_message(message)`: Echo back the provided message
+- `echo_with_length(message)`: Echo back the message with its length
+
+Example:
+    >>> from openenv.core.env_server.mcp_types import ListToolsAction, CallToolAction
+    >>> env = EchoEnvironment()
+    >>> env.reset()
+    >>>
+    >>> # List available tools
+    >>> obs = env.step(ListToolsAction())
+    >>> print([t.name for t in obs.tools])  # ["echo_message", "echo_with_length"]
+    >>>
+    >>> # Call a tool
+    >>> obs = env.step(CallToolAction(tool_name="echo_message", arguments={"message": "Hi!"}))
+    >>> print(obs.result)  # "Hi!"
+"""
+
+from typing import Any, Optional
+from uuid import uuid4
+
+# Support both in-repo and standalone imports
+try:
+    # In-repo imports (when running from OpenEnv repository)
+    from openenv.core.env_server.mcp_environment import MCPEnvironment
+    from openenv.core.env_server.types import Action, Observation, State
+except ImportError:
+    # Standalone imports (when environment is standalone with openenv from pip)
+    from openenv.core.env_server.mcp_environment import MCPEnvironment
+    from openenv.core.env_server.types import Action, Observation, State
+
+from fastmcp import FastMCP
+
+
+class EchoEnvironment(MCPEnvironment):
+    """
+    A pure MCP echo environment that echoes back messages.
+
+    This environment exposes all functionality through MCP tools:
+    - `echo_message`: Echo back the provided message
+    - `echo_with_length`: Echo back the message with its length
+
+    The environment inherits MCP support (ListToolsAction, CallToolAction)
+    from the MCPEnvironment base class. No legacy action types are supported.
+
+    Example using MCPToolClient:
+        >>> from openenv.core.mcp_client import MCPToolClient
+        >>>
+        >>> with MCPToolClient(base_url="http://localhost:8000") as env:
+        ...     env.reset()
+        ...     tools = env.list_tools()
+        ...     print([t.name for t in tools])
+        ...     result = env.call_tool("echo_message", message="Hello!")
+        ...     print(result)
+    """
+
+    def __init__(self):
+        """Initialize the echo environment with MCP server and tools."""
+        # Create MCP server and define tools inline
+        mcp = FastMCP("echo_env")
+
+        @mcp.tool
+        def echo_message(message: str) -> str:
+            """
+            Echo back the provided message.
+
+            Args:
+                message: The message to echo back
+
+            Returns:
+                The same message that was provided
+            """
+            return message
+
+        @mcp.tool
+        def echo_with_length(message: str) -> dict:
+            """
+            Echo back the message with its length.
+
+            Args:
+                message: The message to echo back
+
+            Returns:
+                Dictionary with the message and its length
+            """
+            return {"message": message, "length": len(message)}
+
+        # Pass the MCP server to the base class
+        super().__init__(mcp)
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self._reset_count = 0
+
+    def reset(
+        self,
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+        **kwargs: Any,
+    ) -> Observation:
+        """
+        Reset the environment.
+
+        Args:
+            seed: Optional random seed (unused in echo env)
+            episode_id: Optional episode ID to use
+            **kwargs: Additional reset options
+
+        Returns:
+            Observation indicating the environment is ready
+        """
+        self._state = State(
+            episode_id=episode_id or str(uuid4()),
+            step_count=0,
+        )
+        self._reset_count += 1
+
+        return Observation(
+            done=False,
+            reward=0.0,
+            metadata={"status": "ready", "message": "Echo environment ready!"},
+        )
+
+    def _step_impl(
+        self,
+        action: Action,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> Observation:
+        """
+        Handle non-MCP actions.
+
+        This environment only supports MCP actions (ListToolsAction, CallToolAction).
+        Any other action type returns an error observation.
+
+        Args:
+            action: The action to execute
+            timeout_s: Optional timeout (unused)
+            **kwargs: Additional arguments
+
+        Returns:
+            Observation with error for unknown action types
+        """
+        return Observation(
+            done=False,
+            reward=0.0,
+            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:
+        """
+        Execute a step in the environment.
+
+        Delegates to base class for MCP actions. Increments step count for all actions.
+
+        Args:
+            action: The MCP action to execute (ListToolsAction or CallToolAction)
+            timeout_s: Optional timeout for the action
+            **kwargs: Additional arguments
+
+        Returns:
+            Observation from the action execution
+        """
+        # Increment step count for all actions
+        self._state.step_count += 1
+
+        # Let the base class handle MCP actions and non-MCP routing
+        return super().step(action, timeout_s=timeout_s, **kwargs)
+
+    @property
+    def state(self) -> State:
+        """
+        Get the current environment state.
+
+        Returns:
+            Current State with episode_id and step_count
+        """
+        return self._state