@sema-agent/server 1.315.0 → 1.316.0

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

@@ -1,53 +1,2 @@
-import { escapeLike } from "./sql-escape.js";
-import { pgSanitizeText } from "./pg-safe-json.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 PgToolResultStore {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async put(ref, content) {
-        const safe = pgSanitizeText(Buffer.from(content, "utf8").toString("utf8"));
-        await this.pool.query("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
-            ? "SELECT SUBSTRING(content FROM $1::int FOR $2::int) AS slice, CHAR_LENGTH(content) AS total FROM tool_result WHERE ref = $3"
-            : "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 res = await this.pool.query(sql, params);
-        if (res.rows.length === 0)
-            return undefined;
-        return { content: String(res.rows[0].slice ?? ""), offset, totalChars: Number(res.rows[0].total) };
-    }
-    async reapOlderThan(cutoffMs) {
-        try {
-            const res = await this.pool.query("DELETE FROM tool_result WHERE created_at < $1", [new Date(cutoffMs)]);
-            return res.rowCount ?? 0;
-        }
-        catch {
-            return 0;
-        }
-    }
-    async deleteBySession(sessionId) {
-        const prefix = `${escapeLike(`tr_${sessionId}_`)}%`;
-        const res = await this.pool.query("DELETE FROM tool_result WHERE ref LIKE $1 ESCAPE '\\'", [prefix]);
-        return res.rowCount ?? 0;
-    }
-}
+export { PgToolResultStore, PG_TOOL_RESULT_SCHEMA, ensureSchema } from "./tool-result-store-sql.js";
 //# sourceMappingURL=pg-tool-result-store.js.map

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

@@ -1,21 +1,2 @@
-import type { Pool } from "pg";
-import { type WorkflowJournalEntry, type WorkflowJournalStore } from "@sema-agent/core";
-export declare class PgWorkflowJournalStore implements WorkflowJournalStore {
-    private readonly pool;
-    constructor(pool: Pool);
-    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 { PgWorkflowJournalStore } from "./workflow-journal-store-sql.js";
 //# sourceMappingURL=pg-workflow-journal-store.d.ts.map

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

@@ -1,35 +1,2 @@
-import { callKeyOrdinal } from "@sema-agent/core";
-import { oversizeJournalResult } from "./workflow-journal-limits.js";
-export class PgWorkflowJournalStore {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async append(runId, scope, entry) {
-        const serialized = JSON.stringify(entry.result);
-        if (oversizeJournalResult(serialized))
-            return;
-        await this.pool.query("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 r = await this.pool.query("SELECT call_key, result FROM workflow_journal WHERE run_id = $1 AND scope = $2 ORDER BY ordinal ASC", [runId, scope]);
-        return r.rows.map((row) => ({ callKey: String(row.call_key), result: JSON.parse(String(row.result)) }));
-    }
-    locator(runId, _scope) {
-        return `/v1/workflows/${runId}/journal`;
-    }
-    async loadPage(runId, scope, opts) {
-        const r = await this.pool.query("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", [runId, scope, opts.maxResultBytes, opts.limit, opts.offset]);
-        return r.rows.map((row) => ({ callKey: String(row.call_key), resultJson: row.result_json === null ? null : String(row.result_json), resultBytes: Number(row.result_bytes) }));
-    }
-    async deleteByRun(runId) {
-        const r = await this.pool.query("DELETE FROM workflow_journal WHERE run_id = $1", [runId]);
-        return r.rowCount ?? 0;
-    }
-    async reapExpired(now, maxAgeMs) {
-        const r = await this.pool.query("DELETE FROM workflow_journal WHERE created_at < $1", [now - maxAgeMs]);
-        return r.rowCount ?? 0;
-    }
-}
+export { PgWorkflowJournalStore } from "./workflow-journal-store-sql.js";
 //# sourceMappingURL=pg-workflow-journal-store.js.map

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

@@ -1,56 +1,2 @@
-import type { Pool } 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 InboxWarn } from "./tidb-workflow-run-store.js";
-type WorkflowRun = Parameters<WorkflowRunStore["put"]>[1];
-export declare class PgWorkflowRunStore 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 PgWorkflowCompletionInbox 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 PgWorkflowNotifyJournalStore 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 { PgWorkflowRunStore, PgWorkflowCompletionInbox, PgWorkflowNotifyJournalStore } from "./workflow-run-store-sql.js";
 //# sourceMappingURL=pg-workflow-run-store.d.ts.map

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

@@ -1,221 +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";
-import { MAX_RUN_BLOB_BYTES, slimOversizeRun } from "./tidb-workflow-run-store.js";
-export class PgWorkflowRunStore {
-    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 ($1,$2,$3,$4,$5,$6,$7)", [id, run.scope, run.status, JSON.stringify(stored), stored.rev, run.createdAt, run.endedAt ?? null]);
-        }
-        catch (e) {
-            if (e.code === "23505") {
-                throw new WorkflowRunStoreError("workflow_run.already_exists", "workflow run id already exists");
-            }
-            throw e;
-        }
-    }
-    async get(id) {
-        const res = await this.pool.query("SELECT run, rev FROM workflow_run WHERE id = $1", [id]);
-        const r = res.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 = $1, rev = rev + 1, status = $2, ended_at = $3 WHERE id = $4 AND scope = $5${expect !== undefined ? " AND rev = $6" : ""}`, expect !== undefined ? [blob, run.status, run.endedAt ?? null, id, scope, expect.rev] : [blob, run.status, run.endedAt ?? null, id, scope]);
-        return res.rowCount === 1;
-    }
-    async listByScope(scope, opts) {
-        const params = [scope];
-        let where = "scope = $1";
-        if (opts?.status !== undefined) {
-            params.push(opts.status);
-            where += ` AND status = $${params.length}`;
-        }
-        if (opts?.session !== undefined) {
-            params.push(opts.session);
-            where += ` AND run::json->>'originatingSessionId' = $${params.length}`;
-        }
-        let limit = "";
-        if (opts?.limit !== undefined) {
-            params.push(Math.max(0, opts.limit));
-            limit = ` LIMIT $${params.length}`;
-        }
-        const res = await this.pool.query(`SELECT run, rev FROM workflow_run WHERE ${where} ORDER BY created_at DESC, id DESC${limit}`, params);
-        return res.rows.map((r) => {
-            const run = JSON.parse(String(r.run));
-            run.rev = Number(r.rev);
-            return summarizeWorkflowRun(run);
-        });
-    }
-    async reapAllScopes(now, opts) {
-        const res = await this.pool.query("SELECT DISTINCT scope FROM workflow_run");
-        let total = 0;
-        for (const r of res.rows)
-            total += await this.reap(r.scope, now, opts);
-        return total;
-    }
-    async reap(scope, now, opts) {
-        if (opts?.maxAgeMs === undefined && opts?.keep === undefined)
-            return 0;
-        const res = await this.pool.query("SELECT id, status, created_at, ended_at FROM workflow_run WHERE scope = $1 ORDER BY created_at DESC, id DESC", [scope]);
-        const rows = res.rows;
-        const terminal = rows.filter((r) => isTerminalWorkflowStatus(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(r.id);
-        }
-        if (doomed.length === 0)
-            return 0;
-        const del = await this.pool.query(`DELETE FROM workflow_run WHERE scope = $1 AND id = ANY($2::text[])`, [scope, doomed]);
-        return del.rowCount ?? 0;
-    }
-}
-const KIND_SERVED = "served";
-const KIND_PURGE = "purge";
-export class PgWorkflowCompletionInbox {
-    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 < $1", [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 = $1 AND kind = $2 AND run_id IN ($3, $4) AND until_ms >= $5", [entry.sessionId, KIND_SERVED, entry.runId, foldKeyFamily(entry.runId), now]);
-        if ((served.rowCount ?? 0) > 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 = $1 AND kind = $2 AND run_id = '' AND until_ms >= $3", [entry.sessionId, KIND_PURGE, now]);
-        const pf = purge.rows[0];
-        if (pf && (Number(pf.owner_known) === 0 || (pf.owner === null ? entry.owner === null : pf.owner === entry.owner))) {
-            this.onWarn?.("workflow_completion_enqueue_after_purge", { sessionId: entry.sessionId, runId: entry.runId });
-            return;
-        }
-        await this.pool.query("INSERT INTO workflow_completion_inbox (session_id, run_id, owner, status, summary, enqueued_at, kind, payload) VALUES ($1,$2,$3,$4,$5,$6,$7,$8) " +
-            "ON CONFLICT (session_id, run_id) DO UPDATE SET seq = nextval(pg_get_serial_sequence('workflow_completion_inbox','seq')), " +
-            "owner = EXCLUDED.owner, status = EXCLUDED.status, summary = EXCLUDED.summary, enqueued_at = EXCLUDED.enqueued_at, kind = EXCLUDED.kind, payload = EXCLUDED.payload", [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 = $1 AND until_ms >= $2 AND (run_id IN ($3, $4) OR (kind = $5 AND run_id = ''))", [entry.sessionId, now, entry.runId, foldKeyFamily(entry.runId), KIND_PURGE]);
-        for (const f of confirm.rows) {
-            const isServed = f.kind === KIND_SERVED;
-            const purgeFencesUs = !isServed && (Number(f.owner_known) === 0 || (f.owner === null ? entry.owner === null : 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 = $1 ORDER BY seq DESC OFFSET $2", [entry.sessionId, MAX_PENDING_PER_SESSION]);
-        const overRows = over.rows;
-        if (overRows.length > 0) {
-            await this.pool.query("DELETE FROM workflow_completion_inbox WHERE session_id = $1 AND seq = ANY($2::bigint[])", [
-                entry.sessionId,
-                overRows.map((r) => r.seq),
-            ]);
-            for (const r of overRows)
-                this.onWarn?.("workflow_completion_inbox_overflow", { sessionId: entry.sessionId, droppedRunId: r.run_id });
-        }
-    }
-    async pending(sessionId) {
-        const res = 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 = $1 AND NOT EXISTS (SELECT 1 FROM workflow_inbox_fence f WHERE f.session_id = i.session_id AND f.kind = $2 AND f.run_id IN (i.run_id, regexp_replace(i.run_id, '#[0-9]+$', '')) AND f.until_ms >= $3) " +
-            "ORDER BY i.seq ASC", [sessionId, KIND_SERVED, Date.now()]);
-        return res.rows.map((r) => ({
-            sessionId,
-            runId: r.run_id,
-            owner: r.owner,
-            status: r.status,
-            summary: r.summary,
-            enqueuedAt: Number(r.enqueued_at),
-            ...(r.kind != null ? { kind: r.kind } : {}),
-            ...(r.payload != null ? { payload: r.payload } : {}),
-        }));
-    }
-    async ack(sessionId, runId) {
-        await this.pool.query("DELETE FROM workflow_completion_inbox WHERE session_id = $1 AND run_id = $2", [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 ($1,$2,'',$3,$4,$5) " +
-            "ON CONFLICT (session_id, kind, run_id) DO UPDATE SET owner = EXCLUDED.owner, owner_known = EXCLUDED.owner_known, until_ms = EXCLUDED.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 = $1", [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 ($1,$2,$3,NULL,0,$4) " +
-            "ON CONFLICT (session_id, kind, run_id) DO UPDATE SET until_ms = EXCLUDED.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 = $1 AND run_id <> $2 AND regexp_replace(run_id, '#[0-9]+$', '') = $3", [sessionId, runId, runId]);
-    }
-}
-export class PgWorkflowNotifyJournalStore {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async record(input) {
-        await this.pool.query("INSERT INTO workflow_notify_journal (run_id, scope, acked, source_task_id, principal, created_at) VALUES ($1,$2,0,$3,$4,$5) ON CONFLICT (run_id) DO NOTHING", [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 = $1 WHERE run_id = $2 AND acked = 0", [ackedAt, runId]);
-    }
-    async listPending() {
-        const res = await this.pool.query("SELECT run_id, scope, source_task_id, principal, created_at FROM workflow_notify_journal WHERE acked = 0");
-        return res.rows.map((r) => ({
-            runId: r.run_id,
-            scope: r.scope,
-            acked: false,
-            ...(r.source_task_id != null ? { sourceTaskId: r.source_task_id } : {}),
-            ...(r.principal != null ? { principal: 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 < $1", [before]);
-        return res.rowCount ?? 0;
-    }
-    async get(runId) {
-        const res = await this.pool.query("SELECT run_id, scope, acked, source_task_id, principal, created_at, acked_at FROM workflow_notify_journal WHERE run_id = $1", [runId]);
-        const r = res.rows[0];
-        if (!r)
-            return null;
-        return {
-            runId: r.run_id,
-            scope: r.scope,
-            acked: Number(r.acked) === 1,
-            ...(r.source_task_id != null ? { sourceTaskId: r.source_task_id } : {}),
-            ...(r.principal != null ? { principal: r.principal } : {}),
-            createdAt: Number(r.created_at),
-            ...(r.acked_at != null ? { ackedAt: Number(r.acked_at) } : {}),
-        };
-    }
-}
+export { PgWorkflowRunStore, PgWorkflowCompletionInbox, PgWorkflowNotifyJournalStore } from "./workflow-run-store-sql.js";
 //# sourceMappingURL=pg-workflow-run-store.js.map

package/dist/plugins/resume-anchor-store-sql.d.ts

@@ -0,0 +1,23 @@
+import type { Pool as MySqlPool } from "mysql2/promise";
+import type { Pool as PgPool } from "pg";
+import { type SqlDriver } from "./sql-driver.js";
+export declare class SqlResumeAnchorStore {
+    protected readonly db: SqlDriver;
+    constructor(db: SqlDriver);
+    private q;
+    put(sessionId: string, eventId: string, entryId: string, owner: string | null): Promise<void>;
+    resolve(sessionId: string, eventId: string, owner: string | null): Promise<string | undefined>;
+    listBySession(sessionId: string): Promise<Array<{
+        eventId: string;
+        entryId: string;
+        owner: string | null;
+    }>>;
+    deleteBySession(sessionId: string): Promise<number>;
+}
+export declare class TiDBResumeAnchorStore extends SqlResumeAnchorStore {
+    constructor(pool: MySqlPool);
+}
+export declare class PgResumeAnchorStore extends SqlResumeAnchorStore {
+    constructor(pool: PgPool);
+}
+//# sourceMappingURL=resume-anchor-store-sql.d.ts.map

package/dist/plugins/resume-anchor-store-sql.js

@@ -0,0 +1,38 @@
+import { mysqlDriver, pgDriver } from "./sql-driver.js";
+export class SqlResumeAnchorStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    q(tidb, pg) {
+        return this.db.dialect === "tidb" ? tidb : pg;
+    }
+    async put(sessionId, eventId, entryId, owner) {
+        await this.db.query(this.q("INSERT INTO resume_anchor (session_id, event_id, entry_id, owner, created_at) VALUES (?,?,?,?,?) " +
+            "ON DUPLICATE KEY UPDATE entry_id = VALUES(entry_id), owner = VALUES(owner)", "INSERT INTO resume_anchor (session_id, event_id, entry_id, owner, created_at) VALUES ($1,$2,$3,$4,$5) " +
+            "ON CONFLICT (session_id, event_id) DO UPDATE SET entry_id = EXCLUDED.entry_id, owner = EXCLUDED.owner"), [sessionId, eventId, entryId, owner, new Date()]);
+    }
+    async resolve(sessionId, eventId, owner) {
+        const { rows } = await this.db.query(this.q("SELECT entry_id FROM resume_anchor WHERE session_id = ? AND event_id = ? AND owner <=> ?", "SELECT entry_id FROM resume_anchor WHERE session_id = $1 AND event_id = $2 AND owner IS NOT DISTINCT FROM $3"), [sessionId, eventId, owner]);
+        return rows[0] ? String(rows[0].entry_id) : undefined;
+    }
+    async listBySession(sessionId) {
+        const { rows } = await this.db.query(this.q("SELECT event_id, entry_id, owner FROM resume_anchor WHERE session_id = ?", "SELECT event_id, entry_id, owner FROM resume_anchor WHERE session_id = $1"), [sessionId]);
+        return rows.map((r) => ({ eventId: String(r.event_id), entryId: String(r.entry_id), owner: r.owner == null ? null : String(r.owner) }));
+    }
+    async deleteBySession(sessionId) {
+        const res = await this.db.query(this.q("DELETE FROM resume_anchor WHERE session_id = ?", "DELETE FROM resume_anchor WHERE session_id = $1"), [sessionId]);
+        return res.affected;
+    }
+}
+export class TiDBResumeAnchorStore extends SqlResumeAnchorStore {
+    constructor(pool) {
+        super(mysqlDriver(pool));
+    }
+}
+export class PgResumeAnchorStore extends SqlResumeAnchorStore {
+    constructor(pool) {
+        super(pgDriver(pool));
+    }
+}
+//# sourceMappingURL=resume-anchor-store-sql.js.map

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

@@ -0,0 +1,89 @@
+import type { TaskResult, TaskStatus } from "@sema-agent/core";
+import type { Pool as MySqlPool } from "mysql2/promise";
+import type { Pool as PgPool } from "pg";
+import { type UsageRow } from "../usage-analytics.js";
+import type { RunRecord, SessionSummary, RunEvent } from "./store-contracts.js";
+import { type SqlDriver } from "./sql-driver.js";
+export type { RunRecord, SessionSummary, RunEvent } from "./store-contracts.js";
+export declare class SqlRunStore {
+    protected readonly db: SqlDriver;
+    constructor(db: SqlDriver);
+    private q;
+    private isDupKey;
+    private json;
+    private tx;
+    createRun(taskId: string, sessionId: string, owner: string | null, instanceId: string, meta?: {
+        jobId?: string | null;
+        source?: string | null;
+        objectivePreview?: string | null;
+    }): Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        activeTaskId: string;
+    }>;
+    requestCancel(taskId: string, owner: string | null): Promise<boolean>;
+    isCancelRequested(taskId: string, owner: string | null): Promise<boolean>;
+    requestPreempt(taskId: string, owner: string | null): Promise<boolean>;
+    isPreemptRequested(taskId: string, owner: string | null): Promise<boolean>;
+    heartbeat(taskId: string, owner: string | null): Promise<void>;
+    appendEvent(taskId: string, seq: number, type: string, data: unknown): Promise<void>;
+    maxSeq(taskId: string): Promise<number>;
+    setTerminal(taskId: string, status: TaskStatus, result: TaskResult | null, error: string | null): Promise<void>;
+    setSuspended(taskId: string): Promise<void>;
+    setNeedsReview(taskId: string): Promise<void>;
+    markResuming(taskId: string): Promise<boolean>;
+    getActiveTaskId(sessionId: string): Promise<string | undefined>;
+    private rowToRun;
+    getRun(taskId: string): Promise<RunRecord | undefined>;
+    listRuns(opts: {
+        status?: string;
+        jobId?: string;
+        source?: string;
+        owner?: string;
+        cursor?: {
+            createdAt: string;
+            taskId: string;
+        };
+        limit: number;
+    }): Promise<RunRecord[]>;
+    listSessions(opts: {
+        owner?: string;
+        cursor?: {
+            lastActivityAt: string;
+            sessionId: string;
+        };
+        limit: number;
+        q?: string;
+    }): Promise<SessionSummary[]>;
+    private rowToSession;
+    deleteBySession(sessionId: string, owner: string | null): Promise<{
+        removed: number;
+    } | {
+        active: string;
+    }>;
+    sourceSummary(sinceMs: number): Promise<Array<{
+        source: string | null;
+        status: string;
+        count: number;
+    }>>;
+    usageScan(fromMs: number, toMs: number, opts?: {
+        owner?: string;
+        limit?: number;
+    }): Promise<{
+        rows: UsageRow[];
+        truncated: boolean;
+    }>;
+    retainedFrom(taskId: string): Promise<number>;
+    getEvents(taskId: string, afterSeq: number): Promise<RunEvent[]>;
+    reapStale(olderThanMs: number): Promise<number>;
+    reapSuspended(olderThanMs: number): Promise<number>;
+    failSuspendedWithExpiredCheckpoint(): Promise<number>;
+}
+export declare class TiDBRunStore extends SqlRunStore {
+    constructor(pool: MySqlPool);
+}
+export declare class PgRunStore extends SqlRunStore {
+    constructor(pool: PgPool);
+}
+//# sourceMappingURL=run-store-sql.d.ts.map