support new tasks interface

Author: ollmer

experiments/run_miniwob.py

@@ -11,7 +11,7 @@
 from agentlab.agents.react_toolcall_agent import AgentConfig, LLMArgs, ReactToolCallAgentArgs
 from agentlab.agents.tapeagent.agent import TapeAgentArgs, load_config
 from agentlab.backends.browser.mcp_playwright import MCPPlaywright
-from agentlab.backends.browser.playwright import AsyncPlaywright
+from agentlab.backends.browser.playwright import SyncPlaywright
 from agentlab.benchmarks.miniwob import MiniWobBenchmark
 from agentlab.experiments.study import make_study
 from agentlab.llm.chat_api import BaseModelArgs
@@ -54,7 +54,7 @@ def parse_args():
     if args.backend == "bgym":
         benchmark = DEFAULT_BENCHMARKS["miniwob"](n_repeats=1)
     elif args.backend == "playwright":
-        benchmark = MiniWobBenchmark(backend_cls=AsyncPlaywright)
+        benchmark = MiniWobBenchmark(backend_cls=SyncPlaywright)
     elif args.backend == "mcp":
         benchmark = MiniWobBenchmark(backend_cls=MCPPlaywright)
     else:

experiments/test_mcp.py

@@ -8,7 +8,7 @@
 
 from mcp import ClientSession, StdioServerParameters, stdio_client
 from mcp import Tool as MCPTool
-from mcp.types import CallToolResult, ImageContent, TextContent
+from mcp.types import CallToolResult, ContentBlock, TextContent
 
 from agentlab.actions import FunctionSpec, ToolCall, ToolSpec
 from agentlab.backends.browser.base import BrowserBackend
@@ -24,7 +24,7 @@ def __init__(self, config_path: str, read_timeout_seconds: int = 10) -> None:
         self.tool_to_server: dict[str, str] = {}
         self.read_timeout_seconds = read_timeout_seconds
         self.exit_stack = AsyncExitStack()
-        self.loop = None
+        self.loop: asyncio.AbstractEventLoop
 
     def initialize(self):
         try:
@@ -125,15 +125,15 @@ def check_tool_exists(self, tool_name):
             raise Exception(f"Tool {tool_name} not found in any of the MCP servers")
         return server_name
 
-    def actions(self) -> tuple[ToolSpec]:
-        return (
+    def actions(self) -> list[ToolSpec]:
+        return [
             ToolSpec(
                 function=FunctionSpec(
                     name=tool.name, description=tool.description or "", parameters=tool.inputSchema
                 )
             )
             for tool in self.tools.values()
-        )
+        ]
 
     async def aclose(self) -> None:
         await self.exit_stack.aclose()
@@ -144,28 +144,28 @@ def close(self) -> None:
 
 class MCPBrowserBackend(BrowserBackend):
     config_path: str
-    _mcp = None
+    _mcp: MCPClient
 
     def initialize(self) -> None:
         self._mcp = MCPClient(config_path=self.config_path)
         self._mcp.initialize()
 
     def step(self, action: ToolCall) -> dict:
         contents = self.call_tool(action.name, action.arguments)
-        text = "\n".join([c.text for c in contents if c.type == "text"])
+        action_result = "\n".join([c.text for c in contents if c.type == "text"])
         images = [c for c in contents if c.type == "image"]
         return {
-            "text": text,
+            "action_result": action_result,
             "screenshot": images[-1] if images else None,
         }
 
-    def call_tool(self, tool_name: str, arguments: dict) -> list[TextContent | ImageContent]:
+    def call_tool(self, tool_name: str, arguments: dict) -> list[ContentBlock]:
         tool_result = self._mcp.call_tool(tool_name, arguments)
         if tool_result.isError:
-            return [TextContent(text=f"Error calling tool {tool_name}")] + tool_result.content
+            return [TextContent(type="text", text=f"Error calling tool {tool_name}")] + tool_result.content
         return tool_result.content
 
-    def actions(self) -> tuple[ToolSpec]:
+    def actions(self) -> list[ToolSpec]:
         return list(self._mcp.actions())
 
     def close(self) -> None:

src/agentlab/backends/browser/mcp.py

@@ -15,7 +15,7 @@
 class MCPPlaywright(MCPBrowserBackend):
     config_path: str = DEFAULT_CONFIG_PATH
 
-    def run_js(self, js: str):
+    def evaluate_js(self, js: str):
         contents = self.call_tool("browser_evaluate", {"function": js})
         raw_response = "\n".join([c.text for c in contents if c.type == "text"])
         try:
@@ -30,14 +30,14 @@ def run_js(self, js: str):
     def step(self, action: ToolCall) -> dict:
         contents = self.call_tool(action.name, action.arguments)
         logger.info(f"Step result has {len(contents)} contents")
-        tool_result = "\n".join(
+        action_result = "\n".join(
             [c.text for c in contents if c.type == "text" and "# Ran Playwright code" not in c.text]
         )
         html = self.page_html()
         screenshot = self.page_screenshot()
         axtree = self.page_axtree()
         return {
-            "tool_result": tool_result,
+            "action_result": action_result,
             "pruned_html": html,
             "axtree_txt": axtree,
             "screenshot": screenshot,
@@ -60,7 +60,7 @@ def page_axtree(self) -> str:
         contents = self.call_tool("browser_snapshot", {})
         return "\n".join([c.text for c in contents if c.type == "text"])
 
-    def page_screenshot(self) -> Image:
+    def page_screenshot(self) -> Image.Image:
         contents = self.call_tool("browser_take_screenshot", {})
         content = [c for c in contents if c.type == "image"][0]
         image_base64 = content.data

src/agentlab/backends/browser/mcp_playwright.py

@@ -28,7 +28,6 @@ def model_post_init(self, __context: Any) -> None:
         if self.dataset is None:
             self.dataset = get_miniwob_tasks()
         for task in self.dataset:
-            name = f"miniwob.{task.task_id}"
-            env_args = BrowserEnvArgs(task_name=name, task=task, backend_cls=self.backend_cls)
+            env_args = BrowserEnvArgs(task=task, backend_cls=self.backend_cls)
             self.env_args_list.append(env_args)
         logger.info(f"Loaded {len(self.env_args_list)} miniwob tasks")