verifiers 0.4.1.dev26__tar.gz → 0.4.1.dev27__tar.gz

{verifiers-0.4.1.dev26 → verifiers-0.4.1.dev27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.4.1.dev26
+Version: 0.4.1.dev27
 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.4.1.dev26 → verifiers-0.4.1.dev27}/tests/integration/conftest.py

@@ -67,6 +67,9 @@ def pytest_configure(config) -> None:
     inherits `PYTHONPATH` but not pytest's in-process `pythonpath`. Put the fixture dir on
     `PYTHONPATH` so a fixture server module (e.g. `tool_response_image_v1`)
     resolves there too — an installed example package (e.g. `glossary`) already would."""
+    config.addinivalue_line(
+        "markers", "opencode: integration cells on the OpenCode harness"
+    )
     fixtures = str(Path(__file__).parent / "fixtures")
     existing = os.environ.get("PYTHONPATH", "")
     if fixtures not in existing.split(os.pathsep):

{verifiers-0.4.1.dev26 → verifiers-0.4.1.dev27}/tests/integration/grid.py

@@ -52,6 +52,7 @@ HARNESSES: list[str | dict] = [
     "kimi-code",
     "pi",
     "openclaw",
+    "opencode",
     "mini-swe-agent",
     "prime-agent",
 ]

{verifiers-0.4.1.dev26 → verifiers-0.4.1.dev27}/verifiers/v1/harnesses/__init__.py

@@ -19,6 +19,7 @@ from verifiers.v1.harnesses.mini_swe_agent import (
 )
 from verifiers.v1.harnesses.null import NullHarness, NullHarnessConfig
 from verifiers.v1.harnesses.openclaw import OpenClawHarness, OpenClawHarnessConfig
+from verifiers.v1.harnesses.opencode import OpenCodeHarness, OpenCodeHarnessConfig
 from verifiers.v1.harnesses.pi import PiHarness, PiHarnessConfig
 from verifiers.v1.harnesses.prime_agent import (
     PrimeAgentHarness,
@@ -46,6 +47,8 @@ __all__ = [
     "NullHarnessConfig",
     "OpenClawHarness",
     "OpenClawHarnessConfig",
+    "OpenCodeHarness",
+    "OpenCodeHarnessConfig",
     "PiHarness",
     "PiHarnessConfig",
     "PrimeAgentHarness",

verifiers-0.4.1.dev27/verifiers/v1/harnesses/opencode/__init__.py

@@ -0,0 +1,6 @@
+from verifiers.v1.harnesses.opencode.harness import (
+    OpenCodeHarness,
+    OpenCodeHarnessConfig,
+)
+
+__all__ = ["OpenCodeHarness", "OpenCodeHarnessConfig"]

verifiers-0.4.1.dev27/verifiers/v1/harnesses/opencode/harness.py

@@ -0,0 +1,141 @@
+"""Run OpenCode 2's native ACP server against interception."""
+
+import json
+from pathlib import Path
+from typing import Literal
+
+from verifiers.v1.acp import ACPConfig, ACPHarness
+from verifiers.v1.clients import ModelContext
+from verifiers.v1.configs.harness import HarnessConfig, PinnedVersion
+from verifiers.v1.harnesses.node import ensure_node
+from verifiers.v1.harnesses.utils.install import ensure_installed, remove_dir
+from verifiers.v1.runtimes import Runtime
+from verifiers.v1.task import TaskData
+from verifiers.v1.trace import Trace
+
+OPENCODE_DIR = "/var/tmp/vf-opencode"
+STATE_ROOT = "/tmp/vf-opencode-runs"
+KEY_VAR = "VF_OPENCODE_API_KEY"
+MCP_READY = (Path(__file__).resolve().parent / "mcp-ready.js").read_bytes()
+
+INSTALL = r"""
+set -e
+export PATH="/var/tmp/vf-node/bin:$PATH"
+npm install --prefix "$VF_OPENCODE_DIR" --no-audit --no-fund --omit=dev \
+    "@opencode/cli@$VF_OPENCODE_VERSION" >/dev/null
+"""
+
+
+class OpenCodeHarnessConfig(HarnessConfig):
+    version: PinnedVersion = "2.0.26"
+    """OpenCode 2 release to install, pinned for reproducibility."""
+    transport: Literal["chat_completions", "responses", "anthropic_messages"] = (
+        "chat_completions"
+    )
+    """Model API transport."""
+    disabled_tools: list[str] | None = None
+    """OpenCode permission actions to deny, such as shell, read, or edit."""
+
+
+class OpenCodeHarness(ACPHarness[OpenCodeHarnessConfig]):
+    APPENDS_SYSTEM_PROMPT = True
+    SUPPORTS_MCP = True
+    SUPPORTS_SKILLS = True
+
+    async def setup(self, runtime: Runtime) -> None:
+        await ensure_node(runtime)
+        directory = f"{OPENCODE_DIR}/{self.config.version}"
+        await ensure_installed(
+            runtime,
+            directory=directory,
+            ready=f"[ -x {directory}/node_modules/.bin/opencode ]",
+            install=INSTALL,
+            env={
+                **self.config.resolved_env,
+                "VF_OPENCODE_DIR": directory,
+                "VF_OPENCODE_VERSION": self.config.version,
+            },
+            label="OpenCode",
+        )
+        await super().setup(runtime)
+
+    async def prepare_acp(
+        self,
+        ctx: ModelContext,
+        trace: Trace,
+        runtime: Runtime,
+        endpoint: str,
+        secret: str,
+        mcp_urls: dict[str, str],
+        data: TaskData,
+    ) -> ACPConfig:
+        root = f"{STATE_ROOT}/{trace.id}"
+        config_dir = f"{root}/config/opencode"
+        await self.install_skills(runtime, f"{config_dir}/skills")
+        system_prompt, prompt = self.resolve_prompt(data)
+        if system_prompt:
+            await runtime.write(f"{config_dir}/AGENTS.md", system_prompt.encode())
+
+        package = {
+            "chat_completions": "openai-compatible",
+            "responses": "openai-compatible/responses",
+            "anthropic_messages": "anthropic-compatible",
+        }[self.config.transport]
+        settings = {
+            "model": "intercept/model",
+            "providers": {
+                "intercept": {
+                    "env": [KEY_VAR],
+                    "package": f"@opencode/ai/providers/{package}",
+                    "settings": {"baseURL": endpoint},
+                    "models": {"model": {"modelID": ctx.model}},
+                }
+            },
+            "default_agent": "build",
+            # Auxiliary title/summary model calls must not become rollout turns.
+            "agents": {"title": {"disabled": True}, "summary": {"disabled": True}},
+            "permissions": [
+                {"action": "*", "resource": "*", "effect": "allow"},
+                *(
+                    {"action": tool, "resource": "*", "effect": "deny"}
+                    for tool in self.config.disabled_tools or []
+                ),
+            ],
+            "update": "disable",
+            "share": "disabled",
+            "snapshots": False,
+        }
+        if mcp_urls:
+            plugin_dir = f"{root}/mcp-ready"
+            await runtime.write(f"{plugin_dir}/index.js", MCP_READY)
+            settings["plugins"] = [
+                {
+                    "package": plugin_dir,
+                    "options": {
+                        "servers": list(mcp_urls),
+                        "timeout": int(self.config.tool_timeout * 1000),
+                    },
+                }
+            ]
+        return ACPConfig(
+            command=[
+                f"{OPENCODE_DIR}/{self.config.version}/node_modules/.bin/opencode",
+                "acp",
+            ],
+            env={
+                **self.config.resolved_env,
+                KEY_VAR: secret,
+                "XDG_CONFIG_HOME": f"{root}/config",
+                "XDG_DATA_HOME": f"{root}/data",
+                "XDG_CACHE_HOME": f"{root}/cache",
+                "XDG_STATE_HOME": f"{root}/state",
+                "OPENCODE_CONFIG_DIR": config_dir,
+                "OPENCODE_CONFIG_CONTENT": json.dumps(settings),
+                "OPENCODE_DISABLE_AUTOUPDATE": "1",
+                "OPENCODE_DISABLE_MODELS_FETCH": "1",
+            },
+            prompt=prompt,
+        )
+
+    async def cleanup(self, trace: Trace, runtime: Runtime) -> None:
+        await remove_dir(runtime, f"{STATE_ROOT}/{trace.id}", "OpenCode state")

verifiers-0.4.1.dev27/verifiers/v1/harnesses/opencode/mcp-ready.js

@@ -0,0 +1,44 @@
+import { Context, Effect } from "effect";
+
+export default {
+  id: "verifiers.mcp-ready",
+  effect: Effect.fn(function* (ctx) {
+    // ACP registrations bypass OpenCode's configured MCP server timeout defaults.
+    yield* ctx.mcp.transform((editor) => {
+      for (const name of ctx.options.servers) {
+        editor.update(name, (server) => {
+          server.timeout = { ...server.timeout, execution: ctx.options.timeout };
+        });
+      }
+    });
+    yield* ctx.session.hook(
+      "prompt",
+      Effect.fn(function* () {
+        // OpenCode 2.0.26's public plugin API omits discovered MCP tools. Read
+        // its native service in the prompt's location context, including empty servers.
+        const mcp = yield* Context.Service()("@opencode/MCP");
+        const servers = yield* mcp.servers();
+        for (const name of ctx.options.servers) {
+          const server = servers.find((server) => server.name === name);
+          if (server?.status.status !== "connected") {
+            return yield* Effect.die(
+              new Error(`MCP server ${name} is not connected: ${JSON.stringify(server?.status)}`),
+            );
+          }
+        }
+        const expected = (yield* mcp.tools())
+          .filter((tool) => ctx.options.servers.includes(tool.server))
+          .map((tool) => `${tool.server}_${tool.name}`.replace(/[^a-zA-Z0-9_-]/g, "_"));
+        // ACP session/new awaits connection, but OpenCode refreshes its tool
+        // registry asynchronously. Do not let the prompt snapshot an old catalog.
+        yield* Effect.gen(function* () {
+          while (true) {
+            const registered = new Set((yield* ctx.tool.list()).map((tool) => tool.id));
+            if (expected.every((name) => registered.has(name))) return;
+            yield* Effect.sleep("10 millis");
+          }
+        }).pipe(Effect.timeout(ctx.options.timeout), Effect.orDie);
+      }),
+    );
+  }),
+};