@sema-agent/server 1.315.0 → 1.317.0

package/dist/plugins/tidb-workflow-run-store.d.ts

@@ -1,62 +1,2 @@
-import type { Pool } from "mysql2/promise";
-import { summarizeWorkflowRun, type WorkflowRunStore } from "@sema-agent/core";
-import { type WorkflowCompletionInbox, type WorkflowCompletionInboxEntry } from "../orchestration/workflow-completion-inbox.js";
-import type { WorkflowNotifyJournalStore, WorkflowNotifyJournalEntry } from "../orchestration/workflow-notify-journal.js";
-type WorkflowRun = Parameters<WorkflowRunStore["put"]>[1];
-export declare const MAX_RUN_BLOB_BYTES: number;
-declare const onWarnType: (msg: string, meta: Record<string, unknown>) => void;
-export type InboxWarn = typeof onWarnType;
-export declare function slimOversizeRun(run: WorkflowRun & {
-    id: string;
-    scope: string;
-}, maxBytes: number): string | null;
-export declare class TiDBWorkflowRunStore implements WorkflowRunStore {
-    private readonly pool;
-    constructor(pool: Pool);
-    put(id: string, run: WorkflowRun): Promise<void>;
-    get(id: string): Promise<WorkflowRun | null>;
-    update(id: string, scope: string, run: WorkflowRun, expect?: {
-        rev: number;
-    }): Promise<boolean>;
-    listByScope(scope: string, opts?: {
-        status?: WorkflowRun["status"];
-        limit?: number;
-        session?: string;
-    }): Promise<ReturnType<typeof summarizeWorkflowRun>[]>;
-    reapAllScopes(now: number, opts: {
-        maxAgeMs?: number;
-        keep?: number;
-    }): Promise<number>;
-    reap(scope: string, now: number, opts?: {
-        maxAgeMs?: number;
-        keep?: number;
-    }): Promise<number>;
-}
-export declare class TiDBWorkflowCompletionInbox implements WorkflowCompletionInbox {
-    private readonly pool;
-    private readonly onWarn?;
-    constructor(pool: Pool, onWarn?: InboxWarn | undefined);
-    private sweepFences;
-    enqueue(entry: WorkflowCompletionInboxEntry): Promise<void>;
-    pending(sessionId: string): Promise<WorkflowCompletionInboxEntry[]>;
-    ack(sessionId: string, runId: string): Promise<void>;
-    purge(sessionId: string, purgedOwner?: string | null): Promise<void>;
-    markTerminalServed(sessionId: string, runId: string): Promise<void>;
-}
-export declare class TiDBWorkflowNotifyJournalStore implements WorkflowNotifyJournalStore {
-    private readonly pool;
-    constructor(pool: Pool);
-    record(input: {
-        runId: string;
-        scope: string;
-        sourceTaskId?: string;
-        principal?: string;
-        createdAt: number;
-    }): Promise<void>;
-    ack(runId: string, ackedAt: number): Promise<void>;
-    listPending(): Promise<WorkflowNotifyJournalEntry[]>;
-    reapAcked(before: number): Promise<number>;
-    get(runId: string): Promise<WorkflowNotifyJournalEntry | null>;
-}
-export {};
+export { MAX_RUN_BLOB_BYTES, slimOversizeRun, type InboxWarn, TiDBWorkflowRunStore, TiDBWorkflowCompletionInbox, TiDBWorkflowNotifyJournalStore, } from "./workflow-run-store-sql.js";
 //# sourceMappingURL=tidb-workflow-run-store.d.ts.map

package/dist/plugins/tidb-workflow-run-store.js

@@ -1,232 +1,2 @@
-import { summarizeWorkflowRun, isTerminalWorkflowStatus, WorkflowRunStoreError } from "@sema-agent/core";
-import { foldKeyFamily, MAX_PENDING_PER_SESSION, PURGE_FENCE_MS, SERVED_FENCE_MS, } from "../orchestration/workflow-completion-inbox.js";
-export const MAX_RUN_BLOB_BYTES = 4 * 1024 * 1024;
-const onWarnType = (msg, meta) => void [msg, meta];
-export function slimOversizeRun(run, maxBytes) {
-    const MARK = "…[truncated: run blob exceeded the store cap]";
-    const cut = (s) => s.slice(0, 4000) + MARK;
-    const step1 = {
-        ...run,
-        ...(typeof run.result === "string" && run.result.length > 4000 ? { result: cut(run.result) } : {}),
-        ...(typeof run.error === "string" && run.error.length > 4000 ? { error: cut(run.error) } : {}),
-    };
-    let blob = JSON.stringify(step1);
-    if (Buffer.byteLength(blob) <= maxBytes)
-        return blob;
-    const step2 = { ...step1, phases: [], agents: [], groups: [], error: step1.error ? String(step1.error).slice(0, 1000) + MARK : MARK };
-    blob = JSON.stringify(step2);
-    return Buffer.byteLength(blob) <= maxBytes ? blob : null;
-}
-export class TiDBWorkflowRunStore {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async put(id, run) {
-        const stored = { ...run, id, rev: run.rev ?? 0 };
-        try {
-            await this.pool.query("INSERT INTO workflow_run (id, scope, status, run, rev, created_at, ended_at) VALUES (?,?,?,?,?,?,?)", [id, run.scope, run.status, JSON.stringify(stored), stored.rev, run.createdAt, run.endedAt ?? null]);
-        }
-        catch (e) {
-            if (e.code === "ER_DUP_ENTRY") {
-                throw new WorkflowRunStoreError("workflow_run.already_exists", "workflow run id already exists");
-            }
-            throw e;
-        }
-    }
-    async get(id) {
-        const [rows] = await this.pool.query("SELECT run, rev FROM workflow_run WHERE id = ?", [id]);
-        const r = rows[0];
-        if (!r)
-            return null;
-        const run = JSON.parse(String(r.run));
-        run.rev = Number(r.rev);
-        return run;
-    }
-    async update(id, scope, run, expect) {
-        let blob = JSON.stringify({ ...run, id, scope });
-        if (Buffer.byteLength(blob) > MAX_RUN_BLOB_BYTES) {
-            const slim = slimOversizeRun({ ...run, id, scope }, MAX_RUN_BLOB_BYTES);
-            if (slim === null)
-                return false;
-            blob = slim;
-        }
-        const [res] = await this.pool.query(`UPDATE workflow_run SET run = ?, rev = rev + 1, status = ?, ended_at = ? WHERE id = ? AND scope = ?${expect !== undefined ? " AND rev = ?" : ""}`, expect !== undefined
-            ? [blob, run.status, run.endedAt ?? null, id, scope, expect.rev]
-            : [blob, run.status, run.endedAt ?? null, id, scope]);
-        return res.affectedRows === 1;
-    }
-    async listByScope(scope, opts) {
-        const params = [scope];
-        let where = "scope = ?";
-        if (opts?.status !== undefined) {
-            where += " AND status = ?";
-            params.push(opts.status);
-        }
-        if (opts?.session !== undefined) {
-            where += " AND JSON_UNQUOTE(JSON_EXTRACT(run, '$.originatingSessionId')) = ?";
-            params.push(opts.session);
-        }
-        let limit = "";
-        if (opts?.limit !== undefined) {
-            limit = " LIMIT ?";
-            params.push(Math.max(0, opts.limit));
-        }
-        const [rows] = await this.pool.query(`SELECT run, rev FROM workflow_run WHERE ${where} ORDER BY created_at DESC, id DESC${limit}`, params);
-        return rows.map((r) => {
-            const run = JSON.parse(String(r.run));
-            run.rev = Number(r.rev);
-            return summarizeWorkflowRun(run);
-        });
-    }
-    async reapAllScopes(now, opts) {
-        const [rows] = await this.pool.query("SELECT DISTINCT scope FROM workflow_run");
-        let total = 0;
-        for (const r of rows)
-            total += await this.reap(String(r.scope), now, opts);
-        return total;
-    }
-    async reap(scope, now, opts) {
-        if (opts?.maxAgeMs === undefined && opts?.keep === undefined)
-            return 0;
-        const [rows] = await this.pool.query("SELECT id, status, created_at, ended_at FROM workflow_run WHERE scope = ? ORDER BY created_at DESC, id DESC", [scope]);
-        const terminal = rows.filter((r) => isTerminalWorkflowStatus(String(r.status)));
-        const doomed = [];
-        for (let i = 0; i < terminal.length; i++) {
-            const r = terminal[i];
-            const anchor = r.ended_at != null ? Number(r.ended_at) : Number(r.created_at);
-            const tooOld = opts.maxAgeMs !== undefined && anchor < now - opts.maxAgeMs;
-            const overKeep = opts.keep !== undefined && i >= opts.keep;
-            if (tooOld || overKeep)
-                doomed.push(String(r.id));
-        }
-        if (doomed.length === 0)
-            return 0;
-        const [res] = await this.pool.query(`DELETE FROM workflow_run WHERE scope = ? AND id IN (${doomed.map(() => "?").join(",")})`, [scope, ...doomed]);
-        return res.affectedRows;
-    }
-}
-const KIND_SERVED = "served";
-const KIND_PURGE = "purge";
-export class TiDBWorkflowCompletionInbox {
-    pool;
-    onWarn;
-    constructor(pool, onWarn) {
-        this.pool = pool;
-        this.onWarn = onWarn;
-    }
-    async sweepFences(now) {
-        await this.pool.query("DELETE FROM workflow_inbox_fence WHERE until_ms < ?", [now]);
-    }
-    async enqueue(entry) {
-        const now = Date.now();
-        await this.sweepFences(now);
-        const [served] = await this.pool.query("SELECT 1 FROM workflow_inbox_fence WHERE session_id = ? AND kind = ? AND run_id IN (?, ?) AND until_ms >= ?", [entry.sessionId, KIND_SERVED, entry.runId, foldKeyFamily(entry.runId), now]);
-        if (served.length > 0) {
-            this.onWarn?.("workflow_completion_enqueue_after_poll_served", { sessionId: entry.sessionId, runId: entry.runId });
-            return;
-        }
-        const [purge] = await this.pool.query("SELECT owner, owner_known FROM workflow_inbox_fence WHERE session_id = ? AND kind = ? AND run_id = '' AND until_ms >= ?", [entry.sessionId, KIND_PURGE, now]);
-        const pf = purge[0];
-        if (pf && (Number(pf.owner_known) === 0 || (pf.owner === null ? entry.owner === null : String(pf.owner) === entry.owner))) {
-            this.onWarn?.("workflow_completion_enqueue_after_purge", { sessionId: entry.sessionId, runId: entry.runId });
-            return;
-        }
-        await this.pool.query("REPLACE INTO workflow_completion_inbox (session_id, run_id, owner, status, summary, enqueued_at, kind, payload) VALUES (?,?,?,?,?,?,?,?)", [entry.sessionId, entry.runId, entry.owner, entry.status, entry.summary, entry.enqueuedAt, entry.kind ?? null, entry.payload ?? null]);
-        const [confirm] = await this.pool.query("SELECT kind, owner, owner_known FROM workflow_inbox_fence WHERE session_id = ? AND until_ms >= ? AND (run_id IN (?, ?) OR (kind = ? AND run_id = ''))", [entry.sessionId, now, entry.runId, foldKeyFamily(entry.runId), KIND_PURGE]);
-        for (const f of confirm) {
-            const isServed = String(f.kind) === KIND_SERVED;
-            const purgeFencesUs = !isServed && (Number(f.owner_known) === 0 || (f.owner === null ? entry.owner === null : String(f.owner) === entry.owner));
-            if (isServed || purgeFencesUs) {
-                await this.ack(entry.sessionId, entry.runId);
-                this.onWarn?.(isServed ? "workflow_completion_enqueue_after_poll_served" : "workflow_completion_enqueue_after_purge", {
-                    sessionId: entry.sessionId,
-                    runId: entry.runId,
-                });
-                return;
-            }
-        }
-        const [over] = await this.pool.query("SELECT seq, run_id FROM workflow_completion_inbox WHERE session_id = ? ORDER BY seq DESC LIMIT 100000 OFFSET ?", [entry.sessionId, MAX_PENDING_PER_SESSION]);
-        if (over.length > 0) {
-            await this.pool.query(`DELETE FROM workflow_completion_inbox WHERE session_id = ? AND seq IN (${over.map(() => "?").join(",")})`, [entry.sessionId, ...over.map((r) => r.seq)]);
-            for (const r of over)
-                this.onWarn?.("workflow_completion_inbox_overflow", { sessionId: entry.sessionId, droppedRunId: String(r.run_id) });
-        }
-    }
-    async pending(sessionId) {
-        const [rows] = await this.pool.query("SELECT i.run_id, i.owner, i.status, i.summary, i.enqueued_at, i.kind, i.payload FROM workflow_completion_inbox i " +
-            "WHERE i.session_id = ? AND NOT EXISTS (SELECT 1 FROM workflow_inbox_fence f WHERE f.session_id = i.session_id AND f.kind = ? AND f.run_id IN (i.run_id, REGEXP_REPLACE(i.run_id, '#[0-9]+$', '')) AND f.until_ms >= ?) " +
-            "ORDER BY i.seq ASC", [sessionId, KIND_SERVED, Date.now()]);
-        return rows.map((r) => ({
-            sessionId,
-            runId: String(r.run_id),
-            owner: r.owner === null ? null : String(r.owner),
-            status: String(r.status),
-            summary: String(r.summary),
-            enqueuedAt: Number(r.enqueued_at),
-            ...(r.kind != null ? { kind: String(r.kind) } : {}),
-            ...(r.payload != null ? { payload: String(r.payload) } : {}),
-        }));
-    }
-    async ack(sessionId, runId) {
-        await this.pool.query("DELETE FROM workflow_completion_inbox WHERE session_id = ? AND run_id = ?", [sessionId, runId]);
-    }
-    async purge(sessionId, purgedOwner) {
-        const now = Date.now();
-        await this.sweepFences(now);
-        await this.pool.query("INSERT INTO workflow_inbox_fence (session_id, kind, run_id, owner, owner_known, until_ms) VALUES (?,?,?,?,?,?) " +
-            "ON DUPLICATE KEY UPDATE owner = VALUES(owner), owner_known = VALUES(owner_known), until_ms = VALUES(until_ms)", [sessionId, KIND_PURGE, "", purgedOwner ?? null, purgedOwner !== undefined ? 1 : 0, now + PURGE_FENCE_MS]);
-        await this.pool.query("DELETE FROM workflow_completion_inbox WHERE session_id = ?", [sessionId]);
-    }
-    async markTerminalServed(sessionId, runId) {
-        const now = Date.now();
-        await this.sweepFences(now);
-        await this.pool.query("INSERT INTO workflow_inbox_fence (session_id, kind, run_id, owner, owner_known, until_ms) VALUES (?,?,?,NULL,0,?) " +
-            "ON DUPLICATE KEY UPDATE until_ms = VALUES(until_ms)", [sessionId, KIND_SERVED, runId, now + SERVED_FENCE_MS]);
-        await this.ack(sessionId, runId);
-        await this.pool.query("DELETE FROM workflow_completion_inbox WHERE session_id = ? AND run_id <> ? AND REGEXP_REPLACE(run_id, '#[0-9]+$', '') = ?", [sessionId, runId, runId]);
-    }
-}
-export class TiDBWorkflowNotifyJournalStore {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async record(input) {
-        await this.pool.query("INSERT IGNORE INTO workflow_notify_journal (run_id, scope, acked, source_task_id, principal, created_at) VALUES (?,?,0,?,?,?)", [input.runId, input.scope, input.sourceTaskId ?? null, input.principal ?? null, input.createdAt]);
-    }
-    async ack(runId, ackedAt) {
-        await this.pool.query("UPDATE workflow_notify_journal SET acked = 1, acked_at = ? WHERE run_id = ? AND acked = 0", [ackedAt, runId]);
-    }
-    async listPending() {
-        const [rows] = await this.pool.query("SELECT run_id, scope, source_task_id, principal, created_at FROM workflow_notify_journal WHERE acked = 0");
-        return rows.map((r) => ({
-            runId: String(r.run_id),
-            scope: String(r.scope),
-            acked: false,
-            ...(r.source_task_id != null ? { sourceTaskId: String(r.source_task_id) } : {}),
-            ...(r.principal != null ? { principal: String(r.principal) } : {}),
-            createdAt: Number(r.created_at),
-        }));
-    }
-    async reapAcked(before) {
-        const [res] = await this.pool.query("DELETE FROM workflow_notify_journal WHERE acked = 1 AND acked_at < ?", [before]);
-        return res.affectedRows;
-    }
-    async get(runId) {
-        const [rows] = await this.pool.query("SELECT run_id, scope, acked, source_task_id, principal, created_at, acked_at FROM workflow_notify_journal WHERE run_id = ?", [runId]);
-        const r = rows[0];
-        if (!r)
-            return null;
-        return {
-            runId: String(r.run_id),
-            scope: String(r.scope),
-            acked: Number(r.acked) === 1,
-            ...(r.source_task_id != null ? { sourceTaskId: String(r.source_task_id) } : {}),
-            ...(r.principal != null ? { principal: String(r.principal) } : {}),
-            createdAt: Number(r.created_at),
-            ...(r.acked_at != null ? { ackedAt: Number(r.acked_at) } : {}),
-        };
-    }
-}
+export { MAX_RUN_BLOB_BYTES, slimOversizeRun, TiDBWorkflowRunStore, TiDBWorkflowCompletionInbox, TiDBWorkflowNotifyJournalStore, } from "./workflow-run-store-sql.js";
 //# sourceMappingURL=tidb-workflow-run-store.js.map

package/dist/plugins/tool-result-store-sql.d.ts

@@ -0,0 +1,25 @@
+import type { ToolResultStore, ToolResultSlice } from "@sema-agent/core";
+import type { Pool as MySqlPool } from "mysql2/promise";
+import type { Pool as PgPool, PoolClient as PgPoolClient } from "pg";
+import { type SqlDriver } from "./sql-driver.js";
+export declare const PG_TOOL_RESULT_SCHEMA: string[];
+export declare function ensureSchema(pool: PgPool | PgPoolClient): Promise<void>;
+export declare class SqlToolResultStore implements ToolResultStore {
+    protected readonly db: SqlDriver;
+    constructor(db: SqlDriver);
+    private q;
+    put(ref: string, content: string): Promise<void>;
+    get(ref: string, opts?: {
+        offset?: number;
+        limit?: number;
+    }): Promise<ToolResultSlice | undefined>;
+    reapOlderThan(cutoffMs: number): Promise<number>;
+    deleteBySession(sessionId: string): Promise<number>;
+}
+export declare class TiDBToolResultStore extends SqlToolResultStore {
+    constructor(pool: MySqlPool);
+}
+export declare class PgToolResultStore extends SqlToolResultStore {
+    constructor(pool: PgPool);
+}
+//# sourceMappingURL=tool-result-store-sql.d.ts.map

package/dist/plugins/tool-result-store-sql.js

@@ -0,0 +1,69 @@
+import { escapeLike } from "./sql-escape.js";
+import { pgSanitizeText } from "./pg-safe-json.js";
+import { mysqlDriver, pgDriver } from "./sql-driver.js";
+export const PG_TOOL_RESULT_SCHEMA = [
+    `CREATE TABLE IF NOT EXISTS tool_result (
+     ref        VARCHAR(190) NOT NULL,
+     content    TEXT         NOT NULL,
+     created_at TIMESTAMPTZ(3) NOT NULL,
+     PRIMARY KEY (ref)
+   )`,
+    `CREATE INDEX IF NOT EXISTS idx_tool_result_created ON tool_result (created_at)`,
+];
+export async function ensureSchema(pool) {
+    for (const stmt of PG_TOOL_RESULT_SCHEMA)
+        await pool.query(stmt);
+}
+export class SqlToolResultStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    q(tidb, pg) {
+        return this.db.dialect === "tidb" ? tidb : pg;
+    }
+    async put(ref, content) {
+        let safe = Buffer.from(content, "utf8").toString("utf8");
+        if (this.db.dialect === "pg")
+            safe = pgSanitizeText(safe);
+        await this.db.query(this.q("INSERT IGNORE INTO tool_result (ref, content, created_at) VALUES (?,?,?)", "INSERT INTO tool_result (ref, content, created_at) VALUES ($1,$2,$3) ON CONFLICT (ref) DO NOTHING"), [ref, safe, new Date()]);
+    }
+    async get(ref, opts = {}) {
+        const offset = Math.max(0, Math.floor(opts.offset ?? 0));
+        const hasLimit = opts.limit !== undefined && Number.isFinite(opts.limit);
+        const limit = hasLimit ? Math.max(0, Math.floor(opts.limit)) : 0;
+        const sql = hasLimit
+            ? this.q("SELECT SUBSTRING(content, ?, ?) AS slice, CHAR_LENGTH(content) AS total FROM tool_result WHERE ref = ?", "SELECT SUBSTRING(content FROM $1::int FOR $2::int) AS slice, CHAR_LENGTH(content) AS total FROM tool_result WHERE ref = $3")
+            : this.q("SELECT SUBSTRING(content, ?) AS slice, CHAR_LENGTH(content) AS total FROM tool_result WHERE ref = ?", "SELECT SUBSTRING(content FROM $1::int) AS slice, CHAR_LENGTH(content) AS total FROM tool_result WHERE ref = $2");
+        const params = hasLimit ? [offset + 1, limit, ref] : [offset + 1, ref];
+        const { rows } = await this.db.query(sql, params);
+        if (rows.length === 0)
+            return undefined;
+        return { content: String(rows[0].slice ?? ""), offset, totalChars: Number(rows[0].total) };
+    }
+    async reapOlderThan(cutoffMs) {
+        try {
+            const { affected } = await this.db.query(this.q("DELETE FROM tool_result WHERE created_at < ?", "DELETE FROM tool_result WHERE created_at < $1"), [new Date(cutoffMs)]);
+            return affected;
+        }
+        catch {
+            return 0;
+        }
+    }
+    async deleteBySession(sessionId) {
+        const prefix = `${escapeLike(`tr_${sessionId}_`)}%`;
+        const { affected } = await this.db.query(this.q("DELETE FROM tool_result WHERE ref LIKE ? ESCAPE '\\\\'", "DELETE FROM tool_result WHERE ref LIKE $1 ESCAPE '\\'"), [prefix]);
+        return affected;
+    }
+}
+export class TiDBToolResultStore extends SqlToolResultStore {
+    constructor(pool) {
+        super(mysqlDriver(pool));
+    }
+}
+export class PgToolResultStore extends SqlToolResultStore {
+    constructor(pool) {
+        super(pgDriver(pool));
+    }
+}
+//# sourceMappingURL=tool-result-store-sql.js.map

package/dist/plugins/workflow-journal-store-sql.d.ts

@@ -0,0 +1,30 @@
+import type { Pool as MySqlPool } from "mysql2/promise";
+import type { Pool as PgPool } from "pg";
+import { type WorkflowJournalEntry, type WorkflowJournalStore } from "@sema-agent/core";
+import { type SqlDriver } from "./sql-driver.js";
+export declare class SqlWorkflowJournalStore implements WorkflowJournalStore {
+    private readonly db;
+    constructor(db: SqlDriver);
+    private q;
+    append(runId: string, scope: string, entry: WorkflowJournalEntry): Promise<void>;
+    load(runId: string, scope: string): Promise<WorkflowJournalEntry[]>;
+    locator(runId: string, _scope: string): string;
+    loadPage(runId: string, scope: string, opts: {
+        offset: number;
+        limit: number;
+        maxResultBytes: number;
+    }): Promise<Array<{
+        callKey: string;
+        resultJson: string | null;
+        resultBytes: number;
+    }>>;
+    deleteByRun(runId: string): Promise<number>;
+    reapExpired(now: number, maxAgeMs: number): Promise<number>;
+}
+export declare class TiDBWorkflowJournalStore extends SqlWorkflowJournalStore {
+    constructor(pool: MySqlPool);
+}
+export declare class PgWorkflowJournalStore extends SqlWorkflowJournalStore {
+    constructor(pool: PgPool);
+}
+//# sourceMappingURL=workflow-journal-store-sql.d.ts.map

package/dist/plugins/workflow-journal-store-sql.js

@@ -0,0 +1,53 @@
+import { callKeyOrdinal } from "@sema-agent/core";
+import { oversizeJournalResult } from "./workflow-journal-limits.js";
+import { mysqlDriver, pgDriver } from "./sql-driver.js";
+export class SqlWorkflowJournalStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    q(tidb, pg) {
+        return this.db.dialect === "tidb" ? tidb : pg;
+    }
+    async append(runId, scope, entry) {
+        const serialized = JSON.stringify(entry.result);
+        if (oversizeJournalResult(serialized))
+            return;
+        await this.db.query(this.q("INSERT INTO workflow_journal (run_id, ordinal, scope, call_key, result, created_at) VALUES (?,?,?,?,?,?) " +
+            "ON DUPLICATE KEY UPDATE call_key = VALUES(call_key), result = VALUES(result)", "INSERT INTO workflow_journal (run_id, ordinal, scope, call_key, result, created_at) VALUES ($1,$2,$3,$4,$5,$6) " +
+            "ON CONFLICT (run_id, ordinal) DO UPDATE SET call_key = EXCLUDED.call_key, result = EXCLUDED.result"), [runId, callKeyOrdinal(entry.callKey), scope, entry.callKey, serialized, Date.now()]);
+    }
+    async load(runId, scope) {
+        const { rows } = await this.db.query(this.q("SELECT call_key, result FROM workflow_journal WHERE run_id = ? AND scope = ? ORDER BY ordinal ASC", "SELECT call_key, result FROM workflow_journal WHERE run_id = $1 AND scope = $2 ORDER BY ordinal ASC"), [runId, scope]);
+        return rows.map((r) => ({ callKey: String(r.call_key), result: JSON.parse(String(r.result)) }));
+    }
+    locator(runId, _scope) {
+        return `/v1/workflows/${runId}/journal`;
+    }
+    async loadPage(runId, scope, opts) {
+        const params = this.db.dialect === "tidb"
+            ? [opts.maxResultBytes, runId, scope, opts.limit, opts.offset]
+            : [runId, scope, opts.maxResultBytes, opts.limit, opts.offset];
+        const { rows } = await this.db.query(this.q("SELECT call_key, CASE WHEN LENGTH(result) > ? THEN NULL ELSE result END AS result_json, LENGTH(result) AS result_bytes FROM workflow_journal WHERE run_id = ? AND scope = ? ORDER BY ordinal ASC LIMIT ? OFFSET ?", "SELECT call_key, CASE WHEN OCTET_LENGTH(result) > $3 THEN NULL ELSE result END AS result_json, OCTET_LENGTH(result) AS result_bytes FROM workflow_journal WHERE run_id = $1 AND scope = $2 ORDER BY ordinal ASC LIMIT $4 OFFSET $5"), params);
+        return rows.map((r) => ({ callKey: String(r.call_key), resultJson: r.result_json === null ? null : String(r.result_json), resultBytes: Number(r.result_bytes) }));
+    }
+    async deleteByRun(runId) {
+        const res = await this.db.query(this.q("DELETE FROM workflow_journal WHERE run_id = ?", "DELETE FROM workflow_journal WHERE run_id = $1"), [runId]);
+        return res.affected;
+    }
+    async reapExpired(now, maxAgeMs) {
+        const res = await this.db.query(this.q("DELETE FROM workflow_journal WHERE created_at < ?", "DELETE FROM workflow_journal WHERE created_at < $1"), [now - maxAgeMs]);
+        return res.affected;
+    }
+}
+export class TiDBWorkflowJournalStore extends SqlWorkflowJournalStore {
+    constructor(pool) {
+        super(mysqlDriver(pool));
+    }
+}
+export class PgWorkflowJournalStore extends SqlWorkflowJournalStore {
+    constructor(pool) {
+        super(pgDriver(pool));
+    }
+}
+//# sourceMappingURL=workflow-journal-store-sql.js.map

package/dist/plugins/workflow-run-store-sql.d.ts

@@ -0,0 +1,85 @@
+import type { Pool as MySqlPool } from "mysql2/promise";
+import type { Pool as PgPool } from "pg";
+import { summarizeWorkflowRun, type WorkflowRunStore } from "@sema-agent/core";
+import { type WorkflowCompletionInbox, type WorkflowCompletionInboxEntry } from "../orchestration/workflow-completion-inbox.js";
+import type { WorkflowNotifyJournalStore, WorkflowNotifyJournalEntry } from "../orchestration/workflow-notify-journal.js";
+import { type SqlDriver } from "./sql-driver.js";
+type WorkflowRun = Parameters<WorkflowRunStore["put"]>[1];
+export declare const MAX_RUN_BLOB_BYTES: number;
+declare const onWarnType: (msg: string, meta: Record<string, unknown>) => void;
+export type InboxWarn = typeof onWarnType;
+export declare function slimOversizeRun(run: WorkflowRun & {
+    id: string;
+    scope: string;
+}, maxBytes: number): string | null;
+export declare class SqlWorkflowRunStore implements WorkflowRunStore {
+    protected readonly db: SqlDriver;
+    constructor(db: SqlDriver);
+    private q;
+    put(id: string, run: WorkflowRun): Promise<void>;
+    get(id: string): Promise<WorkflowRun | null>;
+    update(id: string, scope: string, run: WorkflowRun, expect?: {
+        rev: number;
+    }): Promise<boolean>;
+    listByScope(scope: string, opts?: {
+        status?: WorkflowRun["status"];
+        limit?: number;
+        session?: string;
+    }): Promise<ReturnType<typeof summarizeWorkflowRun>[]>;
+    reapAllScopes(now: number, opts: {
+        maxAgeMs?: number;
+        keep?: number;
+    }): Promise<number>;
+    reap(scope: string, now: number, opts?: {
+        maxAgeMs?: number;
+        keep?: number;
+    }): Promise<number>;
+}
+export declare class SqlWorkflowCompletionInbox implements WorkflowCompletionInbox {
+    protected readonly db: SqlDriver;
+    private readonly onWarn?;
+    constructor(db: SqlDriver, onWarn?: InboxWarn | undefined);
+    private q;
+    private sweepFences;
+    enqueue(entry: WorkflowCompletionInboxEntry): Promise<void>;
+    pending(sessionId: string): Promise<WorkflowCompletionInboxEntry[]>;
+    ack(sessionId: string, runId: string): Promise<void>;
+    purge(sessionId: string, purgedOwner?: string | null): Promise<void>;
+    markTerminalServed(sessionId: string, runId: string): Promise<void>;
+}
+export declare class SqlWorkflowNotifyJournalStore implements WorkflowNotifyJournalStore {
+    protected readonly db: SqlDriver;
+    constructor(db: SqlDriver);
+    private q;
+    record(input: {
+        runId: string;
+        scope: string;
+        sourceTaskId?: string;
+        principal?: string;
+        createdAt: number;
+    }): Promise<void>;
+    ack(runId: string, ackedAt: number): Promise<void>;
+    listPending(): Promise<WorkflowNotifyJournalEntry[]>;
+    reapAcked(before: number): Promise<number>;
+    get(runId: string): Promise<WorkflowNotifyJournalEntry | null>;
+}
+export declare class TiDBWorkflowRunStore extends SqlWorkflowRunStore {
+    constructor(pool: MySqlPool);
+}
+export declare class TiDBWorkflowCompletionInbox extends SqlWorkflowCompletionInbox {
+    constructor(pool: MySqlPool, onWarn?: InboxWarn);
+}
+export declare class TiDBWorkflowNotifyJournalStore extends SqlWorkflowNotifyJournalStore {
+    constructor(pool: MySqlPool);
+}
+export declare class PgWorkflowRunStore extends SqlWorkflowRunStore {
+    constructor(pool: PgPool);
+}
+export declare class PgWorkflowCompletionInbox extends SqlWorkflowCompletionInbox {
+    constructor(pool: PgPool, onWarn?: InboxWarn);
+}
+export declare class PgWorkflowNotifyJournalStore extends SqlWorkflowNotifyJournalStore {
+    constructor(pool: PgPool);
+}
+export {};
+//# sourceMappingURL=workflow-run-store-sql.d.ts.map