verifiers 0.3.2.dev77__tar.gz → 0.3.2.dev79__tar.gz

{verifiers-0.3.2.dev77 → verifiers-0.3.2.dev79}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev77
+Version: 0.3.2.dev79
 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.dev77 → verifiers-0.3.2.dev79}/verifiers/v1/envs/isolated_verifier/env.py

@@ -91,8 +91,8 @@ class IsolatedVerifierEnv(vf.Env[IsolatedVerifierEnvConfig]):
             if not PurePosixPath(artifact.source).is_absolute()
         ]
         solver = resolve_runtime_config(self.config.agent.runtime, task)
-        solver_workdir = PurePosixPath(getattr(solver, "workdir", "") or "/")
-        verifier_workdir = PurePosixPath(config.workdir)
+        solver_workdir = PurePosixPath(getattr(solver, "workdir", "/") or "/app")
+        verifier_workdir = PurePosixPath(config.workdir or "/app")
         if relative and solver_workdir != verifier_workdir:
             raise ValueError(
                 "isolated-verifier cannot transfer relative artifacts "

{verifiers-0.3.2.dev77 → verifiers-0.3.2.dev79}/verifiers/v1/runtimes/docker/__init__.py

@@ -33,7 +33,8 @@ logger = logging.getLogger(__name__)
 class DockerConfig(NetworkPolicyConfig):
     type: Literal["docker"] = "docker"
     image: str = "python:3.11-slim"
-    workdir: str = "/app"
+    workdir: str | None = None
+    """Working directory override; None uses the task's workdir, or /app."""
     # TaskData.resources uses these units; non-default runtime config values take precedence.
     cpu: float | None = None
     """Pin the container to this many CPU cores (docker `--cpus`). None = unlimited."""
@@ -178,8 +179,8 @@ control.sendmsg([b"listener"], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, array.arr
 class DockerRuntime(Runtime):
     def __init__(self, config: DockerConfig, name: str | None = None) -> None:
         super().__init__(name)
-        self.config = config
-        self.info = DockerRuntimeInfo(**config.model_dump())
+        self.config = config.model_copy(update={"workdir": config.workdir or "/app"})
+        self.info = DockerRuntimeInfo(**self.config.model_dump())
         self._container: str | None = None  # our `--name` (used for exec/rm)
         self._proxy: EgressProxy | None = None
         self._proxy_host_ip: str | None = None

{verifiers-0.3.2.dev77 → verifiers-0.3.2.dev79}/verifiers/v1/runtimes/modal.py

@@ -39,7 +39,8 @@ _APP_NAME = "verifiers-v1"
 class ModalConfig(BaseConfig):
     type: Literal["modal"] = "modal"
     image: str = "python:3.11-slim"
-    workdir: str = "/app"
+    workdir: str | None = None
+    """Working directory override; None uses the task's workdir, or /app."""
     network_access: bool = True
     region: str | None = None
     """Region to provision in (None = provider-chosen)."""
@@ -107,8 +108,8 @@ class ModalRuntime(Runtime):
 
     def __init__(self, config: ModalConfig, name: str | None = None) -> None:
         super().__init__(name)
-        self.config = config
-        self.info = ModalRuntimeInfo(**config.model_dump())
+        self.config = config.model_copy(update={"workdir": config.workdir or "/app"})
+        self.info = ModalRuntimeInfo(**self.config.model_dump())
         self._sandbox = None
 
     @property

{verifiers-0.3.2.dev77 → verifiers-0.3.2.dev79}/verifiers/v1/runtimes/prime.py

@@ -76,7 +76,8 @@ class PrimeConfig(NetworkPolicyConfig):
     platform auto-builds what the sandbox needs from it (a VM image for `vm` sandboxes,
     ~10 minutes) and caches the result, so later sandboxes on the same ref start in
     seconds."""
-    workdir: str = "/app"
+    workdir: str | None = None
+    """Working directory override; None uses the task's workdir, or /app."""
     vm: bool = True
     """Run as a micro-VM rather than a container (kernel features / stronger isolation)."""
     guaranteed: bool = False
@@ -149,8 +150,8 @@ class PrimeRuntime(Runtime):
     def __init__(self, config: PrimeConfig, name: str | None = None) -> None:
         ensure_prime_auth()
         super().__init__(name)
-        self.config = config
-        self.info = PrimeRuntimeInfo(**config.model_dump())
+        self.config = config.model_copy(update={"workdir": config.workdir or "/app"})
+        self.info = PrimeRuntimeInfo(**self.config.model_dump())
         self._client = None
 
     @property

{verifiers-0.3.2.dev77 → verifiers-0.3.2.dev79}/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.dev79/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()