revert mcp gym issue

Author: Benny Chen

eval_protocol/mcp/client/connection.py

@@ -441,34 +441,24 @@ async def call_tool(self, session: MCPSession, tool_name: str, arguments: Dict)
         # Extract data plane results (observation only)
         if tool_result.content and len(tool_result.content) > 0:
             content = tool_result.content[0]
-            # Safely attempt to read a "text" attribute if present across content types
-            text_attr = getattr(content, "text", None)
-            if isinstance(text_attr, str):
-                content_text = text_attr
-            elif isinstance(text_attr, list):
-                # text can also be an array of parts with optional .text fields
-                content_text = "".join([getattr(p, "text", "") for p in text_attr])
-            else:
-                content_text = None
-
-            if isinstance(content_text, str):
+            if hasattr(content, "text"):
                 # Fix: Handle empty or invalid JSON responses gracefully
-                if content_text.strip() == "":
+                if not content.text or content.text.strip() == "":
                     logger.warning(f"Session {session.session_id}: Empty tool response from {tool_name}")
                     observation = {
                         "observation": "empty_response",
                         "session_id": session.session_id,
                     }
                 else:
                     try:
-                        observation = json.loads(content_text)
+                        observation = json.loads(content.text)
                     except json.JSONDecodeError as e:
                         logger.warning(
-                            f"Session {session.session_id}: Invalid JSON from {tool_name}: {content_text}. Error: {e}"
+                            f"Session {session.session_id}: Invalid JSON from {tool_name}: {content.text}. Error: {e}"
                         )
                         # Create a structured response from the raw text
                         observation = {
-                            "observation": content_text,
+                            "observation": content.text,
                             "session_id": session.session_id,
                             "error": "invalid_json_response",
                         }

eval_protocol/mcp/mcpgym.py

@@ -205,6 +205,15 @@ def _get_or_create_session(self, ctx: Context) -> Dict[str, Any]:
         """
         session_id = self._get_session_id(ctx)
         print(f"🔍 _get_or_create_session: session_id: {session_id}")
+        if session_id not in self.sessions:
+            env, obs, info = self._new_env(seed=None)
+            with self.session_lock:
+                self.sessions[session_id] = {
+                    "env": env,
+                    "obs": obs,
+                    "session_data": {},
+                    "session_id": session_id,
+                }
         return self.sessions[session_id]
 
     def _register_session_reset_endpoint(self):
@@ -400,6 +409,15 @@ def _execute_session_environment_step(self, session_id: str, action: Any) -> Dic
         Returns:
             Data plane response (observation only, no rewards)
         """
+        if session_id not in self.sessions:
+            env, obs, info = self._new_env(seed=None)
+            with self.session_lock:
+                self.sessions[session_id] = {
+                    "env": env,
+                    "obs": obs,
+                    "session_data": {},
+                    "session_id": session_id,
+                }
         session_data = self.sessions[session_id]
         env = session_data["env"]
 

tests/pytest/test_mcp_session_autocreate.py

@@ -0,0 +1,61 @@
+"""
+Regression test: ensure MCP-Gym auto-creates a session on first tool call
+without requiring a prior initial state fetch, and returns JSON.
+"""
+
+import time
+from multiprocessing import Process
+
+import httpx
+import pytest
+
+from eval_protocol.mcp.client.connection import MCPConnectionManager
+from eval_protocol.types import MCPSession
+
+
+def _run_airline_server():
+    import os
+
+    os.environ["PORT"] = "9780"
+    from eval_protocol.mcp_servers.tau2.tau2_mcp import AirlineDomainMcp
+
+    server = AirlineDomainMcp(seed=None)
+    server.run(transport="streamable-http")
+
+
+@pytest.mark.asyncio
+async def test_tool_call_returns_json_without_prior_initial_state():
+    proc = Process(target=_run_airline_server, daemon=True)
+    proc.start()
+
+    try:
+        base_url = "http://127.0.0.1:9780/mcp"
+        client = httpx.Client(timeout=1.0)
+        deadline = time.time() + 20
+        while time.time() < deadline:
+            try:
+                r = client.get(base_url)
+                if r.status_code in (200, 307, 406):
+                    break
+            except Exception:
+                pass
+            time.sleep(0.2)
+        else:
+            pytest.fail("Server did not start on port 9780 in time")
+
+        session = MCPSession(base_url=base_url, session_id="test-autocreate", seed=None, model_id="test-model")
+
+        mgr = MCPConnectionManager()
+        await mgr.initialize_session(session)
+        await mgr.discover_tools(session)
+
+        observation, reward, done, info = await mgr.call_tool(session, "list_all_airports", {})
+
+        assert isinstance(observation, dict), f"Expected JSON dict, got: {type(observation)} {observation}"
+        assert observation.get("error") != "invalid_json_response"
+
+        await mgr.reset_session(session)
+        await mgr.close_session(session)
+    finally:
+        proc.terminate()
+        proc.join(timeout=5)