@sema-agent/server 1.314.0 → 1.316.0

package/dist/plugins/pg-outcome-ledger.d.ts

@@ -1,23 +1,3 @@
-import type { Pool, PoolClient } from "pg";
-import { type TaskOutcome, type RunStatus } from "./tidb-outcome-ledger.js";
-import type { TaskOutcome as CoreTaskOutcome } from "@sema-agent/core";
-export declare const PG_OUTCOME_LEDGER_SCHEMA: string[];
-export declare function ensureSchema(pool: Pool | PoolClient): Promise<void>;
-export declare class PgOutcomeLedger {
-    private readonly pool;
-    constructor(pool: Pool);
-    record(o: TaskOutcome): Promise<string>;
-    recordCore(o: CoreTaskOutcome): Promise<void>;
-    summary(opts?: {
-        taskSignature?: string;
-        includeAborted?: boolean;
-    }): Promise<Array<{
-        taskSignature: string;
-        model: string;
-        n: number;
-        passRate: number;
-        meanCostMicroUsd: number;
-    }>>;
-}
-export type { TaskOutcome, RunStatus };
+export { PgOutcomeLedger, PG_OUTCOME_LEDGER_SCHEMA, ensurePgOutcomeLedgerSchema as ensureSchema, } from "./outcome-ledger-sql.js";
+export type { TaskOutcome, RunStatus } from "./outcome-ledger-sql.js";
 //# sourceMappingURL=pg-outcome-ledger.d.ts.map

package/dist/plugins/pg-outcome-ledger.js

@@ -1,105 +1,2 @@
-import { randomUUID } from "node:crypto";
-import { taskSignature, deriveOutcome, } from "./tidb-outcome-ledger.js";
-import { coreOutcomeToLedgerRow } from "./tidb-outcome-ledger.js";
-import { pgSafeJsonStringify } from "./pg-safe-json.js";
-export const PG_OUTCOME_LEDGER_SCHEMA = [
-    `CREATE TABLE IF NOT EXISTS outcome_ledger (
-     id             VARCHAR(64)  NOT NULL,
-     task_signature VARCHAR(190) NOT NULL,
-     model          VARCHAR(190) NOT NULL,
-     task_id        VARCHAR(64),
-     run_status     VARCHAR(20)  NOT NULL DEFAULT 'completed-graded',
-     route          VARCHAR(16),
-     worker_count   INTEGER,
-     oracle_passed  INTEGER,
-     oracle_total   INTEGER,
-     assemble_exit  INTEGER,
-     lint_exit      INTEGER,
-     merge_ok       SMALLINT,
-     replan_triggers JSONB,
-     cost_micro_usd BIGINT,
-     turns          INTEGER,
-     outcome        VARCHAR(8),
-     llm_assisted   JSONB,
-     signature_inputs JSONB,
-     -- design/73 §1 bridge: the VERBATIM core TaskOutcome fact (oracleHadRedRun / status / oracle blob) as it
-     -- came off core, kept alongside the derived mechanical columns. NULL when the caller recorded through the
-     -- non-core \`record()\` path (no core fact to bridge).
-     core_outcome   JSONB,
-     created_at     TIMESTAMPTZ(3) NOT NULL,
-     PRIMARY KEY (id)
-   )`,
-    `CREATE INDEX IF NOT EXISTS idx_outcome_ledger_sig_model ON outcome_ledger (task_signature, model, run_status)`,
-    `CREATE INDEX IF NOT EXISTS idx_outcome_ledger_outcome ON outcome_ledger (outcome)`,
-    `CREATE INDEX IF NOT EXISTS idx_outcome_ledger_created ON outcome_ledger (created_at)`,
-];
-export async function ensureSchema(pool) {
-    for (const stmt of PG_OUTCOME_LEDGER_SCHEMA)
-        await pool.query(stmt);
-}
-export class PgOutcomeLedger {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async record(o) {
-        const id = randomUUID().replace(/-/g, "").slice(0, 32);
-        const sig = taskSignature(o.signatureInputs);
-        const m = o.mechanical;
-        const runStatus = o.runStatus ?? "completed-graded";
-        await this.pool.query(`INSERT INTO outcome_ledger
-        (id, task_signature, model, task_id, run_status, route, worker_count, oracle_passed, oracle_total,
-         assemble_exit, lint_exit, merge_ok, replan_triggers, cost_micro_usd, turns, outcome,
-         llm_assisted, signature_inputs, core_outcome, created_at)
-       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13::jsonb,$14,$15,$16,$17::jsonb,$18::jsonb,$19::jsonb,$20)`, [
-            id,
-            sig,
-            o.model,
-            o.taskId ?? null,
-            runStatus,
-            m.route ?? null,
-            m.workerCount ?? null,
-            m.oraclePassed ?? null,
-            m.oracleTotal ?? null,
-            m.assembleExit ?? null,
-            m.lintExit ?? null,
-            m.mergeOk == null ? null : m.mergeOk ? 1 : 0,
-            m.replanTriggers ? pgSafeJsonStringify(m.replanTriggers) : null,
-            m.costMicroUsd ?? null,
-            m.turns ?? null,
-            deriveOutcome(m, runStatus),
-            o.llmAssisted ? pgSafeJsonStringify(o.llmAssisted) : null,
-            pgSafeJsonStringify(o.signatureInputs),
-            o.core != null ? pgSafeJsonStringify(o.core) : null,
-            new Date(),
-        ]);
-        return id;
-    }
-    async recordCore(o) {
-        await this.record(coreOutcomeToLedgerRow(o));
-    }
-    async summary(opts = {}) {
-        const clauses = [];
-        const params = [];
-        if (!opts.includeAborted)
-            clauses.push("run_status = 'completed-graded'");
-        if (opts.taskSignature) {
-            params.push(opts.taskSignature);
-            clauses.push(`task_signature = $${params.length}`);
-        }
-        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
-        const res = await this.pool.query(`SELECT task_signature, model, COUNT(*) n,
-              AVG((outcome = 'pass')::int) pass_rate, AVG(cost_micro_usd) mean_cost
-         FROM outcome_ledger ${where}
-        GROUP BY task_signature, model
-        ORDER BY task_signature, model`, params);
-        return res.rows.map((r) => ({
-            taskSignature: String(r.task_signature),
-            model: String(r.model),
-            n: Number(r.n),
-            passRate: Number(r.pass_rate),
-            meanCostMicroUsd: Number(r.mean_cost ?? 0),
-        }));
-    }
-}
+export { PgOutcomeLedger, PG_OUTCOME_LEDGER_SCHEMA, ensurePgOutcomeLedgerSchema as ensureSchema, } from "./outcome-ledger-sql.js";
 //# sourceMappingURL=pg-outcome-ledger.js.map

package/dist/plugins/pg-rate-limiter.d.ts

@@ -1,38 +1,8 @@
 import type { Pool, PoolClient } from "pg";
 import type { RateDecision, RateGate } from "../observability/rate-limit.js";
 import { type CounterDegradeHook } from "./write-behind-counter.js";
-export interface CounterTable {
-    table: string;
-    keyCol: string;
-    valCol: string;
-}
-export declare class PgWriteBehindCounter {
-    private readonly pool;
-    private readonly t;
-    private readonly windowMs;
-    private readonly now;
-    private readonly onDegraded?;
-    private readonly queryTimeoutMs;
-    private pendingDelta;
-    private fleetTotal;
-    private timer?;
-    private flushing;
-    private flushStartedAt;
-    private failStreak;
-    constructor(pool: Pool, t: CounterTable, windowMs: number, now?: () => number, onDegraded?: CounterDegradeHook | undefined, queryTimeoutMs?: number);
-    private bump;
-    bucket(): number;
-    private rk;
-    used(key: string): number;
-    addLocal(key: string, n: number): void;
-    retryAfterSec(): number;
-    flush(): Promise<void>;
-    private flushOnce;
-    refresh(): Promise<void>;
-    reap(): Promise<number>;
-    startRefresh(intervalMs?: number): this;
-    stop(): void;
-}
+export { PgWriteBehindCounter } from "./write-behind-counter.js";
+export type { CounterTable } from "./write-behind-counter.js";
 export declare class PgRateLimiter implements RateGate {
     private readonly limit;
     private readonly counter;

package/dist/plugins/pg-rate-limiter.js

@@ -1,155 +1,12 @@
-import { DEFAULT_COUNTER_QUERY_TIMEOUT_MS } from "./write-behind-counter.js";
-const SEP = "\u0000";
-export class PgWriteBehindCounter {
-    pool;
-    t;
-    windowMs;
-    now;
-    onDegraded;
-    queryTimeoutMs;
-    pendingDelta = new Map();
-    fleetTotal = new Map();
-    timer;
-    flushing = false;
-    flushStartedAt = 0;
-    failStreak = new Map();
-    constructor(pool, t, windowMs, now = () => Date.now(), onDegraded, queryTimeoutMs = DEFAULT_COUNTER_QUERY_TIMEOUT_MS) {
-        this.pool = pool;
-        this.t = t;
-        this.windowMs = windowMs;
-        this.now = now;
-        this.onDegraded = onDegraded;
-        this.queryTimeoutMs = queryTimeoutMs;
-    }
-    bump(kind, failed, error) {
-        if (!this.onDegraded)
-            return;
-        const prev = this.failStreak.get(kind) ?? 0;
-        if (!failed && prev === 0)
-            return;
-        const next = failed ? prev + 1 : 0;
-        this.failStreak.set(kind, next);
-        try {
-            this.onDegraded({ table: this.t.table, kind, streak: next, prevStreak: prev, ...(failed && error !== undefined ? { error: error instanceof Error ? error.message : String(error) } : {}) });
-        }
-        catch {
-        }
-    }
-    bucket() {
-        return Math.floor(this.now() / this.windowMs);
-    }
-    rk(key) {
-        return `${key}${SEP}${this.bucket()}`;
-    }
-    used(key) {
-        const rk = this.rk(key);
-        return (this.fleetTotal.get(rk) ?? 0) + (this.pendingDelta.get(rk) ?? 0);
-    }
-    addLocal(key, n) {
-        if (n <= 0)
-            return;
-        const rk = this.rk(key);
-        this.pendingDelta.set(rk, (this.pendingDelta.get(rk) ?? 0) + n);
-    }
-    retryAfterSec() {
-        return Math.ceil(((this.bucket() + 1) * this.windowMs - this.now()) / 1000);
-    }
-    async flush() {
-        if (this.flushing) {
-            if (this.now() - this.flushStartedAt > 60_000)
-                this.bump("stalled", true, "flush round stalled >60s (hung query?)");
-            return;
-        }
-        this.flushing = true;
-        this.flushStartedAt = this.now();
-        try {
-            await this.flushOnce();
-        }
-        finally {
-            this.flushing = false;
-            this.bump("stalled", false);
-        }
-    }
-    async flushOnce() {
-        const { table, keyCol, valCol } = this.t;
-        let attempted = false;
-        let failure;
-        let hadFailure = false;
-        for (const [rk, delta] of [...this.pendingDelta]) {
-            if (delta <= 0)
-                continue;
-            const sep = rk.lastIndexOf(SEP);
-            const key = rk.slice(0, sep);
-            const windowBucket = Number(rk.slice(sep + 1));
-            attempted = true;
-            try {
-                const q = {
-                    text: `INSERT INTO ${table} (${keyCol}, window_bucket, ${valCol}, updated_at) VALUES ($1,$2,$3,$4) ` +
-                        `ON CONFLICT (${keyCol}, window_bucket) DO UPDATE SET ${valCol} = ${table}.${valCol} + EXCLUDED.${valCol}, updated_at = EXCLUDED.updated_at`,
-                    values: [key, windowBucket, delta, new Date()],
-                    query_timeout: this.queryTimeoutMs,
-                };
-                await this.pool.query(q);
-                const remaining = (this.pendingDelta.get(rk) ?? 0) - delta;
-                if (remaining > 0)
-                    this.pendingDelta.set(rk, remaining);
-                else
-                    this.pendingDelta.delete(rk);
-            }
-            catch (err) {
-                hadFailure = true;
-                failure = err;
-            }
-        }
-        if (attempted)
-            this.bump("flush", hadFailure, failure);
-        await this.refresh();
-        await this.reap();
-    }
-    async refresh() {
-        const { table, keyCol, valCol } = this.t;
-        const b = this.bucket();
-        try {
-            const q = { text: `SELECT ${keyCol}, ${valCol} FROM ${table} WHERE window_bucket = $1`, values: [b], query_timeout: this.queryTimeoutMs };
-            const res = await this.pool.query(q);
-            const next = new Map();
-            for (const row of res.rows) {
-                next.set(`${String(row[keyCol])}${SEP}${b}`, Number(row[valCol]));
-            }
-            this.fleetTotal = next;
-            this.bump("refresh", false);
-        }
-        catch (err) {
-            this.bump("refresh", true, err);
-        }
-    }
-    async reap() {
-        try {
-            const q = { text: `DELETE FROM ${this.t.table} WHERE window_bucket < $1`, values: [this.bucket()], query_timeout: this.queryTimeoutMs };
-            const res = await this.pool.query(q);
-            return res.rowCount ?? 0;
-        }
-        catch {
-            return 0;
-        }
-    }
-    startRefresh(intervalMs = 5_000) {
-        this.timer ??= setInterval(() => void this.flush(), intervalMs);
-        this.timer.unref?.();
-        return this;
-    }
-    stop() {
-        if (this.timer)
-            clearInterval(this.timer);
-        this.timer = undefined;
-    }
-}
+import { PgWriteBehindCounter } from "./write-behind-counter.js";
+export { PgWriteBehindCounter } from "./write-behind-counter.js";
+const RATE_LIMIT_TABLE = { table: "rate_limit", keyCol: "limit_key", valCol: "n" };
 export class PgRateLimiter {
     limit;
     counter;
     constructor(pool, limit, windowMs = 60_000, now, onDegraded, queryTimeoutMs) {
         this.limit = limit;
-        this.counter = new PgWriteBehindCounter(pool, { table: "rate_limit", keyCol: "limit_key", valCol: "n" }, windowMs, now, onDegraded, queryTimeoutMs);
+        this.counter = new PgWriteBehindCounter(pool, RATE_LIMIT_TABLE, windowMs, now, onDegraded, queryTimeoutMs);
     }
     check(key) {
         if (this.limit <= 0)

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

@@ -1,14 +1,2 @@
-import type { Pool } from "pg";
-export declare class PgResumeAnchorStore {
-    private readonly pool;
-    constructor(pool: Pool);
-    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 { PgResumeAnchorStore } from "./resume-anchor-store-sql.js";
 //# sourceMappingURL=pg-resume-anchor-store.d.ts.map

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

@@ -1,23 +1,2 @@
-export class PgResumeAnchorStore {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async put(sessionId, eventId, entryId, owner) {
-        await this.pool.query("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 r = await this.pool.query("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 r.rows[0] ? String(r.rows[0].entry_id) : undefined;
-    }
-    async listBySession(sessionId) {
-        const r = await this.pool.query("SELECT event_id, entry_id, owner FROM resume_anchor WHERE session_id = $1", [sessionId]);
-        return r.rows.map((row) => ({ eventId: String(row.event_id), entryId: String(row.entry_id), owner: row.owner == null ? null : String(row.owner) }));
-    }
-    async deleteBySession(sessionId) {
-        const r = await this.pool.query("DELETE FROM resume_anchor WHERE session_id = $1", [sessionId]);
-        return r.rowCount ?? 0;
-    }
-}
+export { PgResumeAnchorStore } from "./resume-anchor-store-sql.js";
 //# sourceMappingURL=pg-resume-anchor-store.js.map

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

@@ -1,76 +1,2 @@
-import type { TaskResult, TaskStatus } from "@sema-agent/core";
-import { type UsageRow } from "../usage-analytics.js";
-import type { Pool } from "pg";
-import type { RunRecord, RunEvent, SessionSummary } from "./store-contracts.js";
-export declare class PgRunStore {
-    private readonly pool;
-    constructor(pool: Pool);
-    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[]>;
-    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 { PgRunStore } from "./run-store-sql.js";
 //# sourceMappingURL=pg-run-store.d.ts.map