roller-agent 0.2.0__py3-none-any.whl

roller/assets/opencode/runner.py

@@ -0,0 +1,203 @@
+"""Container-side bridge for the pinned OpenCode CLI; standard library only."""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+import subprocess
+import time
+
+VERSION = "1.18.30"
+TOOLS = ("bash", "read", "write", "edit", "apply_patch", "glob", "grep", "skill")
+
+
+def atomic_json(path, value):
+    temporary = path.with_suffix(".tmp")
+    temporary.write_text(json.dumps(value, ensure_ascii=False), encoding="utf-8")
+    temporary.replace(path)
+
+
+def native_reply(export):
+    messages = export.get("messages", [])
+    users = [m for m in messages if m.get("info", {}).get("role") == "user"]
+    if not users:
+        raise ValueError("OpenCode export has no user message")
+    user_id = users[-1]["info"]["id"]
+    assistants = [m for m in messages if m.get("info", {}).get("role") == "assistant" and m["info"].get("parentID") == user_id]
+    if not assistants:
+        raise ValueError("OpenCode turn has no assistant reply")
+    last = assistants[-1]
+    info = last["info"]
+    if info.get("error") or not info.get("time", {}).get("completed"):
+        raise ValueError("OpenCode turn did not complete: " + json.dumps(info.get("error"), ensure_ascii=False))
+    if info.get("finish") not in {"stop", "end-turn"}:
+        raise ValueError("OpenCode turn ended without a final response: " + str(info.get("finish")))
+    content = "\n".join(p["text"] for p in last.get("parts", []) if p.get("type") == "text" and not p.get("synthetic"))
+    if not content.strip():
+        raise ValueError("OpenCode turn returned an empty reply")
+    return content
+
+
+def export_session(state, session_id, timeout):
+    """Export a session without routing its potentially large JSON through a pipe."""
+    export_path = state / "session-export.json"
+    with export_path.open("w", encoding="utf-8") as output:
+        completed = subprocess.run(
+            ["opencode", "export", session_id],
+            stdout=output,
+            stderr=subprocess.PIPE,
+            text=True,
+            timeout=timeout,
+        )
+    if completed.returncode:
+        raise RuntimeError("OpenCode session export failed: " + completed.stderr[-1000:])
+    return json.loads(export_path.read_text(encoding="utf-8"))
+
+
+def run_turn(config, state):
+    deadline = time.monotonic() + config["timeout_seconds"]
+
+    def remaining():
+        value = deadline - time.monotonic()
+        if value <= 0:
+            raise TimeoutError("OpenCode turn timed out")
+        return value
+
+    effort = config.get("thinking")
+    options = {} if effort is None else {"reasoningEffort": "none" if effort == "off" else effort}
+    model = config["model"]
+    native_config = {
+        "$schema": "https://opencode.ai/config.json",
+        "model": "roller/" + model,
+        "enabled_providers": ["roller"],
+        "provider": {"roller": {
+            "npm": "@ai-sdk/openai-compatible", "name": "Roller API",
+            "options": {"baseURL": os.environ["OPENAI_BASE_URL"], "apiKey": "{env:OPENAI_API_KEY}", "timeout": max(1, int(remaining() * 1000))},
+            "models": {model: {
+                "id": model, "name": model, "tool_call": True, "reasoning": True,
+                "interleaved": {"field": "reasoning_content"},
+                "limit": {"context": config["context_length"], "output": config["output_tokens"]},
+                "modalities": {
+                    "input": ["text", "image"] if config.get("vision", True) else ["text"],
+                    "output": ["text"],
+                },
+                "options": options,
+            }},
+        }},
+        "plugin": ["file:///roller/opencode_journal.mjs"],
+        "share": "disabled", "autoupdate": False, "snapshot": False,
+        "compaction": {"auto": False, "prune": False},
+        "lsp": False, "formatter": False,
+        "permission": {"*": "deny", **{name: "allow" for name in TOOLS}, "external_directory": "allow",
+                       **({"task": "allow"} if config.get("capture_calls") else {})},
+        "agent": {"build": {"steps": config["max_steps"]}, "title": {"disable": True}, "summary": {"disable": True}},
+    }
+    if config.get("capture_calls"):
+        # Global task permissions otherwise override Explore's native tool
+        # restrictions. Retain a distinct child tool profile when delegating.
+        native_config["agent"]["general"] = {"steps": config["max_steps"]}
+        native_config["agent"]["explore"] = {"steps": config["max_steps"], "permission": {
+            "write": "deny", "edit": "deny", "apply_patch": "deny",
+            "task": "deny", "skill": "deny",
+        }}
+    atomic_json(state / "opencode.json", native_config)
+    session_file = state / "session.json"
+    session = json.loads(session_file.read_text()) if session_file.exists() else {}
+    args = ["opencode", "run", "--format", "json", "--thinking", "--agent", "build", "--model", "roller/" + model, "--title", "Roller task"]
+    if session.get("id"):
+        args += ["--session", session["id"]]
+    stream_path = state / "cli.jsonl"
+    with stream_path.open("w", encoding="utf-8") as output:
+        process = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=output, stderr=None, text=True)
+        try:
+            process.communicate(config["message"], timeout=remaining())
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.wait(timeout=10)
+            raise TimeoutError("OpenCode CLI timed out") from None
+    events = []
+    # JSONL is LF-delimited; str.splitlines() would corrupt records containing
+    # legal U+2028/U+2029 characters in model or tool output.
+    for line in stream_path.read_text(encoding="utf-8").split("\n"):
+        if not line.strip():
+            continue
+        try:
+            row = json.loads(line)
+        except json.JSONDecodeError:
+            continue  # CLI diagnostics are separate from the authoritative journal.
+        if isinstance(row, dict):
+            events.append(row)
+    ids = {e["sessionID"] for e in events if isinstance(e.get("sessionID"), str)}
+    if len(ids) != 1 or (session.get("id") and ids != {session["id"]}):
+        raise ValueError("OpenCode CLI did not return exactly the expected session")
+    session_id = ids.pop()
+    atomic_json(session_file, {"id": session_id})
+    # OpenCode/Bun can truncate large exports when stdout is a pipe (the
+    # failures cluster at pipe-buffer-sized boundaries).  Stream directly to
+    # a regular file so tool-heavy sessions are exported in full.
+    export = export_session(state, session_id, remaining())
+    if export.get("info", {}).get("id") != session_id:
+        raise ValueError("OpenCode exported a different session")
+    with (state / "trace.jsonl").open("a", encoding="utf-8") as journal:
+        journal.write(json.dumps({"type": "session_export", "data": export}, ensure_ascii=False) + "\n")
+    if config.get("capture_calls"):
+        # Preserve child sessions too. Read exact native IDs from task metadata
+        # and session events; never infer ownership from CLI output ordering.
+        ids = set()
+        for line in (state / "trace.jsonl").read_text(encoding="utf-8").split("\n"):
+            if not line.strip():
+                continue
+            row = json.loads(line)
+            event = row.get("event", {})
+            if event.get("type") in {"session.created", "session.updated"}:
+                info = event.get("properties", {}).get("info", {})
+                if info.get("id"):
+                    ids.add(info["id"])
+            if event.get("type") == "message.part.updated":
+                child = event.get("properties", {}).get("part", {}).get("state", {}).get("metadata", {}).get("sessionId")
+                if child:
+                    ids.add(child)
+        for child_id in sorted(ids - {session_id}):
+            try:
+                child_export = export_session(state, child_id, remaining())
+                record = {"type": "session_export", "data": child_export}
+            except Exception as exc:
+                # Evidence failures do not change the completed root turn.
+                record = {"type": "capture_error", "session_id": child_id,
+                          "error": "child session export failed: " + type(exc).__name__}
+            with (state / "trace.jsonl").open("a", encoding="utf-8") as journal:
+                journal.write(json.dumps(record, ensure_ascii=False) + "\n")
+    errors = [e.get("error") for e in events if e.get("type") == "error"]
+    if process.returncode or errors:
+        raise RuntimeError("OpenCode CLI failed: " + json.dumps(errors, ensure_ascii=False)[:2000])
+    return {"ok": True, "content": native_reply(export), "session_id": session_id}
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--check", action="store_true")
+    parser.add_argument("--config")
+    parser.add_argument("--state-dir", default="/roller/opencode-state")
+    args = parser.parse_args()
+    if args.check:
+        version = subprocess.check_output(["opencode", "--version"], text=True, timeout=30).strip()
+        if version != VERSION:
+            raise ValueError(f"OpenCode version mismatch: expected {VERSION}, got {version}")
+        print(version)
+        return
+    state = Path(args.state_dir)
+    state.mkdir(parents=True, exist_ok=True)
+    destination = state / "result.json"
+    destination.unlink(missing_ok=True)
+    try:
+        result = run_turn(json.loads(Path(args.config).read_text()), state)
+    except Exception as exc:
+        result = {"ok": False, "error": str(exc)}
+    atomic_json(destination, result)
+    if not result["ok"]:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

roller/assets/pi/runner.mjs

@@ -0,0 +1,160 @@
+// Container-only bridge to the pinned official Pi AgentSession SDK.
+import fs from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import {
+  createAgentSession, DefaultResourceLoader, ModelRuntime, SessionManager, SettingsManager,
+} from "/opt/roller-pi/node_modules/@earendil-works/pi-coding-agent/dist/index.js";
+import { configureHttpDispatcher } from "/opt/roller-pi/node_modules/@earendil-works/pi-coding-agent/dist/core/http-dispatcher.js";
+
+const VERSION = "0.85.1";
+const STATE = "/roller/pi-state";
+const agentDir = "/roller/pi-home/agent";
+const redact = (value) => {
+  const text = JSON.stringify(value);
+  return process.env.PI_API_KEY ? text.replaceAll(process.env.PI_API_KEY, "[REDACTED]") : text;
+};
+const journal = (value) => fs.appendFileSync(`${STATE}/trace.jsonl`, redact(value) + "\n");
+
+function check() {
+  for (const name of ["pi-coding-agent", "pi-agent-core", "pi-ai"]) {
+    const installed = JSON.parse(fs.readFileSync(`/opt/roller-pi/node_modules/@earendil-works/${name}/package.json`, "utf8")).version;
+    if (installed !== VERSION) throw new Error(`${name} version mismatch: expected ${VERSION}, got ${installed}`);
+  }
+  return VERSION;
+}
+
+async function serve(config) {
+  check();
+  // Use Pi's own HTTP transport, including HTTP(S)_PROXY and NO_PROXY.
+  configureHttpDispatcher(Math.max(1, Math.ceil(config.timeout_seconds * 1000)));
+  journal({type: "metadata", schema: "roller.pi-events/v1", version: VERSION,
+    session_id: config.session_id, model: config.model, api: "openai-completions"});
+  const settingsManager = SettingsManager.inMemory({
+    compaction: {enabled: false}, retry: {enabled: false, provider: {maxRetries: 0}},
+    enableInstallTelemetry: false, enableAnalytics: false, enableSkillCommands: false,
+    packages: [], extensions: [], skills: [], prompts: [], themes: [],
+  });
+  const loader = new DefaultResourceLoader({
+    cwd: process.cwd(), agentDir, settingsManager,
+    noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true,
+    // Keep Pi's native system prompt and add only task-authorized Context.
+    systemPromptOverride: () => undefined,
+    appendSystemPromptOverride: () => [config.system_prompt],
+    agentsFilesOverride: () => ({agentsFiles: (config.context_paths ?? []).filter((target) => fs.existsSync(target)).map((target) => {
+      const file = path.resolve(target);
+      return {path: file, content: fs.readFileSync(file, "utf8")};
+    })}),
+  });
+  await loader.reload();
+  const modelRuntime = await ModelRuntime.create({
+    authPath: `${agentDir}/auth.json`, modelsPath: null,
+    modelsStorePath: `${agentDir}/models-store.json`, allowModelNetwork: false, refreshOnCreate: false,
+  });
+  modelRuntime.registerProvider("roller", {
+    api: "openai-completions", baseUrl: process.env.PI_BASE_URL, apiKey: "$PI_API_KEY",
+    models: [{id: config.model, name: config.model, reasoning: true, input: ["text", "image"],
+      thinkingLevelMap: {off: "none", xhigh: "xhigh", max: "max"},
+      cost: {input: 0, output: 0, cacheRead: 0, cacheWrite: 0},
+      contextWindow: config.context_length, maxTokens: config.output_tokens,
+      compat: {supportsStore: false, supportsDeveloperRole: false, supportsReasoningEffort: true,
+        maxTokensField: "max_tokens"},
+    }],
+  });
+  const model = modelRuntime.getModel("roller", config.model);
+  if (!model) throw new Error("Pi did not register the requested model");
+  const {session} = await createAgentSession({
+    cwd: process.cwd(), agentDir, modelRuntime, model, settingsManager,
+    thinkingLevel: config.thinking ?? "off", tools: config.tools, resourceLoader: loader,
+    sessionManager: SessionManager.inMemory(process.cwd()),
+  });
+  let currentTurn = 0;
+  let steps = 0;
+  let active = false;
+  const nativeStream = session.agent.streamFunction;
+  session.agent.streamFunction = async (model, context, options) => {
+    if (steps >= config.max_steps) throw new Error(`Pi max steps exceeded (${config.max_steps})`);
+    steps += 1;
+    journal({type: "context", turn: currentTurn, context});
+    return nativeStream(model, context, {...options, maxTokens: config.output_tokens, maxRetries: 0,
+      ...(config.capture_calls ? {headers: {...options?.headers, "x-roller-native-session-id": config.session_id}} : {})});
+  };
+  session.agent.onPayload = (body) => {
+    journal({type: "request", turn: currentTurn, body});
+    return body;
+  };
+  session.subscribe((event) => {
+    // Final message events are authoritative. Deltas remain in the raw trace.
+    journal({type: "event", turn: currentTurn, event});
+  });
+  const server = net.createServer((socket) => {
+    socket.setEncoding("utf8");
+    let buffer = "";
+    let received = false;
+    socket.on("error", () => {}); // The host may close the socket at its deadline.
+    socket.on("data", async (chunk) => {
+      buffer += chunk;
+      // Split strictly on LF; prompts may contain Unicode line separators.
+      const end = buffer.indexOf("\n");
+      if (received || end < 0) return;
+      received = true;
+      if (active) {
+        socket.end(redact({ok: false, error: "Pi session already has an active turn"}) + "\n");
+        return;
+      }
+      active = true;
+      let timer;
+      let timedOut = false;
+      try {
+        const payload = JSON.parse(buffer.slice(0, end));
+        if (payload.turn !== currentTurn + 1 || typeof payload.message !== "string") {
+          throw new Error("Invalid Pi turn sequence or message");
+        }
+        currentTurn = payload.turn;
+        steps = 0;
+        const before = session.messages.length;
+        journal({type: "turn_start", turn: currentTurn});
+        timer = setTimeout(() => {
+          timedOut = true;
+          void session.abort();
+        }, Math.max(1, payload.timeout_seconds * 1000));
+        await session.prompt(payload.message, {expandPromptTemplates: false});
+        const messages = session.messages.slice(before);
+        const assistants = messages.filter((message) => message.role === "assistant");
+        const last = assistants.at(-1);
+        const content = last?.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+        const failure = assistants.find((message) => !["stop", "toolUse"].includes(message.stopReason));
+        if (timedOut) throw new Error("Pi turn timed out");
+        if (failure || last?.stopReason !== "stop" || !content?.trim()) {
+          throw new Error(failure?.errorMessage || `Pi turn did not complete: ${failure?.stopReason ?? last?.stopReason ?? "empty response"}`);
+        }
+        journal({type: "turn_end", turn: currentTurn});
+        socket.end(redact({ok: true, content}) + "\n");
+      } catch (error) {
+        journal({type: "runner_error", turn: currentTurn, error: String(error)});
+        socket.end(redact({ok: false, error: String(error), timeout: timedOut}) + "\n");
+        server.close();
+        session.dispose();
+      } finally {
+        clearTimeout(timer);
+        active = false;
+      }
+    });
+  });
+  server.on("error", (error) => {
+    journal({type: "runner_error", error: String(error)});
+    process.exitCode = 1;
+    session.dispose();
+  });
+  server.listen(`${STATE}/runner.sock`, () => fs.chmodSync(`${STATE}/runner.sock`, 0o600));
+}
+
+try {
+  if (process.argv[2] === "--check") console.log(check());
+  else if (process.argv[2] === "--serve") await serve(JSON.parse(fs.readFileSync(process.argv[3], "utf8")));
+  else throw new Error("Expected --check or --serve <config>");
+} catch (error) {
+  if (process.argv[2] !== "--check") journal({type: "runner_error", error: String(error)});
+  console.error(redact({error: String(error)}));
+  process.exitCode = 1;
+}

roller/assets/pi/runner.py

@@ -0,0 +1,93 @@
+"""Container-only bridge to the pinned official Pi Harness SDK.
+
+A private Unix socket keeps one native AgentSession process alive
+across Roller turns. The host owns the hard deadline and container cleanup.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+import socket
+import subprocess
+import sys
+import time
+
+STATE = Path("/roller/pi-state")
+SOCKET = str(STATE / "runner.sock")
+
+
+def check():
+    result = subprocess.run(["node", "/roller/pi_sdk.mjs", "--check"],
+                            capture_output=True, text=True, timeout=30)
+    if result.returncode:
+        raise RuntimeError("Pi SDK check failed: " + (result.stderr or result.stdout).strip()[-2000:])
+    return result.stdout.strip()
+
+
+def redact(value):
+    text = json.dumps(value, ensure_ascii=False)
+    key = os.environ.get("PI_API_KEY")
+    return text.replace(key, "[REDACTED]") if key else text
+
+
+def journal(value):
+    with (STATE / "trace.jsonl").open("a", encoding="utf-8") as stream:
+        stream.write(redact(value) + "\n")
+
+
+def write_result(value):
+    temp = STATE / "result.json.tmp"
+    temp.write_text(redact(value), encoding="utf-8")
+    temp.replace(STATE / "result.json")
+
+
+def send(config):
+    process = None
+    if not Path(SOCKET).exists():
+        with (STATE / "runtime.log").open("a") as log:
+            process = subprocess.Popen(["node", "/roller/pi_sdk.mjs", "--serve", str(STATE / "turn.json")],
+                                       stdin=subprocess.DEVNULL, stdout=log, stderr=log,
+                                       start_new_session=True)
+    deadline = time.monotonic() + config["timeout_seconds"]
+    with socket.socket(socket.AF_UNIX) as client:
+        while True:
+            if process is not None and process.poll() is not None:
+                raise RuntimeError("Pi runtime startup failed; see the native journal and rollout log")
+            try:
+                client.connect(SOCKET)
+                break
+            except (FileNotFoundError, ConnectionRefusedError):
+                if time.monotonic() >= deadline:
+                    raise TimeoutError("Pi runtime startup timed out")
+                time.sleep(0.05)
+        client.settimeout(max(0.001, deadline - time.monotonic()))
+        client.sendall((json.dumps(config) + "\n").encode())
+        with client.makefile("r", encoding="utf-8") as stream:
+            value = json.loads(stream.readline())
+        write_result(value)
+        return 0 if value["ok"] else 1
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--check", action="store_true")
+    parser.add_argument("--config", type=Path)
+    args = parser.parse_args()
+    try:
+        if args.check:
+            print(check())
+            return 0
+        config = json.loads(args.config.read_text())
+        return send(config)
+    except Exception as exc:
+        if not args.check:
+            journal({"type": "runner_error", "error": str(exc)})
+            write_result({"ok": False, "error": str(exc), "timeout": isinstance(exc, TimeoutError)})
+        print(redact({"error": str(exc)}), file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

roller/benches/__init__.py

@@ -0,0 +1,73 @@
+"""Benchmark adapters: turn upstream benches into Roller tasks, then score them.
+
+Adding a bench means writing one :class:`BenchAdapter` and registering it in
+``BENCHES`` below. Nothing else in Roller needs to change: the adapter emits
+ordinary ``roller.task/v1`` rows whose optional ``bench`` block carries the
+task's scorer, and the collect path already ignores row keys it does not know.
+"""
+
+from __future__ import annotations
+
+from roller.benches.base import (
+    BENCH_SCHEMA,
+    BenchAdapter,
+    BenchBinding,
+    BenchFormatError,
+    GradeSpec,
+    binding_from_task_row,
+)
+from roller.benches.pinchbench import PinchBenchAdapter
+from roller.benches.report import (
+    SCORE_FILE,
+    format_report,
+    mean_aggregate,
+    read_scores,
+    sample_score,
+)
+from roller.benches.qwenclaw import QwenClawBenchAdapter
+from roller.benches.skillsbench import SkillsBenchAdapter
+from roller.benches.wildclaw import WildClawBenchAdapter
+
+BENCHES: dict[str, BenchAdapter] = {
+    adapter.name: adapter
+    for adapter in (
+        PinchBenchAdapter(),
+        QwenClawBenchAdapter(),
+        SkillsBenchAdapter(),
+        WildClawBenchAdapter(),
+    )
+}
+
+
+def get_bench(name: str) -> BenchAdapter:
+    try:
+        return BENCHES[name]
+    except KeyError:
+        known = ", ".join(sorted(BENCHES)) or "none registered"
+        raise KeyError(f"unknown bench {name!r}; available: {known}") from None
+
+
+def list_benches() -> list[BenchAdapter]:
+    return [BENCHES[name] for name in sorted(BENCHES)]
+
+
+__all__ = [
+    "BENCHES",
+    "BENCH_SCHEMA",
+    "SCORE_FILE",
+    "BenchAdapter",
+    "BenchBinding",
+    "BenchFormatError",
+    "GradeSpec",
+    "PinchBenchAdapter",
+    "QwenClawBenchAdapter",
+    "SkillsBenchAdapter",
+    "WildClawBenchAdapter",
+    "binding_from_task_row",
+    "format_report",
+    "get_bench",
+    "list_benches",
+    "mean_aggregate",
+    "read_scores",
+    "sample_score",
+]