openenv 0.2.2__tar.gz → 0.2.3__tar.gz

openenv-0.2.3/MANIFEST.in

@@ -0,0 +1,2 @@
+global-exclude *.py[cod]
+global-exclude __pycache__/*

{openenv-0.2.2/src/openenv.egg-info → openenv-0.2.3}/PKG-INFO

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

{openenv-0.2.2 → openenv-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openenv"
-version = "0.2.2"
+version = "0.2.3"
 description = "A unified framework for reinforcement learning environments"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -86,8 +86,12 @@ include-package-data = true
 [tool.setuptools.package-data]
 "openenv.cli" = ["templates/**/*"]
 
+[tool.setuptools.exclude-package-data]
+"*" = ["*.pyc", "*.pyo", "__pycache__/*"]
+
 [tool.setuptools.packages.find]
 where = ["src"]
+exclude = ["*.__pycache__", "*.__pycache__.*"]
 
 [tool.coverage.run]
 omit = [

{openenv-0.2.2 → openenv-0.2.3}/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", "openenv"):
+        try:
+            return metadata.version(distribution_name)
+        except metadata.PackageNotFoundError:
+            continue
+    return "0.0.0"
+
+
+__version__ = _load_package_version()
 
 
 _LAZY_MODULES = {

{openenv-0.2.2 → openenv-0.2.3}/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] @ git+https://github.com/meta-pytorch/OpenEnv.git",
-    "openenv[core]>=0.2.1",
+    "openenv[core]>=0.2.2",
     # Environment-specific dependencies
     # Add all dependencies needed for your environment here
     # Examples:

{openenv-0.2.2 → openenv-0.2.3}/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
 

{openenv-0.2.2 → openenv-0.2.3}/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(

{openenv-0.2.2 → openenv-0.2.3}/src/openenv/core/env_server/web_interface.py

@@ -15,13 +15,15 @@ option (e.g. openenv push --enable-interface) or ENABLE_WEB_INTERFACE env var.
 from __future__ import annotations
 
 import asyncio
+import inspect
 import json
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional, Type
 
 import gradio as gr
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi import Body, FastAPI, HTTPException, status, WebSocket, WebSocketDisconnect
+from fastapi.responses import RedirectResponse
 from pydantic import BaseModel, ConfigDict, Field
 
 from .gradio_theme import OPENENV_GRADIO_CSS, OPENENV_GRADIO_THEME
@@ -269,6 +271,28 @@ class WebInterfaceManager:
         # Thread pool for running sync code (e.g., Playwright sync API) in async context
         self._executor = ThreadPoolExecutor(max_workers=1)
 
+    @staticmethod
+    def _get_valid_kwargs(
+        sig: inspect.Signature,
+        kwargs: Dict[str, Any],
+        skip_params: Optional[set[str]] = None,
+    ) -> Dict[str, Any]:
+        """Filter kwargs to only those accepted by the target function."""
+        skip_params = skip_params or set()
+        valid_kwargs: Dict[str, Any] = {}
+        has_var_kwargs = any(
+            param.kind == inspect.Parameter.VAR_KEYWORD
+            for param in sig.parameters.values()
+        )
+
+        for key, value in kwargs.items():
+            if key in skip_params:
+                continue
+            if key in sig.parameters or has_var_kwargs:
+                valid_kwargs[key] = value
+
+        return valid_kwargs
+
     async def _run_sync_in_thread_pool(self, func, *args, **kwargs):
         """Run a synchronous function in the thread pool executor.
 
@@ -317,11 +341,24 @@ class WebInterfaceManager:
         for client in disconnected_clients:
             self.connected_clients.remove(client)
 
-    async def reset_environment(self) -> Dict[str, Any]:
+    async def reset_environment(
+        self, reset_kwargs: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
         """Reset the environment and update state."""
-        # Run sync reset in thread pool to avoid blocking event loop
-        # and to support environments using sync libraries (e.g., Playwright)
-        observation: Observation = await self._run_sync_in_thread_pool(self.env.reset)
+        reset_kwargs = reset_kwargs or {}
+
+        is_async = self.env.reset_async.__func__ is not Environment.reset_async
+        sig = inspect.signature(self.env.reset_async if is_async else self.env.reset)
+        valid_kwargs = self._get_valid_kwargs(sig, reset_kwargs)
+
+        if is_async:
+            observation = await self.env.reset_async(**valid_kwargs)
+        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
+            )
         state: State = self.env.state
 
         # Serialize observation once using shared utility
@@ -428,6 +465,16 @@ def create_web_interface_app(
     web_manager = WebInterfaceManager(env, action_cls, observation_cls, metadata)
 
     # Web API routes first (so they take precedence over Gradio mount at /web)
+    @app.get("/", include_in_schema=False)
+    async def web_root():
+        """Redirect the app root to the Gradio interface."""
+        return RedirectResponse(url="/web/")
+
+    @app.get("/web", include_in_schema=False)
+    async def web_root_no_slash():
+        """Redirect /web to /web/ for mounted Gradio deployments behind proxies."""
+        return RedirectResponse(url="/web/")
+
     @app.get("/web/metadata")
     async def web_metadata():
         """Get environment metadata."""
@@ -449,9 +496,9 @@ def create_web_interface_app(
             await web_manager.disconnect_websocket(websocket)
 
     @app.post("/web/reset")
-    async def web_reset():
+    async def web_reset(request: Optional[Dict[str, Any]] = Body(default=None)):
         """Reset endpoint for web interface."""
-        return await web_manager.reset_environment()
+        return await web_manager.reset_environment(request)
 
     @app.post("/web/step")
     async def web_step(request: Dict[str, Any]):
@@ -475,7 +522,13 @@ def create_web_interface_app(
     @app.get("/web/state")
     async def web_state():
         """State endpoint for web interface."""
-        return web_manager.get_state()
+        try:
+            return web_manager.get_state()
+        except RuntimeError as exc:
+            raise HTTPException(
+                status_code=status.HTTP_409_CONFLICT,
+                detail=str(exc),
+            ) from exc
 
     action_fields = _extract_action_fields(action_cls)
     is_chat_env = _is_chat_env(action_cls)
@@ -505,7 +558,7 @@ def create_web_interface_app(
             )
         gradio_blocks = gr.TabbedInterface(
             [default_blocks, custom_blocks],
-            tab_names=["Playground", "Visualization"],
+            tab_names=["Playground", "Custom"],
             title=get_gradio_display_title(metadata),
         )
     else:

{openenv-0.2.2 → openenv-0.2.3/src/openenv.egg-info}/PKG-INFO

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

{openenv-0.2.2 → openenv-0.2.3}/src/openenv.egg-info/SOURCES.txt

@@ -1,4 +1,5 @@
 LICENSE
+MANIFEST.in
 README.md
 pyproject.toml
 setup.cfg