@tangle-network/agent-runtime 0.197.1 → 0.198.2

package/dist/primeintellect/index.js

@@ -1,739 +0,0 @@
-import { canonicalJson, validateRunRecord } from "@tangle-network/agent-eval";
-import { createHash, randomUUID } from "node:crypto";
-import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
-//#region src/primeintellect/validation.ts
-/** Validate the PrimeIntellect prompt shape shared by package creation and runner input. */
-function validatePrimeIntellectPrompt(value, path) {
-	if (typeof value === "string" && value.length > 0) return value;
-	if (!Array.isArray(value) || value.length === 0) throw new Error(`${path} must be a non-empty string or message array`);
-	for (const [index, message] of value.entries()) validateMessage(message, `${path}[${index}]`);
-	return value;
-}
-function validatePrimeIntellectJson(value, path) {
-	if (value === null || ["string", "boolean"].includes(typeof value)) return;
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) throw new Error(`${path} contains a non-finite number`);
-		return;
-	}
-	if (Array.isArray(value)) {
-		value.forEach((entry, index) => {
-			validatePrimeIntellectJson(entry, `${path}[${index}]`);
-		});
-		return;
-	}
-	if (typeof value === "object") {
-		for (const [key, entry] of Object.entries(value)) validatePrimeIntellectJson(entry, `${path}.${key}`);
-		return;
-	}
-	throw new Error(`${path} is not JSON serializable`);
-}
-function validatePrimeIntellectJsonObject(value, path) {
-	const output = record$1(value, path);
-	validatePrimeIntellectJson(output, path);
-	return output;
-}
-function validateMessage(value, path) {
-	const message = record$1(value, path);
-	const role = message.role;
-	if (![
-		"system",
-		"user",
-		"assistant",
-		"tool"
-	].includes(String(role))) throw new Error(`${path}.role is invalid`);
-	if (role === "system" || role === "user") {
-		assertOnlyKeys(message, ["role", "content"], path);
-		validateContent(message.content, `${path}.content`);
-	} else if (role === "assistant") {
-		assertOnlyKeys(message, [
-			"role",
-			"content",
-			"reasoning_content",
-			"tool_calls",
-			"provider_state"
-		], path);
-		optionalNullableString(message.content, `${path}.content`);
-		optionalNullableString(message.reasoning_content, `${path}.reasoning_content`);
-		if (message.tool_calls !== void 0) validateToolCalls(message.tool_calls, `${path}.tool_calls`);
-		if (message.provider_state !== void 0) validateProviderState(message.provider_state, `${path}.provider_state`);
-	} else {
-		assertOnlyKeys(message, [
-			"role",
-			"tool_call_id",
-			"content",
-			"name"
-		], path);
-		nonEmptyString$2(message.tool_call_id, `${path}.tool_call_id`);
-		if (message.name !== void 0 && typeof message.name !== "string") throw new Error(`${path}.name must be a string`);
-		validateContent(message.content, `${path}.content`);
-	}
-	validatePrimeIntellectJson(message, path);
-}
-function validateToolCalls(value, path) {
-	if (!Array.isArray(value)) throw new Error(`${path} must be an array`);
-	for (const [index, rawCall] of value.entries()) {
-		const call = record$1(rawCall, `${path}[${index}]`);
-		assertOnlyKeys(call, [
-			"id",
-			"name",
-			"arguments"
-		], `${path}[${index}]`);
-		for (const field of [
-			"id",
-			"name",
-			"arguments"
-		]) nonEmptyString$2(call[field], `${path}[${index}].${field}`);
-	}
-}
-function validateProviderState(value, path) {
-	if (!Array.isArray(value)) throw new Error(`${path} must be an array`);
-	for (const [index, rawState] of value.entries()) validatePrimeIntellectJson(record$1(rawState, `${path}[${index}]`), `${path}[${index}]`);
-}
-function validateContent(value, path) {
-	if (typeof value === "string") return;
-	if (!Array.isArray(value) || value.length === 0) throw new Error(`${path} must be a string or non-empty content array`);
-	for (const [index, rawPart] of value.entries()) {
-		const part = record$1(rawPart, `${path}[${index}]`);
-		if (part.type === "text" && typeof part.text === "string") {
-			assertOnlyKeys(part, ["type", "text"], `${path}[${index}]`);
-			continue;
-		}
-		const image = part.image_url;
-		if (part.type === "image_url" && image !== null && typeof image === "object" && !Array.isArray(image) && typeof image.url === "string") {
-			assertOnlyKeys(part, ["type", "image_url"], `${path}[${index}]`);
-			assertOnlyKeys(image, ["url"], `${path}[${index}].image_url`);
-			continue;
-		}
-		throw new Error(`${path}[${index}] is not a supported text or image_url content part`);
-	}
-}
-function optionalNullableString(value, path) {
-	if (value !== void 0 && value !== null && typeof value !== "string") throw new Error(`${path} must be a string or null`);
-}
-function nonEmptyString$2(value, path) {
-	if (typeof value !== "string" || value.length === 0) throw new Error(`${path} must be a non-empty string`);
-	return value;
-}
-function record$1(value, path) {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${path} must be an object`);
-	return value;
-}
-function assertOnlyKeys(value, allowed, path) {
-	for (const key of Object.keys(value)) if (!allowed.includes(key)) throw new Error(`${path}.${key} is not supported`);
-}
-//#endregion
-//#region src/primeintellect/package.ts
-const VERIFIERS_RANGE = ">=0.2.0,<0.3.0";
-const ENV_NAME = /^[A-Z_][A-Z0-9_]*$/;
-const PACKAGE_NAME = /^[a-z][a-z0-9-]{0,62}$/;
-const VERSION = /^\d+\.\d+\.\d+(?:[-+][a-zA-Z0-9.-]+)?$/;
-const DEFAULT_MAX_TURNS = 16;
-const DEFAULT_ROLLOUT_TIMEOUT = 3600;
-const DEFAULT_SCORING_TIMEOUT = 300;
-/** Build a complete PrimeIntellect Verifiers package without writing to disk. */
-function createPrimeIntellectPackage(options) {
-	const validated = validateOptions(options);
-	const moduleName = validated.name.replaceAll("-", "_");
-	const rows = validated.tasks.map((task, idx) => taskRow(task, idx));
-	const runnerFiles = validated.runner.files ?? {};
-	const scoringFiles = validated.scoring.kind === "command" ? validated.scoring.files ?? {} : {};
-	const files = {
-		"pyproject.toml": renderPyproject(validated, moduleName),
-		"prime.eval.toml": renderPrimeConfig(validated, "eval"),
-		"prime.train.toml": renderPrimeConfig(validated, "train"),
-		"README.md": renderReadme(validated),
-		[`${moduleName}/__init__.py`]: renderInit(moduleName),
-		[`${moduleName}/taskset.py`]: renderTaskset(moduleName, validated.scoring),
-		[`${moduleName}/harness.py`]: renderHarness(moduleName),
-		[`${moduleName}/tasks.jsonl`]: `${rows.map((row) => JSON.stringify(row)).join("\n")}\n`,
-		[`${moduleName}/runner.json`]: `${JSON.stringify({
-			command: validated.runner.command,
-			files: runnerFiles,
-			setup: validated.runner.setup ?? [],
-			forwardEnv: validated.runner.forwardEnv ?? []
-		}, null, 2)}\n`
-	};
-	for (const [path, contents] of Object.entries(scoringFiles)) files[`${moduleName}/scoring/${path}`] = contents;
-	const filesSha256 = Object.fromEntries(Object.entries(files).sort(([left], [right]) => left.localeCompare(right)).map(([path, contents]) => [path, sha256(contents)]));
-	const manifest = {
-		kind: "tangle.primeintellect.package",
-		name: validated.name,
-		moduleName,
-		version: validated.version,
-		verifiers: VERIFIERS_RANGE,
-		taskCount: validated.tasks.length,
-		splits: {
-			train: validated.tasks.filter((task) => task.split === "train").length,
-			eval: validated.tasks.filter((task) => task.split === "eval").length
-		},
-		taskIdsSha256: sha256(validated.tasks.map((task) => `${task.split}:${task.id}`).sort().join("\n")),
-		filesSha256
-	};
-	files["manifest.json"] = `${JSON.stringify(manifest, null, 2)}\n`;
-	return {
-		manifest,
-		files: Object.freeze(files)
-	};
-}
-/** Write a bundle through a sibling temporary directory, then rename it into place. */
-async function writePrimeIntellectPackage(bundle, outputDirectory, options = {}) {
-	const output = resolve(outputDirectory);
-	const parent = dirname(output);
-	await mkdir(parent, { recursive: true });
-	const replacing = await pathExists(output);
-	if (replacing) {
-		if (!options.replace) throw new Error(`PrimeIntellect output already exists: ${output}`);
-		await assertGeneratedPackage(output);
-	}
-	const temporary = join(parent, `.${basename(output)}.${randomUUID()}.tmp`);
-	const backup = replacing ? join(parent, `.${basename(output)}.${randomUUID()}.backup`) : void 0;
-	try {
-		await mkdir(temporary);
-		for (const [path, contents] of Object.entries(bundle.files)) {
-			assertRelativePath(path, "bundle file");
-			const target = resolve(temporary, path);
-			if (target !== temporary && !target.startsWith(`${temporary}${sep}`)) throw new Error(`bundle file escapes output directory: ${path}`);
-			await mkdir(dirname(target), { recursive: true });
-			await writeFile(target, contents, "utf8");
-		}
-		if (backup) await rename(output, backup);
-		try {
-			await rename(temporary, output);
-		} catch (error) {
-			if (backup) try {
-				await rename(backup, output);
-			} catch (restoreError) {
-				throw new AggregateError([error, restoreError], `failed to install PrimeIntellect package and restore ${output}`);
-			}
-			throw error;
-		}
-		if (backup) await rm(backup, { recursive: true });
-	} catch (error) {
-		await rm(temporary, {
-			recursive: true,
-			force: true
-		});
-		throw error;
-	}
-	return output;
-}
-function validateOptions(options) {
-	if (!PACKAGE_NAME.test(options.name)) throw new Error("PrimeIntellect package name must match /^[a-z][a-z0-9-]{0,62}$/");
-	if (!VERSION.test(options.version)) throw new Error("PrimeIntellect package version must be a numeric semantic version");
-	if (!Array.isArray(options.tasks) || options.tasks.length === 0) throw new Error("PrimeIntellect package requires tasks");
-	const tasks = options.tasks;
-	const seen = /* @__PURE__ */ new Set();
-	const seenInputs = /* @__PURE__ */ new Map();
-	const splitCounts = {
-		train: 0,
-		eval: 0
-	};
-	for (const [index, task] of tasks.entries()) {
-		validateTask(task, index, options.scoring);
-		if (seen.has(task.id)) throw new Error(`duplicate PrimeIntellect task id: ${task.id}`);
-		seen.add(task.id);
-		const input = canonicalJson({
-			prompt: task.prompt,
-			systemPrompt: task.systemPrompt ?? null,
-			metadata: task.metadata ?? {}
-		});
-		const duplicate = seenInputs.get(input);
-		if (duplicate) throw new Error(`PrimeIntellect tasks ${duplicate.id} (${duplicate.split}) and ${task.id} (${task.split}) expose the same public input`);
-		seenInputs.set(input, {
-			id: task.id,
-			split: task.split
-		});
-		splitCounts[task.split] += 1;
-	}
-	if (splitCounts.train === 0 || splitCounts.eval === 0) throw new Error("PrimeIntellect package requires non-empty, disjoint train and eval splits");
-	validateScoring(options.scoring);
-	validateCommand(options.runner.command, "runner.command");
-	validateFiles(options.runner.files ?? {}, "runner.files");
-	for (const [index, command] of (options.runner.setup ?? []).entries()) validateCommand(command, `runner.setup[${index}]`);
-	validateEnvNames(options.runner.forwardEnv ?? [], "runner.forwardEnv");
-	if (typeof options.runner.image !== "string" || options.runner.image.trim().length === 0) throw new Error("runner.image must be a non-empty container image");
-	if (/(^|:)latest$/i.test(options.runner.image)) throw new Error("runner.image must not use the mutable latest tag");
-	positiveInteger(options.maxTurns ?? DEFAULT_MAX_TURNS, "maxTurns");
-	for (const [name, value] of [
-		["maxInputTokens", options.maxInputTokens],
-		["maxOutputTokens", options.maxOutputTokens],
-		["maxTotalTokens", options.maxTotalTokens]
-	]) if (value !== void 0) positiveInteger(value, name);
-	positiveNumber(options.rolloutTimeoutSeconds ?? DEFAULT_ROLLOUT_TIMEOUT, "rolloutTimeoutSeconds");
-	positiveNumber(options.scoringTimeoutSeconds ?? DEFAULT_SCORING_TIMEOUT, "scoringTimeoutSeconds");
-	return options;
-}
-function validateTask(task, index, scoring) {
-	const path = `tasks[${index}]`;
-	if (typeof task.id !== "string" || task.id.trim().length === 0) throw new Error(`${path}.id must be a non-empty string`);
-	if (task.split !== "train" && task.split !== "eval") throw new Error(`${path}.split must be train or eval`);
-	const prompt = validatePrimeIntellectPrompt(task.prompt, `${path}.prompt`);
-	if (Array.isArray(prompt)) {
-		if (task.systemPrompt !== void 0 && prompt.some((message) => message.role === "system")) throw new Error(`${path} must not set systemPrompt and include a system message`);
-	}
-	if (task.systemPrompt !== void 0 && typeof task.systemPrompt !== "string") throw new Error(`${path}.systemPrompt must be a string`);
-	if (task.metadata !== void 0) validatePrimeIntellectJson(task.metadata, `${path}.metadata`);
-	if (scoring.kind !== "command") {
-		const answers = Array.isArray(task.answer) ? task.answer : [task.answer];
-		if (answers.length === 0 || answers.some((answer) => typeof answer !== "string" || answer.length === 0)) throw new Error(`${path}.answer is required for ${scoring.kind} scoring`);
-	}
-}
-function validateScoring(scoring) {
-	if (scoring.kind === "exact") return;
-	if (scoring.kind === "reference-judge") {
-		if (typeof scoring.model !== "string" || scoring.model.length === 0) throw new Error("reference-judge scoring requires a model");
-		return;
-	}
-	validateCommand(scoring.command, "scoring.command");
-	validateFiles(scoring.files ?? {}, "scoring.files");
-	validateEnvNames(scoring.forwardEnv ?? [], "scoring.forwardEnv");
-	positiveNumber(scoring.timeoutSeconds ?? DEFAULT_SCORING_TIMEOUT, "scoring.timeoutSeconds");
-}
-function validateCommand(command, path) {
-	if (!Array.isArray(command) || command.length === 0) throw new Error(`${path} must be a non-empty argv array`);
-	for (const [index, argument] of command.entries()) if (typeof argument !== "string" || argument.length === 0 || argument.includes("\0")) throw new Error(`${path}[${index}] must be a non-empty string without NUL bytes`);
-}
-function validateFiles(files, path) {
-	for (const [file, contents] of Object.entries(files)) {
-		assertRelativePath(file, path);
-		if (typeof contents !== "string") throw new Error(`${path}.${file} must be a string`);
-	}
-}
-function validateEnvNames(names, path) {
-	const seen = /* @__PURE__ */ new Set();
-	for (const [index, name] of names.entries()) {
-		if (!ENV_NAME.test(name)) throw new Error(`${path}[${index}] is not a valid environment name`);
-		if (seen.has(name)) throw new Error(`${path} contains duplicate name ${name}`);
-		seen.add(name);
-	}
-}
-function assertRelativePath(path, label) {
-	const normalized = normalize(path);
-	if (path.length === 0 || path.includes("\0") || isAbsolute(path) || normalized === ".." || normalized.startsWith(`..${sep}`) || relative(".", normalized).startsWith("..")) throw new Error(`${label} contains unsafe path: ${path}`);
-}
-function taskRow(task, idx) {
-	return {
-		idx,
-		name: task.id,
-		prompt: task.prompt,
-		system_prompt: task.systemPrompt ?? null,
-		split: task.split,
-		answer: task.answer ?? null,
-		metadata: task.metadata ?? {}
-	};
-}
-function renderPyproject(options, moduleName) {
-	const description = options.description ?? `PrimeIntellect tasks for ${options.name}`;
-	return `[project]\nname = ${toml(options.name)}\nversion = ${toml(options.version)}\ndescription = ${toml(description)}\nrequires-python = ">=3.11,<3.14"\ndependencies = ["verifiers${VERIFIERS_RANGE}"]\n\n[build-system]\nrequires = ["hatchling"]\nbuild-backend = "hatchling.build"\n\n[tool.hatch.build.targets.wheel]\npackages = [${toml(moduleName)}]\n\n[tool.uv]\nprerelease = "allow"\n`;
-}
-function renderPrimeConfig(options, split) {
-	return `${[
-		`max_turns = ${options.maxTurns ?? DEFAULT_MAX_TURNS}`,
-		options.maxInputTokens === void 0 ? void 0 : `max_input_tokens = ${options.maxInputTokens}`,
-		options.maxOutputTokens === void 0 ? void 0 : `max_output_tokens = ${options.maxOutputTokens}`,
-		options.maxTotalTokens === void 0 ? void 0 : `max_total_tokens = ${options.maxTotalTokens}`
-	].filter((line) => line !== void 0).join("\n")}\npush = false\n\n[timeout]\nrollout = ${options.rolloutTimeoutSeconds ?? DEFAULT_ROLLOUT_TIMEOUT}\nscoring = ${options.scoringTimeoutSeconds ?? DEFAULT_SCORING_TIMEOUT}\n\n[taskset]\nid = ${toml(options.name)}\nsplit = ${toml(split)}\n\n[harness]\nid = ${toml(options.name)}\nprogram = ${tomlArray(options.runner.command)}\nforward_env = ${tomlArray(options.runner.forwardEnv ?? [])}\n\n[harness.runtime]\ntype = "docker"\nimage = ${toml(options.runner.image)}\n`;
-}
-function renderInit(moduleName) {
-	return `from ${moduleName}.harness import TangleRuntimeHarness\nfrom ${moduleName}.taskset import TangleTaskset\n\n__all__ = ["TangleRuntimeHarness", "TangleTaskset"]\n`;
-}
-function renderTaskset(moduleName, scoring) {
-	const config = scoringConfig(scoring);
-	return `import asyncio\nimport json\nimport math\nimport os\nfrom importlib.resources import files\nfrom pathlib import Path\nfrom typing import Any, Literal\n\nimport verifiers.v1 as vf\n\nSCORING = json.loads(${pythonString(JSON.stringify(config))})\nPACKAGE_ROOT = Path(__file__).resolve().parent\n\n\nclass TangleTaskData(vf.TaskData):\n    split: Literal["train", "eval"]\n    answer: str | list[str] | None = None\n    metadata: dict[str, Any] = {}\n\n\nclass TangleTaskConfig(vf.TaskConfig):\n    scoring: Literal["exact", "reference-judge", "command"] = SCORING["kind"]\n    normalization: Literal["none", "trim", "trim-casefold"] = SCORING.get("normalization", "trim")\n    judge_model: str = SCORING.get("model", "openai/gpt-5.4-nano")\n    judge_prompt: str | None = SCORING.get("prompt")\n    judge_view: Literal["last_reply", "full_trace"] = SCORING.get("view", "last_reply")\n    score_program: list[str] = SCORING.get("command", [])\n    score_forward_env: list[str] = SCORING.get("forwardEnv", [])\n    score_timeout_seconds: float = SCORING.get("timeoutSeconds", 300)\n\n\ndef _normalize(value: str, mode: str) -> str:\n    if mode == "none":\n        return value\n    value = value.strip()\n    return value.casefold() if mode == "trim-casefold" else value\n\n\nasync def _run_score_command(config: TangleTaskConfig, data: TangleTaskData, trace: vf.Trace) -> float:\n    if not config.score_program:\n        raise ValueError("command scoring requires score_program")\n    safe_env = {\n        key: os.environ[key]\n        for key in ("PATH", "HOME", "TMPDIR", "LANG")\n        if key in os.environ\n    }\n    safe_env.update(\n        {key: os.environ[key] for key in config.score_forward_env if key in os.environ}\n    )\n    request = {\n        "kind": "tangle.primeintellect.score",\n        "task": data.model_dump(mode="json", exclude_none=True),\n        "trace": trace.model_dump(mode="json", exclude_none=True),\n    }\n    process = await asyncio.create_subprocess_exec(\n        *config.score_program,\n        cwd=PACKAGE_ROOT,\n        env=safe_env,\n        stdin=asyncio.subprocess.PIPE,\n        stdout=asyncio.subprocess.PIPE,\n        stderr=asyncio.subprocess.PIPE,\n    )\n    payload = json.dumps(request, separators=(",", ":")).encode()\n    try:\n        stdout, stderr = await asyncio.wait_for(\n            process.communicate(payload), timeout=config.score_timeout_seconds\n        )\n    except TimeoutError:\n        process.kill()\n        await process.communicate()\n        raise RuntimeError(\n            f"score command timed out after {config.score_timeout_seconds}s"\n        )\n    if process.returncode != 0:\n        detail = (stderr or stdout).decode(errors="replace").strip()[-2000:]\n        raise RuntimeError(f"score command exited {process.returncode}: {detail}")\n    try:\n        result = json.loads(stdout)\n    except json.JSONDecodeError as error:\n        raise ValueError(f"score command returned invalid JSON: {error}") from error\n    if not isinstance(result, dict):\n        raise ValueError("score command must return an object")\n    reward = result.get("reward")\n    if isinstance(reward, bool) or not isinstance(reward, (int, float)) or not math.isfinite(reward):\n        raise ValueError("score command reward must be a finite number")\n    metrics = result.get("metrics", {})\n    if not isinstance(metrics, dict):\n        raise ValueError("score command metrics must be an object")\n    for name, value in metrics.items():\n        if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value):\n            raise ValueError(f"score command metric {name!r} must be a finite number")\n    trace.record_metrics(metrics)\n    return float(reward)\n\n\nclass TangleTask(vf.Task[TangleTaskData, vf.State, TangleTaskConfig]):\n    @vf.reward(weight=1.0)\n    async def task_reward(self, trace: vf.Trace) -> float:\n        if self.config.scoring == "command":\n            return await _run_score_command(self.config, self.data, trace)\n        if self.data.answer is None:\n            raise ValueError(f"task {self.data.name!r} has no reference answer")\n        if self.config.scoring == "reference-judge":\n            judge = vf.ReferenceJudge(\n                vf.ReferenceJudgeConfig(\n                    model=self.config.judge_model,\n                    prompt=self.config.judge_prompt,\n                    view=self.config.judge_view,\n                )\n            )\n            return await judge.score(self.data, trace)\n        expected = self.data.answer if isinstance(self.data.answer, list) else [self.data.answer]\n        actual = _normalize(trace.last_reply, self.config.normalization)\n        return float(any(actual == _normalize(answer, self.config.normalization) for answer in expected))\n\n\nclass TangleTasksetConfig(vf.TasksetConfig):\n    split: Literal["train", "eval"] = "eval"\n    task: TangleTaskConfig = TangleTaskConfig()\n\n\nclass TangleTaskset(vf.Taskset[TangleTask, TangleTasksetConfig]):\n    def load(self) -> list[TangleTask]:\n        resource = files(${pythonString(moduleName)}).joinpath("tasks.jsonl")\n        tasks: list[TangleTask] = []\n        with resource.open("r", encoding="utf-8") as handle:\n            for line in handle:\n                if not line.strip():\n                    continue\n                row = json.loads(line)\n                if row["split"] != self.config.split:\n                    continue\n                tasks.append(TangleTask(TangleTaskData.model_validate(row), self.config.task))\n        if not tasks:\n            raise ValueError(f"task split {self.config.split!r} is empty")\n        return tasks\n\n\n__all__ = ["TangleTaskset"]\n`;
-}
-function renderHarness(moduleName) {
-	return `import json\nfrom importlib.resources import files\n\nimport verifiers.v1 as vf\n\nRUNNER = json.loads(files(${pythonString(moduleName)}).joinpath("runner.json").read_text(encoding="utf-8"))\n\n\nclass TangleRuntimeHarnessConfig(vf.HarnessConfig):\n    program: list[str] = RUNNER["command"]\n    setup_commands: list[list[str]] = RUNNER["setup"]\n    forward_env: list[str] = RUNNER["forwardEnv"]\n\n\nclass TangleRuntimeHarness(vf.Harness[TangleRuntimeHarnessConfig]):\n    APPENDS_SYSTEM_PROMPT = True\n    SUPPORTS_MCP = True\n    SUPPORTS_MESSAGE_PROMPT = True\n\n    async def setup(self, runtime: vf.Runtime) -> None:\n        for path, contents in RUNNER["files"].items():\n            await runtime.write(path, contents.encode())\n        for command in self.config.setup_commands:\n            result = await runtime.run(command, self.config.resolved_env)\n            if result.exit_code != 0:\n                detail = (result.stderr or result.stdout).strip()[-2000:]\n                raise RuntimeError(\n                    f"runner setup command {command[0]!r} exited {result.exit_code}: {detail}"\n                )\n\n    async def launch(\n        self,\n        ctx: vf.ModelContext,\n        trace: vf.Trace,\n        runtime: vf.Runtime,\n        endpoint: str,\n        secret: str,\n        mcp_urls: dict[str, str],\n    ) -> vf.ProgramResult:\n        data = trace.task.data\n        public_task = {\n            "id": data.name or str(data.idx),\n            "split": data.split,\n            "prompt": data.prompt,\n            "metadata": data.metadata,\n        }\n        if data.system_prompt is not None:\n            public_task["systemPrompt"] = data.system_prompt\n        env = {\n            **self.config.resolved_env,\n            "OPENAI_BASE_URL": endpoint,\n            "OPENAI_API_KEY": secret,\n            "OPENAI_MODEL": ctx.model,\n            "TANGLE_PRIME_TASK_JSON": json.dumps(public_task, separators=(",", ":")),\n            "TANGLE_PRIME_MCP_SERVERS_JSON": json.dumps(mcp_urls, separators=(",", ":")),\n        }\n        if not self.config.program:\n            raise ValueError("Tangle runtime harness requires a program argv")\n        return await runtime.run_program(self.config.program, env)\n\n\n__all__ = ["TangleRuntimeHarness"]\n`;
-}
-function scoringConfig(scoring) {
-	if (scoring.kind === "exact") return {
-		kind: scoring.kind,
-		normalization: scoring.normalization ?? "trim"
-	};
-	if (scoring.kind === "reference-judge") return {
-		kind: scoring.kind,
-		model: scoring.model,
-		prompt: scoring.prompt ?? null,
-		view: scoring.view ?? "last_reply"
-	};
-	return {
-		kind: scoring.kind,
-		command: [...scoring.command],
-		forwardEnv: [...scoring.forwardEnv ?? []],
-		timeoutSeconds: scoring.timeoutSeconds ?? DEFAULT_SCORING_TIMEOUT
-	};
-}
-function renderReadme(options) {
-	return `# ${options.name}\n\nPrimeIntellect Verifiers tasks that run the caller's Tangle agent program.\n\n## Evaluate\n\n\`\`\`bash\nuv run eval @ prime.eval.toml --model <provider/model-snapshot>\n\`\`\`\n\n## Train\n\nUse \`prime.train.toml\` as the environment config for Prime RL. The train and eval rows are disjoint and selected by \`taskset.split\`.\n\nThe runner receives only the prompt, metadata, intercepted model endpoint, and MCP URLs. Reference answers remain in the task process and are never written into the runner workspace or environment.\n`;
-}
-function toml(value) {
-	return JSON.stringify(value);
-}
-function tomlArray(values) {
-	return `[${values.map(toml).join(", ")}]`;
-}
-function pythonString(value) {
-	return JSON.stringify(value);
-}
-function positiveInteger(value, path) {
-	if (!Number.isSafeInteger(value) || value <= 0) throw new Error(`${path} must be a positive integer`);
-}
-function positiveNumber(value, path) {
-	if (!Number.isFinite(value) || value <= 0) throw new Error(`${path} must be positive`);
-}
-async function pathExists(path) {
-	try {
-		await stat(path);
-		return true;
-	} catch (error) {
-		if (error.code === "ENOENT") return false;
-		throw error;
-	}
-}
-async function assertGeneratedPackage(output) {
-	let manifest;
-	try {
-		manifest = JSON.parse(await readFile(join(output, "manifest.json"), "utf8"));
-	} catch (error) {
-		throw new Error(`refusing to replace ${output}: it is not a generated PrimeIntellect package (${error instanceof Error ? error.message : String(error)})`);
-	}
-	if (manifest === null || typeof manifest !== "object" || manifest.kind !== "tangle.primeintellect.package") throw new Error(`refusing to replace ${output}: manifest kind does not match`);
-}
-function sha256(value) {
-	return createHash("sha256").update(value, "utf8").digest("hex");
-}
-//#endregion
-//#region src/primeintellect/runner.ts
-const ENV = {
-	task: "TANGLE_PRIME_TASK_JSON",
-	model: "OPENAI_MODEL",
-	baseUrl: "OPENAI_BASE_URL",
-	apiKey: "OPENAI_API_KEY",
-	mcpServers: "TANGLE_PRIME_MCP_SERVERS_JSON"
-};
-/** Read and validate the private process contract installed by the generated Prime harness. */
-function readPrimeIntellectEpisodeContext(env = process.env) {
-	const rawTask = requiredEnv(env, ENV.task);
-	const rawMcp = env[ENV.mcpServers] ?? "{}";
-	const parsedTask = parseJson(rawTask, ENV.task);
-	const parsedMcp = parseJson(rawMcp, ENV.mcpServers);
-	const task = validatePublicTask(parsedTask);
-	const mcpServers = validateStringMap(parsedMcp, ENV.mcpServers);
-	return {
-		task,
-		model: {
-			name: requiredEnv(env, ENV.model),
-			baseUrl: requiredEnv(env, ENV.baseUrl),
-			apiKey: requiredEnv(env, ENV.apiKey)
-		},
-		mcpServers
-	};
-}
-/** Resolve Prime's intercepted endpoint as transport-only Runtime executor configuration.
-* The caller's exact `AgentProfile` remains the sole owner of model and behavior. */
-function primeIntellectExecutorConfig(context) {
-	return Object.freeze({
-		backend: "router",
-		routerBaseUrl: context.model.baseUrl,
-		routerKey: context.model.apiKey
-	});
-}
-/**
-* Execute the caller's canonical runtime program inside a Prime rollout.
-* The callback may call runPersonified, runAgentic, runAgentRounds, or any product wrapper.
-*/
-async function runPrimeIntellectProgram(run, options = {}) {
-	return run(readPrimeIntellectEpisodeContext(options.env));
-}
-function requiredEnv(env, name) {
-	const value = env[name];
-	if (typeof value !== "string" || value.length === 0) throw new Error(`PrimeIntellect runner requires ${name}`);
-	return value;
-}
-function parseJson(value, name) {
-	try {
-		return JSON.parse(value);
-	} catch (error) {
-		throw new Error(`${name} must contain valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-	}
-}
-function validatePublicTask(value) {
-	const task = record(value, ENV.task);
-	for (const privateField of [
-		"answer",
-		"reference",
-		"scoring",
-		"score"
-	]) if (privateField in task) throw new Error(`${ENV.task} exposed private field ${privateField}`);
-	for (const field of Object.keys(task)) if (![
-		"id",
-		"split",
-		"prompt",
-		"systemPrompt",
-		"metadata"
-	].includes(field)) throw new Error(`${ENV.task}.${field} is not supported`);
-	const id = nonEmptyString$1(task.id, `${ENV.task}.id`);
-	const split = validateSplit(task.split, `${ENV.task}.split`);
-	const prompt = validatePrimeIntellectPrompt(task.prompt, `${ENV.task}.prompt`);
-	const systemPrompt = optionalString(task.systemPrompt, `${ENV.task}.systemPrompt`);
-	if (systemPrompt !== void 0 && Array.isArray(prompt) && prompt.some((message) => message.role === "system")) throw new Error(`${ENV.task} must not set systemPrompt and include a system message`);
-	const metadata = task.metadata === void 0 ? void 0 : validatePrimeIntellectJsonObject(task.metadata, `${ENV.task}.metadata`);
-	return {
-		id,
-		split,
-		prompt,
-		...systemPrompt !== void 0 ? { systemPrompt } : {},
-		...metadata !== void 0 ? { metadata } : {}
-	};
-}
-function validateSplit(value, path) {
-	if (value !== "train" && value !== "eval") throw new Error(`${path} must be train or eval`);
-	return value;
-}
-function validateStringMap(value, path) {
-	const input = record(value, path);
-	const output = {};
-	for (const [key, entry] of Object.entries(input)) {
-		if (typeof entry !== "string" || entry.length === 0) throw new Error(`${path}.${key} must be a non-empty string`);
-		output[key] = entry;
-	}
-	return output;
-}
-function record(value, path) {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${path} must be an object`);
-	return value;
-}
-function nonEmptyString$1(value, path) {
-	if (typeof value !== "string" || value.length === 0) throw new Error(`${path} must be a non-empty string`);
-	return value;
-}
-function optionalString(value, path) {
-	if (value === void 0) return void 0;
-	if (typeof value !== "string") throw new Error(`${path} must be a string`);
-	return value;
-}
-//#endregion
-//#region src/primeintellect/traces.ts
-/** Parse Prime's durable `traces.jsonl` and reject malformed rows with a line number. */
-function parsePrimeIntellectTraces(jsonl) {
-	const traces = [];
-	for (const [lineIndex, line] of jsonl.split("\n").entries()) {
-		if (!line.trim()) continue;
-		let parsed;
-		try {
-			parsed = JSON.parse(line);
-		} catch (error) {
-			throw new Error(`PrimeIntellect trace line ${lineIndex + 1} is invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
-		}
-		traces.push(validateTrace(parsed, lineIndex + 1));
-	}
-	if (traces.length === 0) throw new Error("PrimeIntellect traces.jsonl contains no traces");
-	return traces;
-}
-/** Convert all Prime traces to agent-eval RunRecords while retaining one shared run config. */
-function importPrimeIntellectTraces(jsonl, defaults) {
-	return parsePrimeIntellectTraces(jsonl).map((trace) => primeIntellectTraceToRunRecord(trace, defaults));
-}
-/** Project one complete Prime trace into the common agent-eval analysis row. */
-function primeIntellectTraceToRunRecord(trace, options) {
-	const split = trace.task.data.split;
-	if (split !== "train" && split !== "eval") throw new Error(`PrimeIntellect trace ${trace.id} has no train/eval split`);
-	const reward = sumFinite(Object.values(trace.rewards), `trace ${trace.id} rewards`);
-	const usage = aggregateUsage([...trace.nodes.map((node) => node.usage).filter((value) => value != null), ...trace.extra_usage ?? []]);
-	const errors = trace.errors ?? [];
-	const raw = {
-		reward,
-		"prime.turns": trace.nodes.filter((node) => node.sampled === true).length,
-		"prime.branches": countBranches(trace.nodes),
-		"prime.errors": errors.length,
-		execution_error_count: errors.length,
-		"prime.completed": trace.is_completed ? 1 : 0,
-		"prime.cost_complete": usage.costComplete ? 1 : 0,
-		"prime.reported_cost_usd": usage.reportedCostUsd
-	};
-	for (const [name, value] of Object.entries(trace.rewards)) raw[`reward.${name}`] = finite(value, `trace ${trace.id} reward ${name}`);
-	for (const [name, value] of Object.entries(trace.metrics)) raw[`metric.${name}`] = finite(value, `trace ${trace.id} metric ${name}`);
-	return validateRunRecord({
-		runId: trace.id,
-		experimentId: options.experimentId,
-		candidateId: options.candidateId,
-		seed: options.seed,
-		model: options.model,
-		promptHash: options.promptHash,
-		configHash: options.configHash,
-		commitSha: options.commitSha,
-		wallMs: traceWallMs(trace),
-		costUsd: usage.costComplete ? usage.reportedCostUsd : null,
-		costProvenance: usage.costComplete ? {
-			kind: "observed",
-			usd: usage.reportedCostUsd
-		} : {
-			kind: "uncaptured",
-			usd: null
-		},
-		terminalOutcome: errors.length > 0 ? "failed" : trace.is_completed ? "succeeded" : "incomplete",
-		...errors[0] ? { terminalFailureReason: `${errors[0].type}:${errors[0].message}` } : {},
-		tokenUsage: {
-			input: usage.input,
-			output: usage.output,
-			...usage.reasoning !== void 0 ? { reasoning: usage.reasoning } : {},
-			...usage.cached !== void 0 ? { cached: usage.cached } : {}
-		},
-		outcome: split === "eval" ? {
-			holdoutScore: reward,
-			raw
-		} : {
-			searchScore: reward,
-			raw
-		},
-		splitTag: split === "eval" ? "holdout" : "search",
-		scenarioId: trace.task.data.name ?? String(trace.task.data.idx)
-	});
-}
-function validateTrace(value, line) {
-	const trace = object(value, `PrimeIntellect trace line ${line}`);
-	nonEmptyString(trace.id, `PrimeIntellect trace line ${line}.id`);
-	const task = object(trace.task, `PrimeIntellect trace line ${line}.task`);
-	nonEmptyString(task.type, `PrimeIntellect trace line ${line}.task.type`);
-	const data = object(task.data, `PrimeIntellect trace line ${line}.task.data`);
-	if (!Number.isSafeInteger(data.idx) || data.idx < 0) throw new Error(`PrimeIntellect trace line ${line}.task.data.idx must be a non-negative integer`);
-	if (!Array.isArray(trace.nodes)) throw new Error(`PrimeIntellect trace line ${line}.nodes must be an array`);
-	for (const [index, rawNode] of trace.nodes.entries()) {
-		const node = object(rawNode, `PrimeIntellect trace line ${line}.nodes[${index}]`);
-		const parent = node.parent;
-		if (parent !== void 0 && parent !== null && (!Number.isSafeInteger(parent) || parent < 0 || parent >= index)) throw new Error(`PrimeIntellect trace line ${line}.nodes[${index}].parent must reference an earlier node`);
-		if (node.sampled !== void 0 && typeof node.sampled !== "boolean") throw new Error(`PrimeIntellect trace line ${line}.nodes[${index}].sampled must be boolean`);
-		if (node.usage !== void 0 && node.usage !== null) validateUsage(node.usage, `PrimeIntellect trace line ${line}.nodes[${index}].usage`);
-	}
-	validateNumberMap(trace.rewards, `PrimeIntellect trace line ${line}.rewards`);
-	validateNumberMap(trace.metrics, `PrimeIntellect trace line ${line}.metrics`);
-	if (trace.extra_usage !== void 0 && !Array.isArray(trace.extra_usage)) throw new Error(`PrimeIntellect trace line ${line}.extra_usage must be an array`);
-	for (const [index, usage] of (trace.extra_usage ?? []).entries()) validateUsage(usage, `PrimeIntellect trace line ${line}.extra_usage[${index}]`);
-	if (trace.errors !== void 0 && !Array.isArray(trace.errors)) throw new Error(`PrimeIntellect trace line ${line}.errors must be an array`);
-	for (const [index, rawError] of (trace.errors ?? []).entries()) {
-		const error = object(rawError, `PrimeIntellect trace line ${line}.errors[${index}]`);
-		nonEmptyString(error.type, `PrimeIntellect trace line ${line}.errors[${index}].type`);
-		nonEmptyString(error.message, `PrimeIntellect trace line ${line}.errors[${index}].message`);
-		if (error.traceback !== void 0 && error.traceback !== null && typeof error.traceback !== "string") throw new Error(`PrimeIntellect trace line ${line}.errors[${index}].traceback must be a string or null`);
-	}
-	if (trace.is_completed !== void 0 && typeof trace.is_completed !== "boolean") throw new Error(`PrimeIntellect trace line ${line}.is_completed must be boolean`);
-	if (trace.stop_condition !== void 0 && trace.stop_condition !== null && typeof trace.stop_condition !== "string") throw new Error(`PrimeIntellect trace line ${line}.stop_condition must be a string or null`);
-	if (trace.timing !== void 0) validateTiming(trace.timing, line);
-	return value;
-}
-function validateTiming(value, line) {
-	const timing = object(value, `PrimeIntellect trace line ${line}.timing`);
-	optionalFinite(timing.start, `PrimeIntellect trace line ${line}.timing.start`);
-	for (const phase of [
-		"setup",
-		"generation",
-		"finalize",
-		"scoring"
-	]) {
-		if (timing[phase] === void 0) continue;
-		const span = object(timing[phase], `PrimeIntellect trace line ${line}.timing.${phase}`);
-		optionalFinite(span.start, `PrimeIntellect trace line ${line}.timing.${phase}.start`);
-		optionalFinite(span.end, `PrimeIntellect trace line ${line}.timing.${phase}.end`);
-	}
-}
-function aggregateUsage(usages) {
-	let input = 0;
-	let output = 0;
-	let reasoning = 0;
-	let cached = 0;
-	let costUsd = 0;
-	let sawReasoning = false;
-	let sawCached = false;
-	let costsReported = 0;
-	for (const [index, usage] of usages.entries()) {
-		const prompt = nonNegative(usage.prompt_tokens, `usage[${index}].prompt_tokens`);
-		const completion = nonNegative(usage.completion_tokens, `usage[${index}].completion_tokens`);
-		const cachedInput = optionalNonNegative(usage.cached_input_tokens, `usage[${index}].cached_input_tokens`);
-		const reasoningTokens = optionalNonNegative(usage.reasoning_tokens, `usage[${index}].reasoning_tokens`);
-		const cost = optionalNonNegative(usage.cost, `usage[${index}].cost`);
-		input += prompt + (cachedInput ?? 0);
-		output += completion;
-		if (cachedInput !== void 0) {
-			cached += cachedInput;
-			sawCached = true;
-		}
-		if (reasoningTokens !== void 0) {
-			reasoning += reasoningTokens;
-			sawReasoning = true;
-		}
-		if (cost !== void 0) {
-			costUsd += cost;
-			costsReported += 1;
-		}
-	}
-	if (reasoning > output) throw new Error(`PrimeIntellect reasoning token total ${reasoning} exceeds output total ${output}`);
-	return {
-		input,
-		output,
-		...sawReasoning ? { reasoning } : {},
-		...sawCached ? { cached } : {},
-		reportedCostUsd: costUsd,
-		costComplete: usages.length > 0 && costsReported === usages.length
-	};
-}
-function validateUsage(value, path) {
-	const usage = object(value, path);
-	nonNegative(usage.prompt_tokens, `${path}.prompt_tokens`);
-	nonNegative(usage.completion_tokens, `${path}.completion_tokens`);
-	optionalNonNegative(usage.cached_input_tokens, `${path}.cached_input_tokens`);
-	optionalNonNegative(usage.reasoning_tokens, `${path}.reasoning_tokens`);
-	optionalNonNegative(usage.cost, `${path}.cost`);
-}
-function traceWallMs(trace) {
-	const timing = trace.timing;
-	if (!timing || typeof timing.start !== "number" || !Number.isFinite(timing.start)) return 0;
-	const ends = [
-		timing.setup?.end,
-		timing.generation?.end,
-		timing.finalize?.end,
-		timing.scoring?.end
-	].filter((value) => typeof value === "number" && Number.isFinite(value));
-	if (ends.length === 0) return 0;
-	return Math.max(0, (Math.max(...ends) - timing.start) * 1e3);
-}
-function countBranches(nodes) {
-	if (nodes.length === 0) return 0;
-	const parents = new Set(nodes.map((node) => node.parent).filter((parent) => Number.isSafeInteger(parent) && parent >= 0));
-	return nodes.reduce((count, _node, index) => count + (parents.has(index) ? 0 : 1), 0);
-}
-function validateNumberMap(value, path) {
-	const map = object(value, path);
-	for (const [key, entry] of Object.entries(map)) finite(entry, `${path}.${key}`);
-}
-function sumFinite(values, path) {
-	return values.reduce((sum, value, index) => sum + finite(value, `${path}[${index}]`), 0);
-}
-function finite(value, path) {
-	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${path} must be a finite number`);
-	return value;
-}
-function nonNegative(value, path) {
-	const parsed = finite(value, path);
-	if (parsed < 0) throw new Error(`${path} must be non-negative`);
-	return parsed;
-}
-function optionalNonNegative(value, path) {
-	if (value === void 0 || value === null) return void 0;
-	return nonNegative(value, path);
-}
-function optionalFinite(value, path) {
-	if (value === void 0 || value === null) return void 0;
-	return finite(value, path);
-}
-function object(value, path) {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${path} must be an object`);
-	return value;
-}
-function nonEmptyString(value, path) {
-	if (typeof value !== "string" || value.length === 0) throw new Error(`${path} must be a non-empty string`);
-	return value;
-}
-//#endregion
-export { createPrimeIntellectPackage, importPrimeIntellectTraces, parsePrimeIntellectTraces, primeIntellectExecutorConfig, primeIntellectTraceToRunRecord, readPrimeIntellectEpisodeContext, runPrimeIntellectProgram, writePrimeIntellectPackage };
-
-//# sourceMappingURL=index.js.map