@sema-agent/core/dist/core/store-contracts/workflow-journal-store-contract.js

Stateless, task-oriented AI agent core

import { strict as assert } from "node:assert";
import { JOURNAL_OVERSIZE_ERROR_CODE, MAX_JOURNAL_RESULT_BYTES, } from "../workflow-journal-store.js";
import { beginContract } from "./contract-harness.js";
const key = (ordinal) => `${ordinal}:h`;
const completed = (ordinal, over = {}) => ({
    taskId: `t-${ordinal}`,
    sessionId: `s-${ordinal}`,
    terminal: { kind: "completed" },
    result: `r${ordinal}`,
    structuredOutput: { ordinal, nested: { ok: true } },
    stats: { turns: 1, tokens: 1, costMicroUsd: 0, nested: { tokens: 0, turns: 0, tasks: 0, costMicroUsd: 0 } },
    ...over,
});
const parked = (ordinal, over = {}) => ({
    taskId: `t-${ordinal}`,
    sessionId: `s-${ordinal}`,
    terminal: { kind: "paused", token: `tok-${ordinal}`, checkpointId: `cp-${ordinal}`, gate: { kind: "human", reason: "approve", toolName: "Write" } },
    result: "",
    structuredOutput: { partial: ordinal },
    stats: { turns: 1, tokens: 1, costMicroUsd: 0, nested: { tokens: 3, turns: 2, tasks: 1, costMicroUsd: 1 } },
    ...over,
});
const OVER_CAP = "x".repeat(MAX_JOURNAL_RESULT_BYTES + 1024);
const isOversizeRefusal = (e) => e instanceof Error && e.code === JOURNAL_OVERSIZE_ERROR_CODE;
export async function workflowJournalStoreContract(make, runAssertion) {
    const { run, settle } = beginContract(runAssertion);
    run("append → load returns entries ASCENDING by ordinal, both arms verbatim; a re-append per ordinal OVERWRITES", async () => {
        const store = make();
        await store.append("run-1", "tenant-a", { callKey: key(10), result: completed(10) });
        await store.append("run-1", "tenant-a", { callKey: key(1), parked: parked(1) });
        await store.append("run-1", "tenant-a", { callKey: key(0), result: completed(0) });
        await store.append("run-1", "tenant-a", { callKey: key(2), result: completed(2) });
        await store.append("run-1", "tenant-a", { callKey: key(0), result: completed(0, { result: "overwritten" }) });
        const entries = await store.load("run-1", "tenant-a");
        assert.deepEqual(entries.map((e) => e.callKey), [key(0), key(1), key(2), key(10)]);
        assert.deepEqual(entries[0], { callKey: key(0), result: completed(0, { result: "overwritten" }) });
        assert.deepEqual(entries[1], { callKey: key(1), parked: parked(1) });
    });
    run("scope wall: a cross-scope load is EMPTY — before and after the owner's own load, and after a refused cross-scope append — on both arms", async () => {
        const store = make();
        await store.append("run-1", "alice", { callKey: key(0), result: completed(0) });
        await store.append("run-1", "alice", { callKey: key(1), parked: parked(1) });
        assert.deepEqual(await store.load("run-1", "mallory"), []);
        assert.equal((await store.load("run-1", "alice")).length, 2);
        assert.deepEqual(await store.load("run-1", "mallory"), []);
        await assert.rejects(store.append("run-1", "mallory", { callKey: key(2), result: completed(2) }));
        await assert.rejects(store.append("run-1", "mallory", { callKey: key(3), parked: parked(3) }));
        assert.deepEqual(await store.load("run-1", "mallory"), []);
        assert.deepEqual((await store.load("run-1", "alice")).map((e) => e.callKey), [key(0), key(1)]);
    });
    run(`oversize RESULT arm ⇒ append rejects with code "${JOURNAL_OVERSIZE_ERROR_CODE}"; nothing journaled; the store stays usable`, async () => {
        const store = make();
        await store.append("run-1", "tenant-a", { callKey: key(0), result: completed(0) });
        await assert.rejects(store.append("run-1", "tenant-a", { callKey: key(1), result: completed(1, { result: OVER_CAP }) }), isOversizeRefusal);
        assert.deepEqual((await store.load("run-1", "tenant-a")).map((e) => e.callKey), [key(0)]);
        await store.append("run-1", "tenant-a", { callKey: key(2), result: completed(2) });
        assert.deepEqual((await store.load("run-1", "tenant-a")).map((e) => e.callKey), [key(0), key(2)]);
    });
    run(`oversize PARKED arm ⇒ append rejects with code "${JOURNAL_OVERSIZE_ERROR_CODE}"; nothing journaled (never a silent skip — a lost park is a resume running the ordinal live)`, async () => {
        const store = make();
        await store.append("run-1", "tenant-a", { callKey: key(0), result: completed(0) });
        await assert.rejects(store.append("run-1", "tenant-a", { callKey: key(1), parked: parked(1, { result: OVER_CAP }) }), isOversizeRefusal);
        assert.deepEqual((await store.load("run-1", "tenant-a")).map((e) => e.callKey), [key(0)]);
        await store.append("run-1", "tenant-a", { callKey: key(1), parked: parked(1) });
        assert.equal((await store.load("run-1", "tenant-a"))[1].parked?.terminal.kind, "paused");
    });
    run("the cap is inclusive: a payload of EXACTLY the cap's byte count is accepted on both arms", async () => {
        const store = make();
        const fit = (payload) => {
            const base = Buffer.byteLength(JSON.stringify({ ...payload, result: "" }), "utf8");
            return { ...payload, result: "y".repeat(MAX_JOURNAL_RESULT_BYTES - base) };
        };
        const r = fit(completed(0));
        const p = fit(parked(1));
        assert.equal(Buffer.byteLength(JSON.stringify(r), "utf8"), MAX_JOURNAL_RESULT_BYTES);
        assert.equal(Buffer.byteLength(JSON.stringify(p), "utf8"), MAX_JOURNAL_RESULT_BYTES);
        await store.append("run-1", "tenant-a", { callKey: key(0), result: r });
        await store.append("run-1", "tenant-a", { callKey: key(1), parked: p });
        const entries = await store.load("run-1", "tenant-a");
        assert.deepEqual(entries.map((e) => e.callKey), [key(0), key(1)]);
        assert.deepEqual(entries[0].result, r);
        assert.deepEqual(entries[1].parked, p);
    });
    await settle();
}