@sema-agent/server 1.315.0 → 1.317.0

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

@@ -0,0 +1,299 @@
+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 { mysqlDriver, pgDriver } from "./sql-driver.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 SqlWorkflowRunStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    q(tidb, pg) {
+        return this.db.dialect === "tidb" ? tidb : pg;
+    }
+    async put(id, run) {
+        const stored = { ...run, id, rev: run.rev ?? 0 };
+        try {
+            await this.db.query(this.q("INSERT INTO workflow_run (id, scope, status, run, rev, created_at, ended_at) VALUES (?,?,?,?,?,?,?)", "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) {
+            const isDupKey = this.db.dialect === "tidb" ? e.code === "ER_DUP_ENTRY" : e.code === "23505";
+            if (isDupKey) {
+                throw new WorkflowRunStoreError("workflow_run.already_exists", "workflow run id already exists");
+            }
+            throw e;
+        }
+    }
+    async get(id) {
+        const { rows } = await this.db.query(this.q("SELECT run, rev FROM workflow_run WHERE id = ?", "SELECT run, rev FROM workflow_run WHERE id = $1"), [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.db.query(this.q(`UPDATE workflow_run SET run = ?, rev = rev + 1, status = ?, ended_at = ? WHERE id = ? AND scope = ?${expect !== undefined ? " AND rev = ?" : ""}`, `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.affected === 1;
+    }
+    async listByScope(scope, opts) {
+        const params = [scope];
+        let where;
+        let limit = "";
+        if (this.db.dialect === "tidb") {
+            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);
+            }
+            if (opts?.limit !== undefined) {
+                limit = " LIMIT ?";
+                params.push(Math.max(0, opts.limit));
+            }
+        }
+        else {
+            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}`;
+            }
+            if (opts?.limit !== undefined) {
+                params.push(Math.max(0, opts.limit));
+                limit = ` LIMIT $${params.length}`;
+            }
+        }
+        const { rows } = await this.db.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.db.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.db.query(this.q("SELECT id, status, created_at, ended_at FROM workflow_run WHERE scope = ? ORDER BY created_at DESC, id DESC", "SELECT id, status, created_at, ended_at FROM workflow_run WHERE scope = $1 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.db.query(this.q(`DELETE FROM workflow_run WHERE scope = ? AND id IN (${doomed.map(() => "?").join(",")})`, "DELETE FROM workflow_run WHERE scope = $1 AND id = ANY($2::text[])"), this.db.dialect === "tidb" ? [scope, ...doomed] : [scope, doomed]);
+        return res.affected;
+    }
+}
+const KIND_SERVED = "served";
+const KIND_PURGE = "purge";
+export class SqlWorkflowCompletionInbox {
+    db;
+    onWarn;
+    constructor(db, onWarn) {
+        this.db = db;
+        this.onWarn = onWarn;
+    }
+    q(tidb, pg) {
+        return this.db.dialect === "tidb" ? tidb : pg;
+    }
+    async sweepFences(now) {
+        await this.db.query(this.q("DELETE FROM workflow_inbox_fence WHERE until_ms < ?", "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.db.query(this.q("SELECT 1 FROM workflow_inbox_fence WHERE session_id = ? AND kind = ? AND run_id IN (?, ?) AND until_ms >= ?", "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.rows.length > 0) {
+            this.onWarn?.("workflow_completion_enqueue_after_poll_served", { sessionId: entry.sessionId, runId: entry.runId });
+            return;
+        }
+        const purge = await this.db.query(this.q("SELECT owner, owner_known FROM workflow_inbox_fence WHERE session_id = ? AND kind = ? AND run_id = '' AND until_ms >= ?", "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 : String(pf.owner) === entry.owner))) {
+            this.onWarn?.("workflow_completion_enqueue_after_purge", { sessionId: entry.sessionId, runId: entry.runId });
+            return;
+        }
+        await this.db.query(this.q("REPLACE INTO workflow_completion_inbox (session_id, run_id, owner, status, summary, enqueued_at, kind, payload) VALUES (?,?,?,?,?,?,?,?)", "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.db.query(this.q("SELECT kind, owner, owner_known FROM workflow_inbox_fence WHERE session_id = ? AND until_ms >= ? AND (run_id IN (?, ?) OR (kind = ? AND run_id = ''))", "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 = 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.db.query(this.q("SELECT seq, run_id FROM workflow_completion_inbox WHERE session_id = ? ORDER BY seq DESC LIMIT 100000 OFFSET ?", "SELECT seq, run_id FROM workflow_completion_inbox WHERE session_id = $1 ORDER BY seq DESC OFFSET $2"), [entry.sessionId, MAX_PENDING_PER_SESSION]);
+        if (over.rows.length > 0) {
+            await this.db.query(this.q(`DELETE FROM workflow_completion_inbox WHERE session_id = ? AND seq IN (${over.rows.map(() => "?").join(",")})`, "DELETE FROM workflow_completion_inbox WHERE session_id = $1 AND seq = ANY($2::bigint[])"), this.db.dialect === "tidb" ? [entry.sessionId, ...over.rows.map((r) => r.seq)] : [entry.sessionId, over.rows.map((r) => r.seq)]);
+            for (const r of over.rows)
+                this.onWarn?.("workflow_completion_inbox_overflow", { sessionId: entry.sessionId, droppedRunId: String(r.run_id) });
+        }
+    }
+    async pending(sessionId) {
+        const { rows } = await this.db.query(this.q("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", "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 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.db.query(this.q("DELETE FROM workflow_completion_inbox WHERE session_id = ? AND run_id = ?", "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.db.query(this.q("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)", "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"), this.db.dialect === "tidb"
+            ? [sessionId, KIND_PURGE, "", purgedOwner ?? null, purgedOwner !== undefined ? 1 : 0, now + PURGE_FENCE_MS]
+            : [sessionId, KIND_PURGE, purgedOwner ?? null, purgedOwner !== undefined ? 1 : 0, now + PURGE_FENCE_MS]);
+        await this.db.query(this.q("DELETE FROM workflow_completion_inbox WHERE session_id = ?", "DELETE FROM workflow_completion_inbox WHERE session_id = $1"), [sessionId]);
+    }
+    async markTerminalServed(sessionId, runId) {
+        const now = Date.now();
+        await this.sweepFences(now);
+        await this.db.query(this.q("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)", "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.db.query(this.q("DELETE FROM workflow_completion_inbox WHERE session_id = ? AND run_id <> ? AND REGEXP_REPLACE(run_id, '#[0-9]+$', '') = ?", "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 SqlWorkflowNotifyJournalStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    q(tidb, pg) {
+        return this.db.dialect === "tidb" ? tidb : pg;
+    }
+    async record(input) {
+        await this.db.query(this.q("INSERT IGNORE INTO workflow_notify_journal (run_id, scope, acked, source_task_id, principal, created_at) VALUES (?,?,0,?,?,?)", "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.db.query(this.q("UPDATE workflow_notify_journal SET acked = 1, acked_at = ? WHERE run_id = ? AND acked = 0", "UPDATE workflow_notify_journal SET acked = 1, acked_at = $1 WHERE run_id = $2 AND acked = 0"), [ackedAt, runId]);
+    }
+    async listPending() {
+        const { rows } = await this.db.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.db.query(this.q("DELETE FROM workflow_notify_journal WHERE acked = 1 AND acked_at < ?", "DELETE FROM workflow_notify_journal WHERE acked = 1 AND acked_at < $1"), [before]);
+        return res.affected;
+    }
+    async get(runId) {
+        const { rows } = await this.db.query(this.q("SELECT run_id, scope, acked, source_task_id, principal, created_at, acked_at FROM workflow_notify_journal WHERE run_id = ?", "SELECT run_id, scope, acked, source_task_id, principal, created_at, acked_at FROM workflow_notify_journal WHERE run_id = $1"), [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 class TiDBWorkflowRunStore extends SqlWorkflowRunStore {
+    constructor(pool) {
+        super(mysqlDriver(pool));
+    }
+}
+export class TiDBWorkflowCompletionInbox extends SqlWorkflowCompletionInbox {
+    constructor(pool, onWarn) {
+        super(mysqlDriver(pool), onWarn);
+    }
+}
+export class TiDBWorkflowNotifyJournalStore extends SqlWorkflowNotifyJournalStore {
+    constructor(pool) {
+        super(mysqlDriver(pool));
+    }
+}
+export class PgWorkflowRunStore extends SqlWorkflowRunStore {
+    constructor(pool) {
+        super(pgDriver(pool));
+    }
+}
+export class PgWorkflowCompletionInbox extends SqlWorkflowCompletionInbox {
+    constructor(pool, onWarn) {
+        super(pgDriver(pool), onWarn);
+    }
+}
+export class PgWorkflowNotifyJournalStore extends SqlWorkflowNotifyJournalStore {
+    constructor(pool) {
+        super(pgDriver(pool));
+    }
+}
+//# sourceMappingURL=workflow-run-store-sql.js.map

package/dist/question.js

@@ -118,10 +118,10 @@ export class QuestionCoordinator {
     respond(id, principal, body) {
         const parsed = parseQuestionResponse(body);
         if (!parsed.ok)
-            return { status: 400, body: { error: parsed.error } };
+            return { status: 400, body: { error: parsed.error, errorCode: "request.body_shape" } };
         const entry = this.pending.get(id);
         if (!entry || (entry.owner !== null && entry.owner !== principal)) {
-            return { status: 404, body: { error: "no pending question for this id (answered, expired, or not on this replica)" } };
+            return { status: 404, body: { error: "no pending question for this id (answered, expired, or not on this replica)", errorCode: "question.not_pending" } };
         }
         entry.settle(parsed.value, "answered");
         return { status: 200, body: { questionId: id, delivery: "applied" } };

package/dist/run-local.js

@@ -254,7 +254,7 @@ export async function runLocal(argv, deps = {}) {
         toolResultStore: fileBackend.toolResultStore,
         ...(executionEnvFactory ? { executionEnvFactory } : {}),
         ...(lspManager ? { lspManager } : {}),
-        ...(!config.projectMemoryDisabled
+        ...(config.projectMemoryEnabled
             ? { loadProjectMemory: makeLoadProjectMemory({ logger }), probeInstructionSources: makeProbeInstructionSources() }
             : {}),
     });

package/dist/tool-approval.js

@@ -211,10 +211,10 @@ export class ToolApprovalCoordinator {
     respond(id, principal, body) {
         const parsed = parseToolApprovalResponse(body);
         if (!parsed.ok)
-            return { status: 400, body: { error: parsed.error } };
+            return { status: 400, body: { error: parsed.error, errorCode: "request.body_shape" } };
         const entry = this.pending.get(id);
         if (!entry || (entry.owner !== null && entry.owner !== principal)) {
-            return { status: 404, body: { error: "no pending tool approval for this id (settled, expired, or not on this replica)" } };
+            return { status: 404, body: { error: "no pending tool approval for this id (settled, expired, or not on this replica)", errorCode: "tool_approval.not_pending" } };
         }
         let rememberApplied;
         if (parsed.value === "allow_session")

package/dist/trace/ledger-sink.js

@@ -45,7 +45,7 @@ export function createLedgerSink(opts) {
                 break;
             case "status":
                 await flush();
-                await append("brain_status", brainStatusEventData(ev));
+                await append("status", brainStatusEventData(ev));
                 break;
             case "context_usage":
                 await flush();

package/dist/trace/project.d.ts

@@ -221,6 +221,7 @@ export interface TaskSummary {
     };
 }
 export declare function runSummary(run: RunRecord, latestEventType?: string): TaskSummary;
+export declare function normalizeRunEventType(type: string): string;
 export declare function mapTraceEvent(type: string, seq: number, data: Record<string, unknown>): {
     event: string;
     data: Record<string, unknown>;

package/dist/trace/project.js

@@ -299,6 +299,9 @@ export function runSummary(run, latestEventType) {
         lastStep: lastStep(latestEventType, run.status),
     };
 }
+export function normalizeRunEventType(type) {
+    return type === "brain_status" ? "status" : type;
+}
 export function mapTraceEvent(type, seq, data) {
     switch (type) {
         case "reasoning":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "1.315.0",
+  "version": "1.317.0",
   "description": "Sema Server — the server/API implementation layer for Sema, wiring core, registry, model providers, and cloud agent execution. Built on @sema-agent/core.",
   "type": "module",
   "license": "BUSL-1.1",