Upload folder using huggingface_hub

Dockerfile

@@ -74,6 +74,7 @@ ENV PATH="/app/.venv/bin:$PATH"
 
 # Set PYTHONPATH so imports work correctly
 ENV PYTHONPATH="/app/env:$PYTHONPATH"
+ENV ENABLE_WEB_INTERFACE=true
 
 # Health check using Python (more portable than curl/wget)
 HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
@@ -82,5 +83,3 @@ HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
 # 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"]
-
-ENV ENABLE_WEB_INTERFACE=true

README.md

@@ -8,7 +8,7 @@ pinned: false
 app_port: 8000
 base_path: /web
 tags:
-  - openenv-0.2.2
+  - openenv-0.2.3
   - openenv
 ---
 
@@ -17,7 +17,7 @@ tags:
 This Space is built from OpenEnv environment `repl_env`.
 
 - Space URL: `https://huggingface.co/spaces/openenv/repl`
-- OpenEnv pinned ref: `0.2.2`
+- OpenEnv pinned ref: `0.2.3`
 - Hub tag: `openenv`
 
 ### Connecting from Code

envs/repl_env/pyproject.toml

@@ -15,7 +15,7 @@ description = "Recursive Language Model REPL Environment for OpenEnv"
 requires-python = ">=3.10"
 dependencies = [
     # Core OpenEnv dependencies (required for server functionality)
-    "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git@v0.2.2",
+    "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git@v0.2.3",
     "fastapi>=0.115.0",
     "pydantic>=2.0.0",
     "uvicorn>=0.24.0",

envs/repl_env/server/Dockerfile

@@ -70,6 +70,7 @@ ENV PATH="/app/.venv/bin:$PATH"
 
 # Set PYTHONPATH so imports work correctly
 ENV PYTHONPATH="/app/env:$PYTHONPATH"
+ENV ENABLE_WEB_INTERFACE=true
 
 # Health check using Python (more portable than curl/wget)
 HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \

envs/repl_env/server/__init__.py

@@ -10,25 +10,6 @@ REPL Environment Server Components.
 This module contains the server-side implementation of the REPL environment.
 """
 
-import sys
-from pathlib import Path
-
-
-def _prefer_bundled_openenv_src() -> None:
-    """Ensure bundled src/openenv wins over installed openenv-core wheels."""
-    for parent in Path(__file__).resolve().parents:
-        src_dir = parent / "src"
-        if not (src_dir / "openenv").is_dir():
-            continue
-        src_path = str(src_dir)
-        if src_path in sys.path:
-            sys.path.remove(src_path)
-        sys.path.insert(0, src_path)
-        return
-
-
-_prefer_bundled_openenv_src()
-
 from .python_executor import PythonExecutor
 from .repl_environment import REPLEnvironment
 

envs/repl_env/server/app.py

@@ -38,24 +38,6 @@ Environment Variables:
 import inspect
 import logging
 import os
-import sys
-from pathlib import Path
-
-
-def _prefer_bundled_openenv_src() -> None:
-    """Ensure the bundled repo src/ tree wins over installed openenv-core wheels."""
-    for parent in Path(__file__).resolve().parents:
-        src_dir = parent / "src"
-        if not (src_dir / "openenv").is_dir():
-            continue
-        src_path = str(src_dir)
-        if src_path in sys.path:
-            sys.path.remove(src_path)
-        sys.path.insert(0, src_path)
-        return
-
-
-_prefer_bundled_openenv_src()
 
 try:
     from openenv.core.env_server.http_server import create_app

pyproject.toml

@@ -15,7 +15,7 @@ description = "Recursive Language Model REPL Environment for OpenEnv"
 requires-python = ">=3.10"
 dependencies = [
     # Core OpenEnv dependencies (required for server functionality)
-    "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git@v0.2.2",
+    "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git@v0.2.3",
     "fastapi>=0.115.0",
     "pydantic>=2.0.0",
     "uvicorn>=0.24.0",

server/Dockerfile

@@ -70,6 +70,7 @@ ENV PATH="/app/.venv/bin:$PATH"
 
 # Set PYTHONPATH so imports work correctly
 ENV PYTHONPATH="/app/env:$PYTHONPATH"
+ENV ENABLE_WEB_INTERFACE=true
 
 # Health check using Python (more portable than curl/wget)
 HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \

server/__init__.py

@@ -10,25 +10,6 @@ REPL Environment Server Components.
 This module contains the server-side implementation of the REPL environment.
 """
 
-import sys
-from pathlib import Path
-
-
-def _prefer_bundled_openenv_src() -> None:
-    """Ensure bundled src/openenv wins over installed openenv-core wheels."""
-    for parent in Path(__file__).resolve().parents:
-        src_dir = parent / "src"
-        if not (src_dir / "openenv").is_dir():
-            continue
-        src_path = str(src_dir)
-        if src_path in sys.path:
-            sys.path.remove(src_path)
-        sys.path.insert(0, src_path)
-        return
-
-
-_prefer_bundled_openenv_src()
-
 from .python_executor import PythonExecutor
 from .repl_environment import REPLEnvironment
 

server/app.py

@@ -38,24 +38,6 @@ Environment Variables:
 import inspect
 import logging
 import os
-import sys
-from pathlib import Path
-
-
-def _prefer_bundled_openenv_src() -> None:
-    """Ensure the bundled repo src/ tree wins over installed openenv-core wheels."""
-    for parent in Path(__file__).resolve().parents:
-        src_dir = parent / "src"
-        if not (src_dir / "openenv").is_dir():
-            continue
-        src_path = str(src_dir)
-        if src_path in sys.path:
-            sys.path.remove(src_path)
-        sys.path.insert(0, src_path)
-        return
-
-
-_prefer_bundled_openenv_src()
 
 try:
     from openenv.core.env_server.http_server import create_app

src/core/env_server/interfaces.py

@@ -6,7 +6,9 @@
 
 import inspect
 from abc import ABC, abstractmethod
-from typing import Any, Generic, Optional, Protocol, TYPE_CHECKING, TypedDict, TypeVar
+from typing import Any, Generic, Optional, Protocol, TYPE_CHECKING, TypeVar
+
+from typing_extensions import TypedDict
 
 from .types import Action, EnvironmentMetadata, Observation, State
 

src/core/env_server/mcp_environment.py

@@ -420,24 +420,49 @@ class MCPEnvironment(Environment):
             return self._step_impl(action, timeout_s=timeout_s, **kwargs)
 
     def _handle_list_tools(self) -> ListToolsObservation:
+        """Sync wrapper — delegates to the canonical async implementation."""
+        return run_async_safely(self._async_handle_list_tools())
+
+    async def _async_list_tools(self) -> list:
         """
-        Handle a ListToolsAction by querying the MCP server.
+        Async helper to list tools from the MCP client.
 
         Returns:
-            ListToolsObservation containing all available tools with their
-            names, descriptions, and input schemas, filtered by current mode.
+            List of tool objects from the MCP server.
         """
-        try:
-            # Get current mode
-            current_mode = getattr(self, "_mode", None)
+        async with self.mcp_session() as client:
+            return await client.list_tools()
 
-            # Start with tools from FastMCP server (mode=None tools)
-            tools_result = run_async_safely(self._async_list_tools())
+    def _handle_call_tool(
+        self,
+        action: CallToolAction,
+        timeout_s: Optional[float] = None,
+    ) -> CallToolObservation:
+        """Sync wrapper — delegates to the canonical async implementation."""
+        return run_async_safely(
+            self._async_handle_call_tool(action, timeout_s=timeout_s)
+        )
 
-            # Build list of Tool objects
-            tools = []
+    async def _async_call_tool(self, tool_name: str, arguments: dict) -> Any:
+        """
+        Async helper to call a tool on the MCP server.
+
+        Args:
+            tool_name: Name of the tool to invoke.
+            arguments: Dictionary of arguments to pass to the tool.
 
-            # Add FastMCP tools that are not mode-specific
+        Returns:
+            The result from the tool execution.
+        """
+        async with self.mcp_session() as client:
+            return await client.call_tool(tool_name, arguments)
+
+    async def _async_handle_list_tools(self) -> ListToolsObservation:
+        """Async version of _handle_list_tools — avoids run_async_safely."""
+        try:
+            current_mode = getattr(self, "_mode", None)
+            tools_result = await self._async_list_tools()
+            tools = []
             for tool in tools_result:
                 if tool.name not in self._mode_tool_schemas:
                     tools.append(
@@ -449,11 +474,8 @@ class MCPEnvironment(Environment):
                             else {},
                         )
                     )
-
-            # Add mode-specific tools available in current mode
             for tool_name, mode_schemas in self._mode_tool_schemas.items():
                 if None in mode_schemas:
-                    # Tool available in all modes
                     schema = mode_schemas[None]
                     tools.append(
                         Tool(
@@ -463,7 +485,6 @@ class MCPEnvironment(Environment):
                         )
                     )
                 elif current_mode in mode_schemas:
-                    # Tool available in current mode
                     schema = mode_schemas[current_mode]
                     tools.append(
                         Tool(
@@ -472,65 +493,30 @@ class MCPEnvironment(Environment):
                             input_schema=schema["input_schema"],
                         )
                     )
-
             return ListToolsObservation(tools=tools)
-
         except Exception as e:
-            # Return an observation with error in metadata
             return ListToolsObservation(
                 tools=[],
-                metadata={
-                    "error": str(e),
-                    "error_type": "list_tools_failed",
-                },
+                metadata={"error": str(e), "error_type": "list_tools_failed"},
             )
 
-    async def _async_list_tools(self) -> list:
-        """
-        Async helper to list tools from the MCP client.
-
-        Returns:
-            List of tool objects from the MCP server.
-        """
-        async with self.mcp_session() as client:
-            return await client.list_tools()
-
-    def _handle_call_tool(
+    async def _async_handle_call_tool(
         self,
         action: CallToolAction,
         timeout_s: Optional[float] = None,
     ) -> CallToolObservation:
-        """
-        Handle a CallToolAction by invoking the specified tool.
-
-        Args:
-            action: The CallToolAction containing tool_name and arguments.
-            timeout_s: Timeout in seconds. Defaults to MCP_TOOL_CALL_TIMEOUT (30s).
-
-        Returns:
-            CallToolObservation with the tool's result or an error.
-        """
+        """Async version of _handle_call_tool — avoids run_async_safely."""
         timeout = timeout_s if timeout_s is not None else MCP_TOOL_CALL_TIMEOUT
-
-        # Check if this is a mode-specific tool
         tool_name = action.tool_name
         current_mode = getattr(self, "_mode", None)
 
         if tool_name in self._mode_tools:
             mode_info = self._mode_tools[tool_name]
-
-            # Check if tool is available in current mode
-            # Tool is available if:
-            # 1. It has a None mode (available in all modes), OR
-            # 2. It has an implementation for the current mode
             if None in mode_info:
-                # Use the mode-agnostic version
                 func = mode_info[None]
             elif current_mode in mode_info:
-                # Use the mode-specific version
                 func = mode_info[current_mode]
             else:
-                # Tool not available in current mode
                 return CallToolObservation(
                     tool_name=tool_name,
                     result=None,
@@ -539,16 +525,11 @@ class MCPEnvironment(Environment):
                         message=f"Tool '{tool_name}' not available in {current_mode} mode",
                     ),
                 )
-
-            # Call the mode-specific function directly
             try:
-                # Check if function is async and await if necessary
                 if inspect.iscoroutinefunction(func):
-                    result = run_async_safely(func(**action.arguments))
+                    result = await func(**action.arguments)
                 else:
                     result = func(**action.arguments)
-
-                # Wrap result in CallToolResult format to match FastMCP behavior
                 return CallToolObservation(
                     tool_name=tool_name,
                     result=CallToolResult(
@@ -569,22 +550,12 @@ class MCPEnvironment(Environment):
                     ),
                 )
 
-        # Not a mode-specific tool, use FastMCP
         try:
-            # Run the async call_tool with timeout
-            # Use run_async_safely to handle both sync and async contexts
-            result = run_async_safely(
-                asyncio.wait_for(
-                    self._async_call_tool(action.tool_name, action.arguments),
-                    timeout=timeout,
-                )
-            )
-
-            return CallToolObservation(
-                tool_name=action.tool_name,
-                result=result,
+            result = await asyncio.wait_for(
+                self._async_call_tool(action.tool_name, action.arguments),
+                timeout=timeout,
             )
-
+            return CallToolObservation(tool_name=action.tool_name, result=result)
         except asyncio.TimeoutError:
             return CallToolObservation(
                 tool_name=action.tool_name,
@@ -594,11 +565,8 @@ class MCPEnvironment(Environment):
                     message=f"Tool '{action.tool_name}' timed out after {timeout} seconds",
                 ),
             )
-
         except Exception as e:
             error_message = str(e)
-
-            # Determine error type based on the exception
             if (
                 "not found" in error_message.lower()
                 or "unknown tool" in error_message.lower()
@@ -611,29 +579,34 @@ class MCPEnvironment(Environment):
                 error_type = ToolErrorType.INVALID_ARGS
             else:
                 error_type = ToolErrorType.EXECUTION_ERROR
-
             return CallToolObservation(
                 tool_name=action.tool_name,
                 result=None,
-                error=ToolError(
-                    error_type=error_type,
-                    message=error_message,
-                ),
+                error=ToolError(error_type=error_type, message=error_message),
             )
 
-    async def _async_call_tool(self, tool_name: str, arguments: dict) -> Any:
+    async def step_async(
+        self,
+        action: Action,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> Observation:
         """
-        Async helper to call a tool on the MCP server.
+        Async step that routes MCP actions without going through run_async_safely.
 
-        Args:
-            tool_name: Name of the tool to invoke.
-            arguments: Dictionary of arguments to pass to the tool.
-
-        Returns:
-            The result from the tool execution.
+        The WebSocket handler calls this directly on the outer event loop, where
+        the MCP session is already open, avoiding the thread/event-loop deadlock
+        that occurs when the sync step() path is used via run_in_executor.
         """
-        async with self.mcp_session() as client:
-            return await client.call_tool(tool_name, arguments)
+        if isinstance(action, ListToolsAction):
+            return await self._async_handle_list_tools()
+        elif isinstance(action, CallToolAction):
+            return await self._async_handle_call_tool(action, timeout_s=timeout_s)
+        else:
+            loop = asyncio.get_event_loop()
+            return await loop.run_in_executor(
+                None, lambda: self._step_impl(action, timeout_s=timeout_s, **kwargs)
+            )
 
     @abstractmethod
     def _step_impl(

src/core/env_server/web_interface.py

@@ -22,7 +22,7 @@ from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional, Type
 
 import gradio as gr
-from fastapi import Body, FastAPI, HTTPException, WebSocket, WebSocketDisconnect, status
+from fastapi import Body, FastAPI, HTTPException, status, WebSocket, WebSocketDisconnect
 from fastapi.responses import RedirectResponse
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -356,7 +356,9 @@ class WebInterfaceManager:
         else:
             # Run sync reset in thread pool to avoid blocking event loop
             # and to support environments using sync libraries (e.g., Playwright)
-            observation = await self._run_sync_in_thread_pool(self.env.reset, **valid_kwargs)
+            observation = await self._run_sync_in_thread_pool(
+                self.env.reset, **valid_kwargs
+            )
         state: State = self.env.state
 
         # Serialize observation once using shared utility

src/core/openenv/__init__.py

@@ -14,10 +14,18 @@ __all__ = [
     "SyncEnvClient",
 ]
 
-try:
-    __version__ = metadata.version("openenv")  # type: ignore[arg-type]
-except metadata.PackageNotFoundError:  # pragma: no cover - local dev
-    __version__ = "0.0.0"
+
+def _load_package_version() -> str:
+    """Resolve the installed distribution version for the OpenEnv package."""
+    for distribution_name in ("openenv-core", "openenv"):
+        try:
+            return metadata.version(distribution_name)
+        except metadata.PackageNotFoundError:
+            continue
+    return "0.0.0"
+
+
+__version__ = _load_package_version()
 
 
 _LAZY_MODULES = {

src/core/openenv/cli/templates/openenv_env/pyproject.toml

@@ -17,7 +17,7 @@ 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",
+    "openenv-core[core]>=0.2.2",
     # Environment-specific dependencies
     # Add all dependencies needed for your environment here
     # Examples:

src/core/openenv/core/env_server/interfaces.py

@@ -6,7 +6,9 @@
 
 import inspect
 from abc import ABC, abstractmethod
-from typing import Any, Generic, Optional, Protocol, TYPE_CHECKING, TypedDict, TypeVar
+from typing import Any, Generic, Optional, Protocol, TYPE_CHECKING, TypeVar
+
+from typing_extensions import TypedDict
 
 from .types import Action, EnvironmentMetadata, Observation, State
 

src/core/openenv/core/env_server/mcp_environment.py

@@ -420,24 +420,49 @@ class MCPEnvironment(Environment):
             return self._step_impl(action, timeout_s=timeout_s, **kwargs)
 
     def _handle_list_tools(self) -> ListToolsObservation:
+        """Sync wrapper — delegates to the canonical async implementation."""
+        return run_async_safely(self._async_handle_list_tools())
+
+    async def _async_list_tools(self) -> list:
         """
-        Handle a ListToolsAction by querying the MCP server.
+        Async helper to list tools from the MCP client.
 
         Returns:
-            ListToolsObservation containing all available tools with their
-            names, descriptions, and input schemas, filtered by current mode.
+            List of tool objects from the MCP server.
         """
-        try:
-            # Get current mode
-            current_mode = getattr(self, "_mode", None)
+        async with self.mcp_session() as client:
+            return await client.list_tools()
 
-            # Start with tools from FastMCP server (mode=None tools)
-            tools_result = run_async_safely(self._async_list_tools())
+    def _handle_call_tool(
+        self,
+        action: CallToolAction,
+        timeout_s: Optional[float] = None,
+    ) -> CallToolObservation:
+        """Sync wrapper — delegates to the canonical async implementation."""
+        return run_async_safely(
+            self._async_handle_call_tool(action, timeout_s=timeout_s)
+        )
 
-            # Build list of Tool objects
-            tools = []
+    async def _async_call_tool(self, tool_name: str, arguments: dict) -> Any:
+        """
+        Async helper to call a tool on the MCP server.
+
+        Args:
+            tool_name: Name of the tool to invoke.
+            arguments: Dictionary of arguments to pass to the tool.
 
-            # Add FastMCP tools that are not mode-specific
+        Returns:
+            The result from the tool execution.
+        """
+        async with self.mcp_session() as client:
+            return await client.call_tool(tool_name, arguments)
+
+    async def _async_handle_list_tools(self) -> ListToolsObservation:
+        """Async version of _handle_list_tools — avoids run_async_safely."""
+        try:
+            current_mode = getattr(self, "_mode", None)
+            tools_result = await self._async_list_tools()
+            tools = []
             for tool in tools_result:
                 if tool.name not in self._mode_tool_schemas:
                     tools.append(
@@ -449,11 +474,8 @@ class MCPEnvironment(Environment):
                             else {},
                         )
                     )
-
-            # Add mode-specific tools available in current mode
             for tool_name, mode_schemas in self._mode_tool_schemas.items():
                 if None in mode_schemas:
-                    # Tool available in all modes
                     schema = mode_schemas[None]
                     tools.append(
                         Tool(
@@ -463,7 +485,6 @@ class MCPEnvironment(Environment):
                         )
                     )
                 elif current_mode in mode_schemas:
-                    # Tool available in current mode
                     schema = mode_schemas[current_mode]
                     tools.append(
                         Tool(
@@ -472,65 +493,30 @@ class MCPEnvironment(Environment):
                             input_schema=schema["input_schema"],
                         )
                     )
-
             return ListToolsObservation(tools=tools)
-
         except Exception as e:
-            # Return an observation with error in metadata
             return ListToolsObservation(
                 tools=[],
-                metadata={
-                    "error": str(e),
-                    "error_type": "list_tools_failed",
-                },
+                metadata={"error": str(e), "error_type": "list_tools_failed"},
             )
 
-    async def _async_list_tools(self) -> list:
-        """
-        Async helper to list tools from the MCP client.
-
-        Returns:
-            List of tool objects from the MCP server.
-        """
-        async with self.mcp_session() as client:
-            return await client.list_tools()
-
-    def _handle_call_tool(
+    async def _async_handle_call_tool(
         self,
         action: CallToolAction,
         timeout_s: Optional[float] = None,
     ) -> CallToolObservation:
-        """
-        Handle a CallToolAction by invoking the specified tool.
-
-        Args:
-            action: The CallToolAction containing tool_name and arguments.
-            timeout_s: Timeout in seconds. Defaults to MCP_TOOL_CALL_TIMEOUT (30s).
-
-        Returns:
-            CallToolObservation with the tool's result or an error.
-        """
+        """Async version of _handle_call_tool — avoids run_async_safely."""
         timeout = timeout_s if timeout_s is not None else MCP_TOOL_CALL_TIMEOUT
-
-        # Check if this is a mode-specific tool
         tool_name = action.tool_name
         current_mode = getattr(self, "_mode", None)
 
         if tool_name in self._mode_tools:
             mode_info = self._mode_tools[tool_name]
-
-            # Check if tool is available in current mode
-            # Tool is available if:
-            # 1. It has a None mode (available in all modes), OR
-            # 2. It has an implementation for the current mode
             if None in mode_info:
-                # Use the mode-agnostic version
                 func = mode_info[None]
             elif current_mode in mode_info:
-                # Use the mode-specific version
                 func = mode_info[current_mode]
             else:
-                # Tool not available in current mode
                 return CallToolObservation(
                     tool_name=tool_name,
                     result=None,
@@ -539,16 +525,11 @@ class MCPEnvironment(Environment):
                         message=f"Tool '{tool_name}' not available in {current_mode} mode",
                     ),
                 )
-
-            # Call the mode-specific function directly
             try:
-                # Check if function is async and await if necessary
                 if inspect.iscoroutinefunction(func):
-                    result = run_async_safely(func(**action.arguments))
+                    result = await func(**action.arguments)
                 else:
                     result = func(**action.arguments)
-
-                # Wrap result in CallToolResult format to match FastMCP behavior
                 return CallToolObservation(
                     tool_name=tool_name,
                     result=CallToolResult(
@@ -569,22 +550,12 @@ class MCPEnvironment(Environment):
                     ),
                 )
 
-        # Not a mode-specific tool, use FastMCP
         try:
-            # Run the async call_tool with timeout
-            # Use run_async_safely to handle both sync and async contexts
-            result = run_async_safely(
-                asyncio.wait_for(
-                    self._async_call_tool(action.tool_name, action.arguments),
-                    timeout=timeout,
-                )
-            )
-
-            return CallToolObservation(
-                tool_name=action.tool_name,
-                result=result,
+            result = await asyncio.wait_for(
+                self._async_call_tool(action.tool_name, action.arguments),
+                timeout=timeout,
             )
-
+            return CallToolObservation(tool_name=action.tool_name, result=result)
         except asyncio.TimeoutError:
             return CallToolObservation(
                 tool_name=action.tool_name,
@@ -594,11 +565,8 @@ class MCPEnvironment(Environment):
                     message=f"Tool '{action.tool_name}' timed out after {timeout} seconds",
                 ),
             )
-
         except Exception as e:
             error_message = str(e)
-
-            # Determine error type based on the exception
             if (
                 "not found" in error_message.lower()
                 or "unknown tool" in error_message.lower()
@@ -611,29 +579,34 @@ class MCPEnvironment(Environment):
                 error_type = ToolErrorType.INVALID_ARGS
             else:
                 error_type = ToolErrorType.EXECUTION_ERROR
-
             return CallToolObservation(
                 tool_name=action.tool_name,
                 result=None,
-                error=ToolError(
-                    error_type=error_type,
-                    message=error_message,
-                ),
+                error=ToolError(error_type=error_type, message=error_message),
             )
 
-    async def _async_call_tool(self, tool_name: str, arguments: dict) -> Any:
+    async def step_async(
+        self,
+        action: Action,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> Observation:
         """
-        Async helper to call a tool on the MCP server.
+        Async step that routes MCP actions without going through run_async_safely.
 
-        Args:
-            tool_name: Name of the tool to invoke.
-            arguments: Dictionary of arguments to pass to the tool.
-
-        Returns:
-            The result from the tool execution.
+        The WebSocket handler calls this directly on the outer event loop, where
+        the MCP session is already open, avoiding the thread/event-loop deadlock
+        that occurs when the sync step() path is used via run_in_executor.
         """
-        async with self.mcp_session() as client:
-            return await client.call_tool(tool_name, arguments)
+        if isinstance(action, ListToolsAction):
+            return await self._async_handle_list_tools()
+        elif isinstance(action, CallToolAction):
+            return await self._async_handle_call_tool(action, timeout_s=timeout_s)
+        else:
+            loop = asyncio.get_event_loop()
+            return await loop.run_in_executor(
+                None, lambda: self._step_impl(action, timeout_s=timeout_s, **kwargs)
+            )
 
     @abstractmethod
     def _step_impl(

src/core/openenv/core/env_server/web_interface.py

@@ -22,7 +22,7 @@ from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional, Type
 
 import gradio as gr
-from fastapi import Body, FastAPI, HTTPException, WebSocket, WebSocketDisconnect, status
+from fastapi import Body, FastAPI, HTTPException, status, WebSocket, WebSocketDisconnect
 from fastapi.responses import RedirectResponse
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -356,7 +356,9 @@ class WebInterfaceManager:
         else:
             # Run sync reset in thread pool to avoid blocking event loop
             # and to support environments using sync libraries (e.g., Playwright)
-            observation = await self._run_sync_in_thread_pool(self.env.reset, **valid_kwargs)
+            observation = await self._run_sync_in_thread_pool(
+                self.env.reset, **valid_kwargs
+            )
         state: State = self.env.state
 
         # Serialize observation once using shared utility

src/openenv/__init__.py

@@ -14,10 +14,18 @@ __all__ = [
     "SyncEnvClient",
 ]
 
-try:
-    __version__ = metadata.version("openenv")  # type: ignore[arg-type]
-except metadata.PackageNotFoundError:  # pragma: no cover - local dev
-    __version__ = "0.0.0"
+
+def _load_package_version() -> str:
+    """Resolve the installed distribution version for the OpenEnv package."""
+    for distribution_name in ("openenv-core", "openenv"):
+        try:
+            return metadata.version(distribution_name)
+        except metadata.PackageNotFoundError:
+            continue
+    return "0.0.0"
+
+
+__version__ = _load_package_version()
 
 
 _LAZY_MODULES = {

src/openenv/cli/templates/openenv_env/pyproject.toml

@@ -17,7 +17,7 @@ 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",
+    "openenv-core[core]>=0.2.2",
     # Environment-specific dependencies
     # Add all dependencies needed for your environment here
     # Examples:

src/openenv/core/env_server/interfaces.py

@@ -6,7 +6,9 @@
 
 import inspect
 from abc import ABC, abstractmethod
-from typing import Any, Generic, Optional, Protocol, TYPE_CHECKING, TypedDict, TypeVar
+from typing import Any, Generic, Optional, Protocol, TYPE_CHECKING, TypeVar
+
+from typing_extensions import TypedDict
 
 from .types import Action, EnvironmentMetadata, Observation, State
 

src/openenv/core/env_server/mcp_environment.py

@@ -420,24 +420,49 @@ class MCPEnvironment(Environment):
             return self._step_impl(action, timeout_s=timeout_s, **kwargs)
 
     def _handle_list_tools(self) -> ListToolsObservation:
+        """Sync wrapper — delegates to the canonical async implementation."""
+        return run_async_safely(self._async_handle_list_tools())
+
+    async def _async_list_tools(self) -> list:
         """
-        Handle a ListToolsAction by querying the MCP server.
+        Async helper to list tools from the MCP client.
 
         Returns:
-            ListToolsObservation containing all available tools with their
-            names, descriptions, and input schemas, filtered by current mode.
+            List of tool objects from the MCP server.
         """
-        try:
-            # Get current mode
-            current_mode = getattr(self, "_mode", None)
+        async with self.mcp_session() as client:
+            return await client.list_tools()
 
-            # Start with tools from FastMCP server (mode=None tools)
-            tools_result = run_async_safely(self._async_list_tools())
+    def _handle_call_tool(
+        self,
+        action: CallToolAction,
+        timeout_s: Optional[float] = None,
+    ) -> CallToolObservation:
+        """Sync wrapper — delegates to the canonical async implementation."""
+        return run_async_safely(
+            self._async_handle_call_tool(action, timeout_s=timeout_s)
+        )
 
-            # Build list of Tool objects
-            tools = []
+    async def _async_call_tool(self, tool_name: str, arguments: dict) -> Any:
+        """
+        Async helper to call a tool on the MCP server.
+
+        Args:
+            tool_name: Name of the tool to invoke.
+            arguments: Dictionary of arguments to pass to the tool.
 
-            # Add FastMCP tools that are not mode-specific
+        Returns:
+            The result from the tool execution.
+        """
+        async with self.mcp_session() as client:
+            return await client.call_tool(tool_name, arguments)
+
+    async def _async_handle_list_tools(self) -> ListToolsObservation:
+        """Async version of _handle_list_tools — avoids run_async_safely."""
+        try:
+            current_mode = getattr(self, "_mode", None)
+            tools_result = await self._async_list_tools()
+            tools = []
             for tool in tools_result:
                 if tool.name not in self._mode_tool_schemas:
                     tools.append(
@@ -449,11 +474,8 @@ class MCPEnvironment(Environment):
                             else {},
                         )
                     )
-
-            # Add mode-specific tools available in current mode
             for tool_name, mode_schemas in self._mode_tool_schemas.items():
                 if None in mode_schemas:
-                    # Tool available in all modes
                     schema = mode_schemas[None]
                     tools.append(
                         Tool(
@@ -463,7 +485,6 @@ class MCPEnvironment(Environment):
                         )
                     )
                 elif current_mode in mode_schemas:
-                    # Tool available in current mode
                     schema = mode_schemas[current_mode]
                     tools.append(
                         Tool(
@@ -472,65 +493,30 @@ class MCPEnvironment(Environment):
                             input_schema=schema["input_schema"],
                         )
                     )
-
             return ListToolsObservation(tools=tools)
-
         except Exception as e:
-            # Return an observation with error in metadata
             return ListToolsObservation(
                 tools=[],
-                metadata={
-                    "error": str(e),
-                    "error_type": "list_tools_failed",
-                },
+                metadata={"error": str(e), "error_type": "list_tools_failed"},
             )
 
-    async def _async_list_tools(self) -> list:
-        """
-        Async helper to list tools from the MCP client.
-
-        Returns:
-            List of tool objects from the MCP server.
-        """
-        async with self.mcp_session() as client:
-            return await client.list_tools()
-
-    def _handle_call_tool(
+    async def _async_handle_call_tool(
         self,
         action: CallToolAction,
         timeout_s: Optional[float] = None,
     ) -> CallToolObservation:
-        """
-        Handle a CallToolAction by invoking the specified tool.
-
-        Args:
-            action: The CallToolAction containing tool_name and arguments.
-            timeout_s: Timeout in seconds. Defaults to MCP_TOOL_CALL_TIMEOUT (30s).
-
-        Returns:
-            CallToolObservation with the tool's result or an error.
-        """
+        """Async version of _handle_call_tool — avoids run_async_safely."""
         timeout = timeout_s if timeout_s is not None else MCP_TOOL_CALL_TIMEOUT
-
-        # Check if this is a mode-specific tool
         tool_name = action.tool_name
         current_mode = getattr(self, "_mode", None)
 
         if tool_name in self._mode_tools:
             mode_info = self._mode_tools[tool_name]
-
-            # Check if tool is available in current mode
-            # Tool is available if:
-            # 1. It has a None mode (available in all modes), OR
-            # 2. It has an implementation for the current mode
             if None in mode_info:
-                # Use the mode-agnostic version
                 func = mode_info[None]
             elif current_mode in mode_info:
-                # Use the mode-specific version
                 func = mode_info[current_mode]
             else:
-                # Tool not available in current mode
                 return CallToolObservation(
                     tool_name=tool_name,
                     result=None,
@@ -539,16 +525,11 @@ class MCPEnvironment(Environment):
                         message=f"Tool '{tool_name}' not available in {current_mode} mode",
                     ),
                 )
-
-            # Call the mode-specific function directly
             try:
-                # Check if function is async and await if necessary
                 if inspect.iscoroutinefunction(func):
-                    result = run_async_safely(func(**action.arguments))
+                    result = await func(**action.arguments)
                 else:
                     result = func(**action.arguments)
-
-                # Wrap result in CallToolResult format to match FastMCP behavior
                 return CallToolObservation(
                     tool_name=tool_name,
                     result=CallToolResult(
@@ -569,22 +550,12 @@ class MCPEnvironment(Environment):
                     ),
                 )
 
-        # Not a mode-specific tool, use FastMCP
         try:
-            # Run the async call_tool with timeout
-            # Use run_async_safely to handle both sync and async contexts
-            result = run_async_safely(
-                asyncio.wait_for(
-                    self._async_call_tool(action.tool_name, action.arguments),
-                    timeout=timeout,
-                )
-            )
-
-            return CallToolObservation(
-                tool_name=action.tool_name,
-                result=result,
+            result = await asyncio.wait_for(
+                self._async_call_tool(action.tool_name, action.arguments),
+                timeout=timeout,
             )
-
+            return CallToolObservation(tool_name=action.tool_name, result=result)
         except asyncio.TimeoutError:
             return CallToolObservation(
                 tool_name=action.tool_name,
@@ -594,11 +565,8 @@ class MCPEnvironment(Environment):
                     message=f"Tool '{action.tool_name}' timed out after {timeout} seconds",
                 ),
             )
-
         except Exception as e:
             error_message = str(e)
-
-            # Determine error type based on the exception
             if (
                 "not found" in error_message.lower()
                 or "unknown tool" in error_message.lower()
@@ -611,29 +579,34 @@ class MCPEnvironment(Environment):
                 error_type = ToolErrorType.INVALID_ARGS
             else:
                 error_type = ToolErrorType.EXECUTION_ERROR
-
             return CallToolObservation(
                 tool_name=action.tool_name,
                 result=None,
-                error=ToolError(
-                    error_type=error_type,
-                    message=error_message,
-                ),
+                error=ToolError(error_type=error_type, message=error_message),
             )
 
-    async def _async_call_tool(self, tool_name: str, arguments: dict) -> Any:
+    async def step_async(
+        self,
+        action: Action,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> Observation:
         """
-        Async helper to call a tool on the MCP server.
+        Async step that routes MCP actions without going through run_async_safely.
 
-        Args:
-            tool_name: Name of the tool to invoke.
-            arguments: Dictionary of arguments to pass to the tool.
-
-        Returns:
-            The result from the tool execution.
+        The WebSocket handler calls this directly on the outer event loop, where
+        the MCP session is already open, avoiding the thread/event-loop deadlock
+        that occurs when the sync step() path is used via run_in_executor.
         """
-        async with self.mcp_session() as client:
-            return await client.call_tool(tool_name, arguments)
+        if isinstance(action, ListToolsAction):
+            return await self._async_handle_list_tools()
+        elif isinstance(action, CallToolAction):
+            return await self._async_handle_call_tool(action, timeout_s=timeout_s)
+        else:
+            loop = asyncio.get_event_loop()
+            return await loop.run_in_executor(
+                None, lambda: self._step_impl(action, timeout_s=timeout_s, **kwargs)
+            )
 
     @abstractmethod
     def _step_impl(

src/openenv/core/env_server/web_interface.py

@@ -22,7 +22,7 @@ from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional, Type
 
 import gradio as gr
-from fastapi import Body, FastAPI, HTTPException, WebSocket, WebSocketDisconnect, status
+from fastapi import Body, FastAPI, HTTPException, status, WebSocket, WebSocketDisconnect
 from fastapi.responses import RedirectResponse
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -356,7 +356,9 @@ class WebInterfaceManager:
         else:
             # Run sync reset in thread pool to avoid blocking event loop
             # and to support environments using sync libraries (e.g., Playwright)
-            observation = await self._run_sync_in_thread_pool(self.env.reset, **valid_kwargs)
+            observation = await self._run_sync_in_thread_pool(
+                self.env.reset, **valid_kwargs
+            )
         state: State = self.env.state
 
         # Serialize observation once using shared utility

src/openenv_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openenv-core
-Version: 0.2.3.dev0
+Version: 0.2.3
 Summary: A unified framework for reinforcement learning environments
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

src/openenv_core.egg-info/SOURCES.txt

@@ -1,4 +1,5 @@
 LICENSE
+MANIFEST.in
 README.md
 pyproject.toml
 src/openenv/__init__.py
@@ -19,8 +20,6 @@ src/openenv/cli/commands/serve.py
 src/openenv/cli/commands/skills.py
 src/openenv/cli/commands/validate.py
 src/openenv/cli/templates/__init__.py
-src/openenv/cli/templates/__pycache__/__init__.cpython-311.pyc
-src/openenv/cli/templates/__pycache__/__init__.cpython-313.pyc
 src/openenv/cli/templates/openenv_env/README.md
 src/openenv/cli/templates/openenv_env/__init__.py
 src/openenv/cli/templates/openenv_env/client.py