@plico-ai/runtime 0.0.0-stage → 0.1.0

package/dist/run/tool-step.js

@@ -0,0 +1,62 @@
+import { encodeArtifactContent } from "../artifacts.js";
+import { artifactWriteEventPayload, createStagedArtifactContext, } from "./artifact-tool-context.js";
+export async function runToolStep(ctx, events, eventStore, tool, input, stepName, idempotencyKey) {
+    const started = events.all().find((event) => event.type === "run.started");
+    const threadId = started?.payload.threadId;
+    const context = started?.payload.context;
+    let staged;
+    const workspaceId = threadId ? `${threadId}:workspace` : `${ctx.runId}:workspace`;
+    const ensureStaged = async () => {
+        if (staged)
+            return staged;
+        const threadHistory = threadId && eventStore?.getThreadRunEvents
+            ? (await eventStore.getThreadRunEvents(threadId)).filter((event) => event.runId !== ctx.runId)
+            : [];
+        staged = createStagedArtifactContext(ctx.runId, threadId, [...threadHistory, ...events.all()]);
+        return staged;
+    };
+    const artifacts = {
+        async read(path) {
+            return (await ensureStaged()).context.read(path);
+        },
+        async write(path, content, options) {
+            return (await ensureStaged()).context.write(path, content, options);
+        },
+        async list() {
+            return (await ensureStaged()).context.list();
+        },
+    };
+    const recorded = await ctx.step(stepName, async ({ signal }) => {
+        const result = await tool.handler(input, {
+            signal,
+            idempotencyKey,
+            artifacts,
+            ...(context === undefined ? {} : { context }),
+        });
+        return {
+            result: normalizeToolResult(result),
+            writes: staged?.writes() ?? [],
+            createWorkspace: staged?.workspaceCreated() ?? false,
+            workspaceId: staged?.workspaceId ?? workspaceId,
+        };
+    });
+    await events.append("tool.result", { toolName: tool.name, result: recorded.result });
+    if (recorded.createWorkspace) {
+        await events.append("artifact.workspace.created", { workspaceId: recorded.workspaceId });
+    }
+    for (const write of recorded.writes) {
+        await events.append("artifact.file.written", artifactWriteEventPayload(write));
+    }
+    return recorded.result;
+}
+function normalizeToolResult(value) {
+    if (value instanceof Uint8Array)
+        return encodeArtifactContent(value);
+    if (Array.isArray(value))
+        return value.map(normalizeToolResult);
+    if (value !== null &&
+        typeof value === "object" &&
+        Object.getPrototypeOf(value) === Object.prototype)
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, normalizeToolResult(entry)]));
+    return value;
+}

package/dist/run/tracing.d.ts

@@ -0,0 +1,12 @@
+import { type Span, type SpanContext } from "@opentelemetry/api";
+import type { RunContext } from "../engine/index.js";
+export type StoredSpanContext = Pick<SpanContext, "traceId" | "spanId" | "traceFlags"> & {
+    traceState?: string;
+};
+export declare function storeSpanContext(span: Span): StoredSpanContext;
+export declare function nameToolStep(ctx: RunContext, step: string, tool: string): void;
+export declare function startRunSpan(runId: string, stored?: StoredSpanContext): Span;
+export declare function tracedContext(ctx: RunContext, runSpan: Span, model?: {
+    name: string;
+    provider: string;
+}): RunContext;

package/dist/run/tracing.js

@@ -0,0 +1,92 @@
+import { context, createTraceState, ROOT_CONTEXT, SpanStatusCode, trace, } from "@opentelemetry/api";
+const getTracer = () => trace.getTracer("@plico-ai/runtime");
+const toolNames = new WeakMap();
+export function storeSpanContext(span) {
+    const { traceId, spanId, traceFlags, traceState } = span.spanContext();
+    return {
+        traceId,
+        spanId,
+        traceFlags,
+        ...(traceState ? { traceState: traceState.serialize() } : {}),
+    };
+}
+export function nameToolStep(ctx, step, tool) {
+    toolNames.get(ctx)?.set(step, tool);
+}
+export function startRunSpan(runId, stored) {
+    const previous = stored && {
+        traceId: stored.traceId,
+        spanId: stored.spanId,
+        traceFlags: stored.traceFlags,
+        ...(typeof stored.traceState === "string"
+            ? { traceState: createTraceState(stored.traceState) }
+            : {}),
+    };
+    return getTracer().startSpan("plico.run", {
+        attributes: { "plico.run.id": runId },
+        ...(previous && trace.isSpanContextValid(previous) ? { links: [{ context: previous }] } : {}),
+    });
+}
+export function tracedContext(ctx, runSpan, model) {
+    const names = new Map();
+    const wrapped = {
+        get runId() {
+            return ctx.runId;
+        },
+        get signal() {
+            return ctx.signal;
+        },
+        wait: (name, options) => ctx.wait(name, options),
+        step: (name, fn, options) => {
+            const step = getTracer().startSpan("plico.step", { attributes: { "plico.step.name": name } }, trace.setSpan(ROOT_CONTEXT, runSpan));
+            return ctx
+                .step(name, async (attempt) => {
+                const tool = names.get(name);
+                const modelCall = name.startsWith("model:");
+                const child = getTracer().startSpan(modelCall
+                    ? `chat ${model?.name ?? "model"}`
+                    : tool
+                        ? `execute_tool ${tool}`
+                        : "plico.attempt", {
+                    attributes: {
+                        "plico.step.attempt": attempt.attempt,
+                        ...(tool
+                            ? { "gen_ai.operation.name": "execute_tool", "gen_ai.tool.name": tool }
+                            : {}),
+                        ...(modelCall
+                            ? {
+                                "gen_ai.operation.name": "chat",
+                                ...(model
+                                    ? {
+                                        "gen_ai.request.model": model.name,
+                                        "gen_ai.provider.name": model.provider,
+                                    }
+                                    : {}),
+                            }
+                            : {}),
+                    },
+                }, trace.setSpan(ROOT_CONTEXT, step));
+                try {
+                    return await context.with(trace.setSpan(context.active(), child), () => fn(attempt));
+                }
+                catch (error) {
+                    child.setStatus({ code: SpanStatusCode.ERROR });
+                    throw error;
+                }
+                finally {
+                    child.end();
+                }
+            }, options)
+                .then((value) => {
+                step.end();
+                return value;
+            }, (error) => {
+                step.setStatus({ code: SpanStatusCode.ERROR });
+                step.end();
+                throw error;
+            });
+        },
+    };
+    toolNames.set(wrapped, names);
+    return wrapped;
+}

package/dist/script.d.ts

@@ -0,0 +1,4 @@
+import type { DryRunScriptStep } from "./types/index.js";
+export declare class ScriptValidationError extends Error {
+}
+export declare function normalizeScript(value: unknown): DryRunScriptStep[];

package/dist/script.js

@@ -0,0 +1,51 @@
+export class ScriptValidationError extends Error {
+}
+export function normalizeScript(value) {
+    if (!Array.isArray(value))
+        throw new ScriptValidationError("script must be an array.");
+    return value.map(normalizeStep);
+}
+function normalizeStep(step, index) {
+    const prefix = `script step ${index + 1}`;
+    if (!isRecord(step) || typeof step.type !== "string") {
+        throw new ScriptValidationError(`${prefix} must include a type.`);
+    }
+    if (step.type === "assistant.output") {
+        if (typeof step.content !== "string") {
+            throw new ScriptValidationError(`${prefix} must include content.`);
+        }
+        return { type: "assistant.output", content: step.content };
+    }
+    if (step.type === "tool.call") {
+        if (typeof step.toolName !== "string") {
+            throw new ScriptValidationError(`${prefix} must include a toolName.`);
+        }
+        return {
+            type: "tool.call",
+            toolName: step.toolName,
+            arguments: step.arguments,
+            ...("result" in step ? { result: step.result } : {}),
+            ...(step.live === true ? { live: true } : {}),
+        };
+    }
+    if (step.type === "artifact.write") {
+        if (!Array.isArray(step.files)) {
+            throw new ScriptValidationError(`${prefix} must include a files array.`);
+        }
+        const files = step.files.map((file, fileIndex) => {
+            if (!isRecord(file) || typeof file.path !== "string" || typeof file.content !== "string") {
+                throw new ScriptValidationError(`${prefix} file ${fileIndex + 1} must have path and content strings.`);
+            }
+            return {
+                path: file.path,
+                content: file.content,
+                ...(typeof file.mimeType === "string" ? { mimeType: file.mimeType } : {}),
+            };
+        });
+        return { type: "artifact.write", files };
+    }
+    throw new ScriptValidationError(`${prefix} has an unsupported type.`);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/storage/index.d.ts

@@ -0,0 +1 @@
+export { createSqliteEventStore } from "./sqlite/index.js";

package/dist/storage/index.js

@@ -0,0 +1 @@
+export { createSqliteEventStore } from "./sqlite/index.js";

package/dist/storage/metadata.d.ts

@@ -0,0 +1,5 @@
+import type { JsonValue } from "@plico-ai/contracts";
+export type Metadata = Record<string, JsonValue>;
+/** True when every top-level key of `filter` equals the same key of `metadata`, compared as JSON. */
+export declare function matchesMetadata(metadata: Metadata | undefined, filter: Metadata | undefined): boolean;
+export declare function parseMetadata(json: unknown): Metadata | undefined;

package/dist/storage/metadata.js

@@ -0,0 +1,26 @@
+/** True when every top-level key of `filter` equals the same key of `metadata`, compared as JSON. */
+export function matchesMetadata(metadata, filter) {
+    if (filter === undefined)
+        return true;
+    return Object.entries(filter).every(([key, value]) => metadata !== undefined &&
+        Object.hasOwn(metadata, key) &&
+        sameJson(metadata[key], value));
+}
+function sameJson(left, right) {
+    if (left === right)
+        return true;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return (Array.isArray(left) &&
+            Array.isArray(right) &&
+            left.length === right.length &&
+            left.every((item, index) => sameJson(item, right[index])));
+    }
+    if (left === null || right === null || typeof left !== "object" || typeof right !== "object")
+        return false;
+    const keys = Object.keys(left);
+    return (keys.length === Object.keys(right).length &&
+        keys.every((key) => Object.hasOwn(right, key) && sameJson(left[key], right[key])));
+}
+export function parseMetadata(json) {
+    return typeof json === "string" ? JSON.parse(json) : undefined;
+}

package/dist/storage/sqlite/append-event.d.ts

@@ -0,0 +1,3 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { PlicoEvent } from "@plico-ai/contracts";
+export declare function appendEventRecord(database: DatabaseSync, event: PlicoEvent): void;

package/dist/storage/sqlite/append-event.js

@@ -0,0 +1,108 @@
+import { artifactContentBytes, hashArtifactContent } from "../../artifacts.js";
+import { acquireOwner } from "./owner-lock.js";
+import { projectThreadEvent } from "./project-thread.js";
+export function appendEventRecord(database, event) {
+    if (event.streamType !== "run" || event.streamId !== event.runId) {
+        throw new Error("Event must belong to its run stream.");
+    }
+    database.exec("BEGIN IMMEDIATE");
+    try {
+        const payload = compactArtifactPayload(database, event);
+        const existing = database
+            .prepare("SELECT event_id, type, timestamp, payload_json FROM events WHERE stream_type = ? AND stream_id = ? AND sequence = ?")
+            .get(event.streamType, event.streamId, event.sequence);
+        if (existing) {
+            if (existing.event_id !== event.id ||
+                existing.type !== event.type ||
+                existing.timestamp !== event.timestamp ||
+                existing.payload_json !== JSON.stringify(payload)) {
+                throw new Error(`Conflicting event at sequence ${event.sequence}.`);
+            }
+            database.exec("COMMIT");
+            return;
+        }
+        const row = database.prepare("SELECT status FROM runs WHERE run_id = ?").get(event.runId);
+        const last = database
+            .prepare("SELECT sequence, type FROM events WHERE stream_type = ? AND stream_id = ? ORDER BY sequence DESC LIMIT 1")
+            .get(event.streamType, event.streamId);
+        if (event.sequence !== (last?.sequence ?? 0) + 1)
+            throw new Error("Events must be appended in sequence.");
+        if (last?.type === "run.error" && event.type !== "run.failed") {
+            throw new Error("run.error must be followed by run.failed.");
+        }
+        if (!row) {
+            if (event.type !== "run.started" || event.sequence !== 1)
+                throw new Error("The first event must be run.started.");
+            database
+                .prepare("INSERT INTO runs (run_id, project_root, project_name, status, started_at, ended_at, metadata_json) VALUES (?, ?, ?, 'running', ?, NULL, ?)")
+                .run(event.runId, String(event.payload.projectRoot ?? ""), String(event.payload.projectName ?? ""), event.timestamp, event.payload.metadata === undefined ? null : JSON.stringify(event.payload.metadata));
+            const owner = acquireOwner();
+            database
+                .prepare("INSERT INTO run_owners (run_id, process_id, owner_token, owner_path) VALUES (?, ?, ?, ?)")
+                .run(event.runId, process.pid, owner.token, owner.path);
+        }
+        else {
+            if (row.status === "waiting") {
+                // The first event after run.waiting is the run continuing, so the log alone says it is running.
+                database
+                    .prepare("UPDATE runs SET status = 'running', ended_at = NULL WHERE run_id = ?")
+                    .run(event.runId);
+                const owner = acquireOwner();
+                database
+                    .prepare("INSERT OR REPLACE INTO run_owners (run_id, process_id, owner_token, owner_path) VALUES (?, ?, ?, ?)")
+                    .run(event.runId, process.pid, owner.token, owner.path);
+            }
+            else if (row.status !== "running") {
+                throw new Error(`Cannot append to run with status ${row.status}.`);
+            }
+            if (event.type === "run.started")
+                throw new Error("Run has already started.");
+            const status = event.type === "run.waiting"
+                ? "waiting"
+                : event.type === "run.completed"
+                    ? "completed"
+                    : event.type === "run.failed"
+                        ? "failed"
+                        : event.type === "run.cancelled"
+                            ? "cancelled"
+                            : undefined;
+            if (status) {
+                const endedAt = status === "waiting" ? null : event.timestamp;
+                const output = (event.type === "run.completed" || event.type === "run.waiting") &&
+                    typeof event.payload.output === "string"
+                    ? event.payload.output
+                    : null;
+                database
+                    .prepare("UPDATE runs SET status = ?, ended_at = ?, output = ? WHERE run_id = ?")
+                    .run(status, endedAt, output, event.runId);
+                // Drop the owner once the run leaves running, including waiting; recovery only inspects running runs.
+                database.prepare("DELETE FROM run_owners WHERE run_id = ?").run(event.runId);
+            }
+        }
+        database
+            .prepare("INSERT INTO events (stream_type, stream_id, sequence, event_id, schema_version, type, timestamp, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?)")
+            .run(event.streamType, event.streamId, event.sequence, event.id, event.schemaVersion, event.type, event.timestamp, JSON.stringify(payload));
+        projectThreadEvent(database, event);
+        database.exec("COMMIT");
+    }
+    catch (error) {
+        database.exec("ROLLBACK");
+        throw error;
+    }
+}
+function compactArtifactPayload(database, event) {
+    if (event.type !== "artifact.file.written")
+        return event.payload;
+    const { content, contentHash: declaredHash, ...receipt } = event.payload;
+    const actualHash = hashArtifactContent(content);
+    if (declaredHash !== undefined && actualHash !== declaredHash)
+        throw new Error("Artifact content hash does not match its content.");
+    database
+        .prepare("INSERT OR IGNORE INTO artifact_content (content_hash, content) VALUES (?, ?)")
+        .run(actualHash, Buffer.from(artifactContentBytes(content)));
+    return {
+        ...receipt,
+        ...(typeof content === "string" ? {} : { contentEncoding: "base64" }),
+        contentHash: actualHash,
+    };
+}

package/dist/storage/sqlite/driver.d.ts

@@ -0,0 +1,9 @@
+import type { DatabaseSync } from "node:sqlite";
+type SqliteSource = ConstructorParameters<typeof DatabaseSync>[0];
+type SqliteOptions = ConstructorParameters<typeof DatabaseSync>[1];
+/**
+ * Opens a SQLite database, loading `node:sqlite` on first use. Importing it eagerly would print
+ * Node's experimental warning for commands that never touch a database, such as `--version`.
+ */
+export declare function createDatabase(path: SqliteSource, options?: SqliteOptions): DatabaseSync;
+export {};

package/dist/storage/sqlite/driver.js

@@ -0,0 +1,13 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+let sqlite;
+/**
+ * Opens a SQLite database, loading `node:sqlite` on first use. Importing it eagerly would print
+ * Node's experimental warning for commands that never touch a database, such as `--version`.
+ */
+export function createDatabase(path, options) {
+    sqlite ??= require("node:sqlite");
+    return options === undefined
+        ? new sqlite.DatabaseSync(path)
+        : new sqlite.DatabaseSync(path, options);
+}

package/dist/storage/sqlite/index.d.ts

@@ -0,0 +1 @@
+export { createSqliteEventStore } from "./store.js";

package/dist/storage/sqlite/index.js

@@ -0,0 +1 @@
+export { createSqliteEventStore } from "./store.js";

package/dist/storage/sqlite/open.d.ts

@@ -0,0 +1,3 @@
+import type { DatabaseSync } from "node:sqlite";
+/** Opens the database with the pragma order and migrator every Plico store shares. */
+export declare function openDatabase(databasePath: string, readOnly?: boolean): DatabaseSync;

package/dist/storage/sqlite/open.js

@@ -0,0 +1,54 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createDatabase } from "./driver.js";
+import { checkReadOnlySchema, initializeSchema } from "./schema.js";
+/** Opens the database with the pragma order and migrator every Plico store shares. */
+export function openDatabase(databasePath, readOnly = false) {
+    if (!readOnly)
+        mkdirSync(dirname(databasePath), { recursive: true });
+    const database = createDatabase(readOnly ? readOnlySource(databasePath) : databasePath, {
+        readOnly,
+    });
+    try {
+        database.exec("PRAGMA busy_timeout = 5000;");
+        if (!readOnly) {
+            setWalMode(database);
+            initializeSchema(database);
+        }
+        else {
+            checkReadOnlySchema(database);
+        }
+    }
+    catch (error) {
+        database.close();
+        throw error;
+    }
+    return database;
+}
+function setWalMode(database) {
+    // Changing journal mode may return SQLITE_BUSY immediately even with busy_timeout set.
+    const deadline = Date.now() + 5000;
+    const pause = new Int32Array(new SharedArrayBuffer(4));
+    while (true) {
+        try {
+            database.exec("PRAGMA journal_mode = WAL;");
+            return;
+        }
+        catch (error) {
+            const code = error.errcode;
+            if (code === undefined || (code & 0xff) !== 5 || Date.now() >= deadline)
+                throw error;
+            Atomics.wait(pause, 0, 0, Math.min(25, deadline - Date.now()));
+        }
+    }
+}
+// A plain read-only open of a WAL database creates -shm and -wal files. Immutable mode
+// avoids them but ignores WAL content, so it is only safe when no -wal file exists.
+function readOnlySource(databasePath) {
+    if (existsSync(`${databasePath}-wal`))
+        return databasePath;
+    const url = pathToFileURL(databasePath);
+    url.searchParams.set("immutable", "1");
+    return url;
+}

package/dist/storage/sqlite/owner-lock.d.ts

@@ -0,0 +1,5 @@
+export declare function acquireOwner(): {
+    token: string;
+    path: string;
+};
+export declare function ownerIsAlive(token: string, path: string): boolean;

package/dist/storage/sqlite/owner-lock.js

@@ -0,0 +1,55 @@
+import { randomUUID } from "node:crypto";
+import { rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { createDatabase } from "./driver.js";
+let current;
+function lockPath(token) {
+    return join(tmpdir(), `plico-run-owner-${token}.sqlite`);
+}
+export function acquireOwner() {
+    if (current)
+        return current;
+    const token = randomUUID();
+    const path = lockPath(token);
+    const database = createDatabase(path);
+    // SQLite releases this process-owned lock on exit, even when a PID is reused.
+    database.exec("CREATE TABLE owner_lock (id INTEGER); BEGIN EXCLUSIVE;");
+    current = { token, path, database };
+    process.once("exit", () => {
+        try {
+            database.close();
+            rmSync(path, { force: true });
+        }
+        catch {
+            /* OS cleanup may happen later. */
+        }
+    });
+    return current;
+}
+export function ownerIsAlive(token, path) {
+    if (current?.token === token)
+        return true;
+    if (!/^[a-f0-9-]{36}$/.test(token) || basename(path) !== `plico-run-owner-${token}.sqlite`)
+        return true;
+    try {
+        statSync(path);
+    }
+    catch (error) {
+        // ENOENT means the owner is gone, though a temp-folder cleaner could remove a live lock file.
+        return error.code !== "ENOENT";
+    }
+    let probe;
+    try {
+        probe = createDatabase(path, { readOnly: true });
+        probe.exec("PRAGMA busy_timeout = 0; BEGIN EXCLUSIVE; ROLLBACK;");
+        return false;
+    }
+    catch {
+        // Any probe error counts as alive, so the run stays running rather than failing spuriously.
+        return true;
+    }
+    finally {
+        probe?.close();
+    }
+}

package/dist/storage/sqlite/project-thread.d.ts

@@ -0,0 +1,4 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { PlicoEvent } from "@plico-ai/contracts";
+/** Called inside the run event transaction so the transcript cannot lag behind its log. */
+export declare function projectThreadEvent(db: DatabaseSync, event: PlicoEvent): void;

package/dist/storage/sqlite/project-thread.js

@@ -0,0 +1,33 @@
+import { randomUUID } from "node:crypto";
+import { appendThreadEvent } from "./thread-log.js";
+import { retitleThread } from "./thread-title.js";
+/** Called inside the run event transaction so the transcript cannot lag behind its log. */
+export function projectThreadEvent(db, event) {
+    if (event.type === "run.started" && event.payload.threadId) {
+        const threadId = event.payload.threadId;
+        if (!db.prepare("SELECT 1 FROM threads WHERE thread_id = ?").get(threadId))
+            throw new Error("Unknown thread.");
+        db.prepare("INSERT OR IGNORE INTO thread_runs (run_id, thread_id) VALUES (?, ?)").run(event.runId, threadId);
+        const linked = db
+            .prepare("SELECT thread_id FROM thread_runs WHERE run_id = ?")
+            .get(event.runId);
+        if (linked.thread_id !== threadId)
+            throw new Error("Run already belongs to another thread.");
+    }
+    if (event.type !== "run.completed" || event.payload.output === undefined)
+        return;
+    const run = db.prepare("SELECT thread_id FROM thread_runs WHERE run_id = ?").get(event.runId);
+    if (!run)
+        return;
+    const message = {
+        id: randomUUID(),
+        threadId: run.thread_id,
+        role: "assistant",
+        content: event.payload.output,
+        createdAt: event.timestamp,
+        runId: event.runId,
+    };
+    const sequence = appendThreadEvent(db, run.thread_id, "message.created", { message }, event.timestamp);
+    db.prepare("INSERT INTO thread_messages (message_id, thread_id, role, content, created_at, sequence, run_id) VALUES (?, ?, 'assistant', ?, ?, ?, ?)").run(message.id, run.thread_id, message.content, event.timestamp, sequence, event.runId);
+    retitleThread(db, run.thread_id, event.timestamp);
+}

package/dist/storage/sqlite/queries.d.ts

@@ -0,0 +1,9 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { EvalReport, PlicoEvent, RunSummary } from "@plico-ai/contracts";
+export declare function readRunSummaries(database: DatabaseSync): RunSummary[];
+export declare function readRunSummary(database: DatabaseSync, runId: string): RunSummary | undefined;
+export declare function readEvents(database: DatabaseSync, runId: string, afterSequence: number | undefined): PlicoEvent[];
+export declare function readThreadRunEvents(database: DatabaseSync, threadId: string): PlicoEvent[];
+export declare function readThreadRunEventsThrough(database: DatabaseSync, threadId: string, runId: string): PlicoEvent[];
+export declare function persistEvalReportRecord(database: DatabaseSync, report: EvalReport): void;
+export declare function readLatestEvalReport(database: DatabaseSync): EvalReport | undefined;