@cairnkeep/cli 2.3.1 → 2.4.0

package/mcp-memory-server/dist/eval-plan.js

@@ -0,0 +1,346 @@
+import { spawnSync } from "node:child_process";
+import { constants } from "node:fs";
+import { accessSync, closeSync, existsSync, fstatSync, lstatSync, openSync, readFileSync, realpathSync, } from "node:fs";
+import { delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CAPABILITY_IDS } from "./capability-schema.js";
+import { EVAL_SCHEMA_VERSION, canonicalDigest, canonicalJson, evalAdapterConfigSchema, evalTaskSetSchema, } from "./eval-schema.js";
+const MAX_INPUT_BYTES = 4 * 1024 * 1024;
+const MAX_GIT_OUTPUT_BYTES = 8 * 1024 * 1024;
+const MAX_REPETITIONS = 1_000;
+const truthyPattern = /^(?:1|true|yes|on)$/i;
+const moduleDirectory = dirname(fileURLToPath(import.meta.url));
+const projectPackagePath = resolve(moduleDirectory, "..", "..", "package.json");
+const bundledTaskSetPath = resolve(dirname(projectPackagePath), "examples", "eval", "task-set.json");
+function isContained(root, candidate) {
+    const rel = relative(root, candidate);
+    return rel === "" || (!rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel));
+}
+function assertRealDirectory(path, label) {
+    const info = lstatSync(path);
+    if (info.isSymbolicLink() || !info.isDirectory())
+        throw new Error(`${label} must be a real directory.`);
+    return realpathSync(path);
+}
+function readBoundedJson(path, label) {
+    const absolute = resolve(path);
+    const pathInfo = lstatSync(absolute);
+    if (pathInfo.isSymbolicLink() || !pathInfo.isFile())
+        throw new Error(`${label} must be a regular non-symlink file.`);
+    const flags = constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0);
+    const descriptor = openSync(absolute, flags);
+    try {
+        const info = fstatSync(descriptor);
+        if (!info.isFile() || info.size > MAX_INPUT_BYTES)
+            throw new Error(`${label} exceeds the ${MAX_INPUT_BYTES}-byte limit.`);
+        const bytes = readFileSync(descriptor);
+        if (bytes.byteLength > MAX_INPUT_BYTES)
+            throw new Error(`${label} exceeds the ${MAX_INPUT_BYTES}-byte limit.`);
+        let value;
+        try {
+            value = JSON.parse(bytes.toString("utf8"));
+        }
+        catch {
+            throw new Error(`${label} is not valid JSON.`);
+        }
+        return { path: realpathSync(absolute), value, bytes };
+    }
+    finally {
+        closeSync(descriptor);
+    }
+}
+function git(repository, args, label) {
+    const result = spawnSync("git", ["-C", repository, ...args], {
+        encoding: "utf8",
+        timeout: 10_000,
+        maxBuffer: MAX_GIT_OUTPUT_BYTES,
+        shell: false,
+        windowsHide: true,
+    });
+    if (result.error || result.status !== 0)
+        throw new Error(`${label} failed.`);
+    return (result.stdout ?? "").trim();
+}
+function resolveExactCommit(repository, revision) {
+    const resolved = git(repository, ["rev-parse", "--verify", `${revision}^{commit}`], "Resolve evaluation source commit");
+    if (resolved !== revision)
+        throw new Error("Evaluation source revision must resolve exactly to the supplied full commit ID.");
+    return resolved;
+}
+function parseCommittedTaskSet(taskSetPath) {
+    const manifestRepository = assertRealDirectory(git(dirname(taskSetPath), ["rev-parse", "--show-toplevel"], "Resolve task-set repository"), "Task-set repository");
+    if (!isContained(manifestRepository, taskSetPath))
+        throw new Error("The task-set manifest must be contained by its Git repository.");
+    const manifestPath = relative(manifestRepository, taskSetPath).split(sep).join("/");
+    if (!manifestPath || manifestPath.startsWith("../"))
+        throw new Error("The task-set manifest path is invalid.");
+    git(manifestRepository, ["ls-files", "--error-unmatch", "--", manifestPath], "Require a tracked evaluation task set");
+    const dirty = git(manifestRepository, ["status", "--porcelain", "--untracked-files=all", "--", manifestPath], "Check evaluation task set status");
+    if (dirty !== "")
+        throw new Error("Evaluation task set must be committed and unchanged.");
+    const commit = git(manifestRepository, ["rev-parse", "--verify", "HEAD^{commit}"], "Resolve task-set commit");
+    const committed = git(manifestRepository, ["show", `${commit}:${manifestPath}`], "Read committed evaluation task set");
+    let value;
+    try {
+        value = JSON.parse(committed);
+    }
+    catch {
+        throw new Error("The committed evaluation task set is not valid JSON.");
+    }
+    return { taskSet: evalTaskSetSchema.parse(value), commit };
+}
+function resolveWorkspaceDirectories(taskSet, repository, revision) {
+    for (const task of taskSet.tasks) {
+        const candidate = resolve(repository, task.workspace.path);
+        if (!isContained(repository, candidate))
+            throw new Error(`Task ${task.id} workspace escapes the declared repository.`);
+        const object = task.workspace.path === "." ? `${revision}^{tree}` : `${revision}:${task.workspace.path}`;
+        const kind = git(repository, ["cat-file", "-t", object], `Resolve task ${task.id} workspace`);
+        if (kind !== "tree")
+            throw new Error(`Task ${task.id} workspace is not a committed directory.`);
+    }
+}
+function resolvePathProgram(program, base) {
+    const candidate = isAbsolute(program) ? program : resolve(base, program);
+    const info = lstatSync(candidate);
+    if (!info.isFile() && !info.isSymbolicLink())
+        throw new Error(`Evaluation program is not a file: ${program}`);
+    accessSync(candidate, constants.X_OK);
+    return realpathSync(candidate);
+}
+function resolveProgram(program, base) {
+    if (isAbsolute(program) || program.includes("/") || program.includes("\\"))
+        return resolvePathProgram(program, base);
+    for (const directory of (process.env.PATH ?? "").split(delimiter).filter(Boolean)) {
+        const candidate = join(directory, program);
+        try {
+            accessSync(candidate, constants.X_OK);
+            if (lstatSync(candidate).isFile() || lstatSync(candidate).isSymbolicLink())
+                return realpathSync(candidate);
+        }
+        catch {
+            // Continue through PATH without executing the candidate.
+        }
+    }
+    throw new Error(`Evaluation program was not found on PATH: ${program}`);
+}
+function validateOutputRoot(path) {
+    const absolute = resolve(path);
+    let parent = absolute;
+    while (!existsSync(parent)) {
+        const next = dirname(parent);
+        if (next === parent)
+            throw new Error("Evaluation output has no existing parent directory.");
+        parent = next;
+    }
+    const realParent = assertRealDirectory(parent, "Evaluation output parent");
+    accessSync(realParent, constants.W_OK | constants.X_OK);
+    if (existsSync(absolute)) {
+        const realOutput = assertRealDirectory(absolute, "Evaluation output root");
+        if (!isContained(realParent, realOutput) && realParent !== realOutput) {
+            throw new Error("Evaluation output root resolves outside its writable parent.");
+        }
+    }
+    return absolute;
+}
+function packageVersion() {
+    const value = readBoundedJson(projectPackagePath, "Installed package manifest").value;
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Installed package version is invalid.");
+    }
+    const record = value;
+    if (typeof record.version !== "string" || record.version.length < 1 || record.version.length > 128) {
+        throw new Error("Installed package version is invalid.");
+    }
+    return record.version;
+}
+function validateBundledBinding(taskSetPath, taskSet, taskSetBytes) {
+    if (taskSet.source.kind !== "bundled_fake")
+        throw new Error("Bundled binding requires the dedicated bundled source.");
+    if (!existsSync(bundledTaskSetPath) || realpathSync(taskSetPath) !== realpathSync(bundledTaskSetPath)) {
+        throw new Error("The bundled evaluation source is accepted only from the installed package-owned task set.");
+    }
+    if (!taskSetBytes.equals(Buffer.from(`${canonicalJson(taskSet)}\n`, "utf8"))) {
+        throw new Error("The bundled evaluation task set must use its exact canonical bytes.");
+    }
+    const bindingPath = join(dirname(taskSetPath), "bundled-fake.json");
+    const binding = readBoundedJson(bindingPath, "Bundled evaluation binding").value;
+    if (!binding || typeof binding !== "object" || Array.isArray(binding))
+        throw new Error("Bundled evaluation binding is invalid.");
+    const record = binding;
+    const keys = Object.keys(record).sort();
+    if (canonicalJson(keys) !== canonicalJson(["identifier", "package_version", "schema_version", "task_set_digest"])) {
+        throw new Error("Bundled evaluation binding has unknown or missing fields.");
+    }
+    const installedVersion = packageVersion();
+    if (record.schema_version !== EVAL_SCHEMA_VERSION
+        || record.identifier !== "cairn-offline-fake-v1"
+        || record.package_version !== installedVersion
+        || record.task_set_digest !== canonicalDigest(taskSet)) {
+        throw new Error("Bundled evaluation binding does not match the installed package and committed task set.");
+    }
+    return {
+        kind: "bundled_fake",
+        identifier: "cairn-offline-fake-v1",
+        package_version: installedVersion,
+        binding_path: realpathSync(bindingPath),
+    };
+}
+function validateArms(arms) {
+    if (arms.length < 1 || arms.length > 2)
+        throw new Error("Evaluation requires one or two arms.");
+    const seen = new Set();
+    return arms.map((arm) => {
+        if (arm.id !== "baseline" && arm.id !== "treatment")
+            throw new Error("Evaluation arm is invalid.");
+        if (seen.has(arm.id))
+            throw new Error("Evaluation arm IDs must be unique.");
+        seen.add(arm.id);
+        if (arm.disabled_capability !== null && !CAPABILITY_IDS.includes(arm.disabled_capability)) {
+            throw new Error("Evaluation arm disables an unknown capability.");
+        }
+        if (arm.id === "baseline" && arm.disabled_capability !== null)
+            throw new Error("Baseline cannot disable a capability.");
+        if (arm.id === "treatment" && arm.disabled_capability === null)
+            throw new Error("Treatment must disable exactly one capability.");
+        return { id: arm.id, disabled_capability: arm.disabled_capability };
+    });
+}
+function rowSeed(seed, repetition, taskId) {
+    return canonicalDigest({ seed, repetition, task_id: taskId }).slice(0, 32);
+}
+export function isEvalEnabled(value = process.env.CAIRN_EVAL) {
+    return truthyPattern.test(value?.trim() ?? "");
+}
+export function buildEvalSchedule(options) {
+    const taskSet = evalTaskSetSchema.parse(options.taskSet);
+    const arms = validateArms(options.arms);
+    if (!Number.isSafeInteger(options.repetitions) || options.repetitions < 1 || options.repetitions > MAX_REPETITIONS) {
+        throw new Error(`Evaluation repetitions must be an integer from 1 to ${MAX_REPETITIONS}.`);
+    }
+    if (options.seed.length < 1 || options.seed.length > 256)
+        throw new Error("Evaluation seed is invalid.");
+    if (options.passes.length !== 2 || options.passes[0] !== "run1" || options.passes[1] !== "run2") {
+        throw new Error("Evaluation passes must be exactly run1 followed by run2.");
+    }
+    const rows = [];
+    for (const [armOrder, arm] of arms.entries()) {
+        for (let repetition = 0; repetition < options.repetitions; repetition += 1) {
+            for (const pass of options.passes) {
+                for (const task of taskSet.tasks) {
+                    const observationId = `${arm.id}-r${repetition}-${pass}-${task.id}`;
+                    rows.push({
+                        schedule_index: rows.length,
+                        observation_id: observationId,
+                        task_id: task.id,
+                        arm: arm.id,
+                        disabled_capability: arm.disabled_capability,
+                        arm_order: armOrder,
+                        repetition,
+                        pass,
+                        seed: rowSeed(options.seed, repetition, task.id),
+                        note_snapshot_task_id: pass === "run2" ? task.id : null,
+                    });
+                }
+            }
+        }
+    }
+    const frozenRows = rows.map((row) => Object.freeze({ ...row }));
+    return Object.freeze({
+        concurrency: 1,
+        invocation_count: frozenRows.length,
+        digest: canonicalDigest(frozenRows),
+        rows: Object.freeze(frozenRows),
+    });
+}
+export function validateEvalInputs(options) {
+    const cwd = assertRealDirectory(resolve(options.cwd ?? process.cwd()), "Evaluation working directory");
+    const taskInput = readBoundedJson(resolve(cwd, options.taskSetPath), "Evaluation task set");
+    const adapterInput = readBoundedJson(resolve(cwd, options.adapterPath), "Evaluation adapter configuration");
+    const parsedTaskSet = evalTaskSetSchema.parse(taskInput.value);
+    const adapterConfig = evalAdapterConfigSchema.parse(adapterInput.value);
+    let taskSet = parsedTaskSet;
+    let taskSetCommit;
+    let source;
+    let repositoryRoot;
+    if (parsedTaskSet.source.kind === "git") {
+        const committed = parseCommittedTaskSet(taskInput.path);
+        if (canonicalJson(committed.taskSet) !== canonicalJson(parsedTaskSet)) {
+            throw new Error("Evaluation task set differs from its committed document.");
+        }
+        taskSet = committed.taskSet;
+        taskSetCommit = committed.commit;
+        const repositoryCandidate = resolve(dirname(taskInput.path), parsedTaskSet.source.repository);
+        repositoryRoot = assertRealDirectory(repositoryCandidate, "Evaluation source repository");
+        const revision = resolveExactCommit(repositoryRoot, parsedTaskSet.source.revision);
+        resolveWorkspaceDirectories(taskSet, repositoryRoot, revision);
+        source = { kind: "git", repository_root: repositoryRoot, revision };
+    }
+    else {
+        source = validateBundledBinding(taskInput.path, taskSet, taskInput.bytes);
+        taskSetCommit = null;
+    }
+    const repetitions = options.repetitions ?? 1;
+    const seed = options.seed ?? "cairn-eval-v1";
+    const arms = validateArms(options.arms ?? [{ id: "baseline", disabled_capability: null }]);
+    const passes = ["run1", "run2"];
+    const schedule = buildEvalSchedule({ taskSet, arms, repetitions, passes, seed });
+    const adapterBase = dirname(adapterInput.path);
+    const workspaceBase = repositoryRoot ?? dirname(taskInput.path);
+    const outputRoot = validateOutputRoot(resolve(cwd, options.outputRoot));
+    const taskSetDigest = canonicalDigest(taskSet);
+    const adapterConfigDigest = canonicalDigest(adapterConfig);
+    const resolvedPrograms = {
+        adapter: resolveProgram(adapterConfig.command.program, adapterBase),
+        prepare: taskSet.tasks.map((task) => resolveProgram(task.prepare.program, workspaceBase)),
+        verify: taskSet.tasks.map((task) => resolveProgram(task.verify.program, workspaceBase)),
+    };
+    const identity = {
+        schema_version: EVAL_SCHEMA_VERSION,
+        task_set_digest: taskSetDigest,
+        adapter_config_digest: adapterConfigDigest,
+        source,
+        output_root: outputRoot,
+        repetitions,
+        seed,
+        arms,
+        passes,
+        concurrency: 1,
+        task_set_commit: taskSetCommit,
+        schedule_digest: schedule.digest,
+    };
+    const plan = {
+        schema_version: EVAL_SCHEMA_VERSION,
+        task_set: taskSet,
+        adapter_config: adapterConfig,
+        task_set_path: taskInput.path,
+        adapter_path: adapterInput.path,
+        output_root: outputRoot,
+        source,
+        repetitions,
+        seed,
+        arms,
+        passes: ["run1", "run2"],
+        concurrency: 1,
+        invocation_count: schedule.invocation_count,
+        task_set_commit: taskSetCommit,
+        task_set_digest: taskSetDigest,
+        adapter_config_digest: adapterConfigDigest,
+        schedule_digest: schedule.digest,
+        plan_digest: canonicalDigest(identity),
+        schedule: schedule.rows,
+        resolved_programs: resolvedPrograms,
+    };
+    return deepFreeze(plan);
+}
+function deepFreeze(value) {
+    if (value && typeof value === "object" && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const child of Object.values(value))
+            deepFreeze(child);
+    }
+    return value;
+}
+export function loadEvalPlan(options) {
+    return validateEvalInputs(options);
+}

package/mcp-memory-server/dist/eval-process.js

@@ -0,0 +1,273 @@
+import { spawn } from "node:child_process";
+import { evalAdapterRequestSchema, evalAdapterResultSchema, } from "./eval-schema.js";
+export const EVAL_PROCESS_ERROR_CODES = [
+    "spawn_error",
+    "timeout",
+    "cancelled",
+    "stdout_overflow",
+    "invalid_utf8",
+    "multiple_json",
+    "invalid_json",
+    "invalid_request",
+    "invalid_result",
+    "adapter_error",
+    "stdin_error",
+    "cleanup_failed",
+];
+export class EvalProcessError extends Error {
+    code;
+    exit_code;
+    signal;
+    cleanup;
+    termination_scope;
+    constructor(code, details = {}) {
+        super(code);
+        this.name = "EvalProcessError";
+        this.code = code;
+        this.exit_code = details.exit_code ?? null;
+        this.signal = details.signal ?? null;
+        this.cleanup = details.cleanup ?? "closed";
+        this.termination_scope = details.termination_scope ?? terminationScope();
+    }
+}
+const DEFAULT_KILL_GRACE_MS = 1_000;
+const MAX_TIMER_MS = 2_147_483_647;
+function terminationScope() {
+    return process.platform === "win32" ? "child" : "process-group";
+}
+function assertOptions(options) {
+    if (!Number.isSafeInteger(options.timeout_ms) || options.timeout_ms <= 0 || options.timeout_ms > MAX_TIMER_MS) {
+        throw new EvalProcessError("invalid_request");
+    }
+    if (!Number.isSafeInteger(options.max_stdout_bytes) || options.max_stdout_bytes < 0) {
+        throw new EvalProcessError("invalid_request");
+    }
+    if (options.kill_grace_ms !== undefined
+        && (!Number.isSafeInteger(options.kill_grace_ms) || options.kill_grace_ms < 0 || options.kill_grace_ms > MAX_TIMER_MS)) {
+        throw new EvalProcessError("invalid_request");
+    }
+    if (!options.command.program || options.command.program.includes("\u0000")
+        || options.command.args.some((argument) => argument.includes("\u0000"))) {
+        throw new EvalProcessError("invalid_request");
+    }
+}
+function signalChild(child, signal) {
+    if (child.pid === undefined)
+        return false;
+    try {
+        if (process.platform !== "win32") {
+            process.kill(-child.pid, signal);
+            return true;
+        }
+        return child.kill(signal);
+    }
+    catch {
+        try {
+            return child.kill(signal);
+        }
+        catch {
+            return false;
+        }
+    }
+}
+async function runCommandInternal(options) {
+    assertOptions(options);
+    if (options.signal?.aborted)
+        throw new EvalProcessError("cancelled");
+    return new Promise((resolvePromise, rejectPromise) => {
+        const scope = terminationScope();
+        const graceMs = options.kill_grace_ms ?? DEFAULT_KILL_GRACE_MS;
+        const captureStdout = options.stdout_mode === "raw";
+        const chunks = [];
+        let stdoutBytes = 0;
+        let terminalCode = null;
+        let cleanup = "closed";
+        let settled = false;
+        let closed = false;
+        let termSent = false;
+        let killSent = false;
+        let exitCode = null;
+        let exitSignal = null;
+        let graceTimer;
+        let closeTimer;
+        const child = spawn(options.command.program, options.command.args, {
+            cwd: options.cwd,
+            env: options.env,
+            shell: false,
+            detached: process.platform !== "win32",
+            windowsHide: true,
+            stdio: [options.stdin_document ? "pipe" : "ignore", captureStdout ? "pipe" : "ignore", "inherit"],
+        });
+        const clearTimers = () => {
+            clearTimeout(timeoutTimer);
+            if (graceTimer)
+                clearTimeout(graceTimer);
+            if (closeTimer)
+                clearTimeout(closeTimer);
+            options.signal?.removeEventListener("abort", onAbort);
+        };
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimers();
+            if (terminalCode) {
+                rejectPromise(new EvalProcessError(terminalCode, {
+                    exit_code: exitCode,
+                    signal: exitSignal,
+                    cleanup,
+                    termination_scope: scope,
+                }));
+                return;
+            }
+            let stdout;
+            if (captureStdout) {
+                try {
+                    stdout = new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks, stdoutBytes));
+                }
+                catch {
+                    rejectPromise(new EvalProcessError("invalid_utf8", {
+                        exit_code: exitCode,
+                        signal: exitSignal,
+                        cleanup,
+                        termination_scope: scope,
+                    }));
+                    return;
+                }
+            }
+            resolvePromise({
+                exit_code: exitCode,
+                signal: exitSignal,
+                cleanup,
+                termination_scope: scope,
+                ...(stdout === undefined ? {} : { stdout }),
+            });
+        };
+        const forceKill = () => {
+            if (closed || killSent)
+                return;
+            killSent = true;
+            cleanup = signalChild(child, "SIGKILL") ? "killed" : "failed";
+            closeTimer = setTimeout(() => {
+                if (closed)
+                    return;
+                cleanup = "failed";
+                terminalCode = terminalCode ?? "cleanup_failed";
+                finish();
+            }, Math.max(graceMs, 100));
+            closeTimer.unref();
+        };
+        const terminate = (code) => {
+            if (terminalCode !== null || settled)
+                return;
+            terminalCode = code;
+            child.stdout?.destroy();
+            child.stdin?.destroy();
+            if (!termSent) {
+                termSent = true;
+                cleanup = signalChild(child, "SIGTERM") ? "terminated" : "failed";
+            }
+            if (closed) {
+                finish();
+                return;
+            }
+            graceTimer = setTimeout(forceKill, graceMs);
+            graceTimer.unref();
+        };
+        const onAbort = () => terminate("cancelled");
+        options.signal?.addEventListener("abort", onAbort, { once: true });
+        const timeoutTimer = setTimeout(() => terminate("timeout"), options.timeout_ms);
+        timeoutTimer.unref();
+        child.once("error", () => {
+            if (closed || settled)
+                return;
+            terminalCode = terminalCode ?? "spawn_error";
+            cleanup = "failed";
+            finish();
+        });
+        child.stdout?.on("data", (value) => {
+            if (terminalCode !== null)
+                return;
+            const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+            stdoutBytes += chunk.byteLength;
+            if (stdoutBytes > options.max_stdout_bytes) {
+                chunks.length = 0;
+                terminate("stdout_overflow");
+                return;
+            }
+            chunks.push(Buffer.from(chunk));
+        });
+        child.once("close", (code, signal) => {
+            if (settled)
+                return;
+            closed = true;
+            exitCode = code;
+            exitSignal = signal;
+            if (!terminalCode)
+                cleanup = "closed";
+            finish();
+        });
+        if (options.stdin_document) {
+            child.stdin?.once("error", () => terminate("stdin_error"));
+            child.stdin?.end(options.stdin_document);
+        }
+    });
+}
+export async function runBoundedCommand(options) {
+    return runCommandInternal(options);
+}
+function hasTrailingJsonDocument(value) {
+    const document = value.trimStart();
+    if (document[0] !== "{" && document[0] !== "[")
+        return false;
+    let depth = 0;
+    let quoted = false;
+    let escaped = false;
+    for (let index = 0; index < document.length; index += 1) {
+        const character = document[index];
+        if (quoted) {
+            if (escaped)
+                escaped = false;
+            else if (character === "\\")
+                escaped = true;
+            else if (character === '"')
+                quoted = false;
+            continue;
+        }
+        if (character === '"')
+            quoted = true;
+        else if (character === "{" || character === "[")
+            depth += 1;
+        else if (character === "}" || character === "]") {
+            depth -= 1;
+            if (depth === 0)
+                return document.slice(index + 1).trim().length > 0;
+        }
+    }
+    return false;
+}
+export async function runBoundedJsonAdapter(options) {
+    const request = evalAdapterRequestSchema.safeParse(options.request);
+    if (!request.success)
+        throw new EvalProcessError("invalid_request");
+    const commandResult = await runCommandInternal({
+        ...options,
+        stdout_mode: "raw",
+        stdin_document: Buffer.from(JSON.stringify(request.data), "utf8"),
+    });
+    if (commandResult.exit_code !== 0 || commandResult.signal !== null || commandResult.cleanup !== "closed") {
+        throw new EvalProcessError("adapter_error", commandResult);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(commandResult.stdout ?? "");
+    }
+    catch {
+        throw new EvalProcessError(hasTrailingJsonDocument(commandResult.stdout ?? "") ? "multiple_json" : "invalid_json", commandResult);
+    }
+    const result = evalAdapterResultSchema.safeParse(parsed);
+    if (!result.success)
+        throw new EvalProcessError("invalid_result", commandResult);
+    const { stdout: _stdout, ...processResult } = commandResult;
+    return { ...processResult, result: result.data };
+}