fix: clean up file structure

echo_environment.py

@@ -1,196 +0,0 @@
-# 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

server/Dockerfile

@@ -1,80 +0,0 @@
-# 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"]

server/__init__.py

@@ -1,11 +0,0 @@
-# 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 server components."""
-
-from .echo_environment import EchoEnvironment
-
-__all__ = ["EchoEnvironment"]