verifiers 0.3.2.dev78__tar.gz → 0.3.2.dev80__tar.gz

{verifiers-0.3.2.dev78 → verifiers-0.3.2.dev80}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev78
+Version: 0.3.2.dev80
 Summary: Verifiers: Environments for LLM Reinforcement Learning
 Project-URL: Homepage, https://github.com/primeintellect-ai/verifiers
 Project-URL: Documentation, https://github.com/primeintellect-ai/verifiers

{verifiers-0.3.2.dev78 → verifiers-0.3.2.dev80}/verifiers/v1/runtimes/base.py

@@ -24,10 +24,11 @@ from verifiers.v1.utils.aio import run_shielded
 
 logger = logging.getLogger(__name__)
 
-# Ensure the latest `uv` is available for our PEP 723 scripts: prefer pip on Python images,
-# then fall back to the standalone installer (curl/wget), installing curl + CA certs when a
-# bare image has no downloader. Both paths install to ~/.local/bin, which we prepend to PATH.
-# (Needs network + one of pip / curl / wget / apt-get / apk.)
+# Ensure `uv` is available for our PEP 723 scripts: keep one already on PATH (an image that
+# pre-installs it, or an earlier rollout's install on the same box); otherwise prefer pip on
+# Python images, then fall back to the standalone installer (curl/wget), installing curl + CA
+# certs when a bare image has no downloader. Both install paths land in ~/.local/bin, which we
+# prepend to PATH first. (Installing needs network + one of pip / curl / wget / apt-get / apk.)
 _INSTALL_CURL = (  # only when the image has no downloader; needs a known package manager
     "{ command -v curl >/dev/null 2>&1 || command -v wget >/dev/null 2>&1; } "
     "|| { apt-get update -qq && apt-get install -y -qq curl ca-certificates; } "
@@ -39,7 +40,8 @@ _DOWNLOAD_UV = (
 )
 _ENSURE_UV = (
     'export PATH="$HOME/.local/bin:$PATH" UV_INSTALL_DIR="$HOME/.local/bin"; '
-    "pip install -q -U --user uv 2>/dev/null "
+    "command -v uv >/dev/null 2>&1 "
+    "|| pip install -q -U --user uv 2>/dev/null "
     f"|| {{ {_INSTALL_CURL}; {_DOWNLOAD_UV}; }}"
 )
 

{verifiers-0.3.2.dev78 → verifiers-0.3.2.dev80}/verifiers/v1/tasksets/harbor/taskset.py

@@ -32,9 +32,11 @@ from typing import Annotated
 
 from pydantic import BaseModel, ConfigDict, Field, TypeAdapter, ValidationError
 
+from verifiers.v1.configs.task import TaskConfig
 from verifiers.v1.configs.taskset import TasksetConfig
 from verifiers.v1.errors import SandboxError, TaskError
 from verifiers.v1.runtimes import Runtime
+from verifiers.v1.state import State
 from verifiers.v1.task import Task, TaskData, TaskResources, TaskTimeout
 from verifiers.v1.taskset import Taskset
 from verifiers.v1.trace import Trace
@@ -53,7 +55,13 @@ REWARD_JSON_ADAPTER = TypeAdapter(
 )
 
 
+class HarborTaskConfig(TaskConfig):
+    mcp_servers: list[dict] = Field(default_factory=list)
+    """Task-declared connections, bound from HarborData during construction."""
+
+
 class HarborConfig(TasksetConfig):
+    task: HarborTaskConfig = HarborTaskConfig()
     dataset: str = "harbor/hello-world"
     """A Harbor Hub package id ("org/name" or "org/name@ref"), where ref is a
     tag, integer revision, or sha256 digest. Legacy registries selected with `repo`,
@@ -147,6 +155,8 @@ class HarborData(TaskData):
     env: dict[str, str] = Field(default_factory=dict)
     """Raw `[environment.env]` templates, resolved only when the runtime starts."""
     healthcheck: dict | None = None
+    mcp_servers: list[dict] = Field(default_factory=list)
+    """Task-declared MCP servers, preserved for served-task reconstruction."""
     verifier_env: dict[str, str] = Field(default_factory=dict)
     """Raw [verifier.env] entries (literals or `${VAR}`/`${VAR:-default}` templates).
     Resolved against the host environment at scoring time, like `harbor run` — so a
@@ -159,11 +169,25 @@ class HarborData(TaskData):
     grades in the agent's box."""
 
 
-class HarborTask(Task[HarborData]):
+class HarborTask(Task[HarborData, State, HarborTaskConfig]):
     """Stage and run Harbor's verifier inside the task's live runtime."""
 
     verifier_staged: bool = False
 
+    def __init__(self, data: HarborData, config: HarborTaskConfig | None = None):
+        super().__init__(data, config)
+        # Each reconstructed row gets its own connections without mutating worker config.
+        self.config = self.config.model_copy(update={"mcp_servers": data.mcp_servers})
+
+    @classmethod
+    def toolsets(cls, config: HarborTaskConfig):
+        from .toolset import HarborMCPConfig, HarborMCPToolset
+
+        return super().toolsets(config) + [
+            HarborMCPToolset(HarborMCPConfig(colocated=True, server=server))
+            for server in config.mcp_servers
+        ]
+
     def runtime_env(self) -> dict[str, str]:
         return resolve_env(self.data.env)
 
@@ -369,6 +393,7 @@ def verifier_box_data(data: HarborData) -> HarborData:
             "upload_environment": data.upload_environment if fresh else False,
             "env": dict(verifier.env),
             "healthcheck": verifier.healthcheck,
+            "mcp_servers": [],
             "network_allow": list(verifier.network_allow),
             "network_block": [],
         }
@@ -587,7 +612,9 @@ def parse_task(task_dir: Path, idx: int, harbor_config: HarborConfig) -> HarborD
         tags=meta.get("tags", []),
         task_dir=str(task_dir),
         upload_environment=upload_environment,
-        **environment.model_dump(include={"env", "healthcheck"}, mode="json"),
+        **environment.model_dump(
+            include={"env", "healthcheck", "mcp_servers"}, mode="json"
+        ),
         verifier_env=parsed.verifier.env,
         artifacts=artifacts,
         collect=hooks,
@@ -703,9 +730,7 @@ def parse_verifier_environment(
             task_dir.name,
         )
     unsupported = [
-        field
-        for field in ("mcp_servers", "skills_dir", "tpu")
-        if getattr(environment, field, None)
+        field for field in ("skills_dir", "tpu") if getattr(environment, field, None)
     ]
     if environment.os != TaskOS.LINUX or unsupported:
         raise ValueError(

verifiers-0.3.2.dev80/verifiers/v1/tasksets/harbor/toolset.py

@@ -0,0 +1,86 @@
+"""Task-declared Harbor MCP tools served through the standard VF toolset lifecycle."""
+
+import os
+from typing import Any, cast
+
+from mcp import Client
+from mcp.client.sse import sse_client
+from mcp.client.stdio import StdioServerParameters, stdio_client
+from mcp.client.streamable_http import streamable_http_client
+from mcp.server.mcpserver import Context, MCPServer
+from mcp.types import CallToolResult, Tool
+
+from verifiers.v1.mcp import Toolset, ToolsetConfig
+
+
+class HarborMCPConfig(ToolsetConfig):
+    server: dict[str, Any]
+    """One declaration already validated by Harbor's task parser."""
+
+
+class HarborMCPToolset(Toolset[HarborMCPConfig]):
+    @property
+    def server_name(self) -> str:
+        return self.config.server["name"]
+
+    async def setup(self) -> None:
+        spec = self.config.server
+        match spec["transport"]:
+            case "stdio":
+                # Keep task variables, excluding the wrapper's state and bind controls.
+                env = {
+                    key: value
+                    for key, value in os.environ.items()
+                    if key
+                    not in {
+                        "VF_CONFIG",
+                        "VF_STATE_URL",
+                        "VF_STATE_SECRET",
+                        "MCP_HOST",
+                        "MCP_PORT",
+                        "MCP_PORT_FILE",
+                    }
+                }
+                transport = stdio_client(
+                    StdioServerParameters(
+                        command=spec["command"], args=spec.get("args", []), env=env
+                    )
+                )
+            case "sse":
+                transport = sse_client(spec["url"])
+            case "streamable-http":
+                transport = streamable_http_client(spec["url"])
+            case other:
+                raise ValueError(f"Unsupported Harbor MCP transport: {other!r}")
+        # ServerBase enters and closes this stack in the same task. Keep upstream
+        # session state across downstream client reconnects for the whole rollout.
+        self.client = await self._exit_stack.enter_async_context(Client(transport))
+
+    def register(self, mcp: MCPServer) -> None:
+        # MCPServer calls these public methods; forward the real catalog and schemas.
+        server = cast(Any, mcp)
+        server.list_tools = self.list_tools
+        server.call_tool = self.call_tool
+
+    async def list_tools(self) -> list[Tool]:
+        tools: list[Tool] = []
+        cursor = None
+        seen_cursors: set[str] = set()
+        while True:
+            page = await self.client.list_tools(cursor=cursor)
+            tools.extend(page.tools)
+            cursor = page.next_cursor
+            if cursor is None:
+                return tools
+            if cursor in seen_cursors:
+                raise ValueError("MCP tools pagination returned a repeated cursor")
+            seen_cursors.add(cursor)
+
+    async def call_tool(
+        self, name: str, arguments: dict[str, Any], context: Context | None = None
+    ) -> CallToolResult:
+        return await self.client.call_tool(name, arguments)
+
+
+if __name__ == "__main__":
+    HarborMCPToolset.run()