@tenetkit/pg 0.28.0

package/dist/postgres/schema.js

@@ -0,0 +1,274 @@
+export const SCHEMA_VERSION = 7;
+export const SCHEMA_META_TABLE = "baton_schema_meta";
+export const MIGRATIONS_TABLE = "baton_sql_migrations";
+export const NOTIFY_CHANNEL = "baton_run_events";
+export const SCHEMA_STATEMENTS = [
+    `CREATE TABLE IF NOT EXISTS baton_schema_meta (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  version INTEGER NOT NULL,
+  checksum TEXT NOT NULL,
+  dirty BOOLEAN NOT NULL DEFAULT FALSE,
+  applied_at TIMESTAMPTZ NOT NULL
+)`,
+    `CREATE TABLE IF NOT EXISTS baton_lanes (
+  address TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  accepted_sequence BIGINT NOT NULL,
+  queue_json TEXT NOT NULL,
+  head_run_id TEXT,
+  PRIMARY KEY (address, session_id)
+)`,
+    `CREATE TABLE IF NOT EXISTS baton_runs (
+  run_id TEXT PRIMARY KEY,
+  status TEXT NOT NULL,
+  address TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  message_id TEXT NOT NULL,
+  message_json TEXT NOT NULL,
+  message_digest TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL,
+  executable_ref_json TEXT NOT NULL,
+  executable_manifest_json TEXT NOT NULL,
+  root_run_id TEXT NOT NULL,
+  depth INTEGER NOT NULL,
+  max_depth INTEGER NOT NULL,
+  max_subagents INTEGER NOT NULL,
+  parent_run_id TEXT,
+  invocation_id TEXT,
+  active_wait_id TEXT,
+  attempt INTEGER NOT NULL DEFAULT 0,
+  attempt_fence INTEGER NOT NULL DEFAULT 0,
+  last_sequence INTEGER NOT NULL DEFAULT -1,
+  cancellation_requested BOOLEAN NOT NULL DEFAULT FALSE,
+  cancel_reason TEXT,
+  terminal_event_id TEXT,
+  accepted_sequence BIGINT NOT NULL,
+  responded_wait_ids_json TEXT NOT NULL,
+  driver_checkpoint_json TEXT,
+  suspension_json TEXT,
+  continuation_json TEXT,
+  pending_outcome_json TEXT,
+  owner_worker_id TEXT,
+  lease_expires_at TIMESTAMPTZ,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  UNIQUE (address, session_id, idempotency_key)
+)`,
+    `CREATE TABLE IF NOT EXISTS baton_run_events (
+  run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+  sequence INTEGER NOT NULL,
+  event_id TEXT NOT NULL UNIQUE,
+  event_json TEXT NOT NULL,
+  PRIMARY KEY (run_id, sequence)
+)`,
+    `CREATE TABLE IF NOT EXISTS baton_run_operations (
+  run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+  operation_id TEXT NOT NULL,
+  operation_key TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  status TEXT NOT NULL,
+  input_digest TEXT NOT NULL,
+  input_json TEXT NOT NULL,
+  result_json TEXT,
+  error_json TEXT,
+  replay_policy TEXT NOT NULL,
+  attempt INTEGER NOT NULL,
+  owner_worker_id TEXT,
+  lease_expires_at TIMESTAMPTZ,
+  started_at TIMESTAMPTZ,
+  finished_at TIMESTAMPTZ,
+  resolution_idempotency_key TEXT,
+  resolution_json TEXT,
+  PRIMARY KEY (run_id, operation_id),
+  UNIQUE (run_id, operation_key)
+)`,
+    `CREATE TABLE IF NOT EXISTS baton_run_waits (
+  run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+  wait_id TEXT NOT NULL,
+  reason TEXT NOT NULL,
+  status TEXT NOT NULL,
+  response_json TEXT,
+  due_at TIMESTAMPTZ,
+  owner_worker_id TEXT,
+  lease_expires_at TIMESTAMPTZ,
+  opened_at TIMESTAMPTZ NOT NULL,
+  closed_at TIMESTAMPTZ,
+  PRIMARY KEY (run_id, wait_id)
+)`,
+    `CREATE TABLE IF NOT EXISTS baton_run_links (
+  parent_run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+  child_run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+  invocation_id TEXT NOT NULL,
+  readiness TEXT NOT NULL,
+  terminal_event_id TEXT,
+  created_at TIMESTAMPTZ NOT NULL,
+  settled_at TIMESTAMPTZ,
+  PRIMARY KEY (parent_run_id, child_run_id),
+  UNIQUE (child_run_id)
+)`,
+    `CREATE INDEX IF NOT EXISTS baton_run_links_readiness_idx ON baton_run_links(parent_run_id, readiness, created_at, child_run_id)`,
+    `CREATE TABLE IF NOT EXISTS baton_run_steering (
+  entry_id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+  sequence BIGINT NOT NULL,
+  idempotency_key TEXT NOT NULL,
+  digest TEXT NOT NULL,
+  prompt_json TEXT NOT NULL,
+  consumed_operation_id TEXT,
+  discarded_reason TEXT,
+  UNIQUE (run_id, sequence),
+  UNIQUE (run_id, idempotency_key)
+)`,
+    `CREATE INDEX IF NOT EXISTS baton_run_steering_pending_idx
+    ON baton_run_steering(run_id, sequence) WHERE consumed_operation_id IS NULL AND discarded_reason IS NULL`,
+    `CREATE TABLE IF NOT EXISTS baton_agent_names (
+  scope TEXT NOT NULL,
+  name TEXT NOT NULL,
+  run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+  PRIMARY KEY (scope, name)
+)`,
+    `CREATE INDEX IF NOT EXISTS baton_agent_names_run_idx ON baton_agent_names(run_id)`,
+    `CREATE TABLE IF NOT EXISTS baton_messages (
+  entry_id TEXT PRIMARY KEY,
+  target_session_id TEXT NOT NULL,
+  sequence BIGINT NOT NULL,
+  from_address TEXT NOT NULL,
+  from_run_id TEXT NOT NULL,
+  to_address TEXT NOT NULL,
+  message_id TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL,
+  digest TEXT NOT NULL,
+  bytes BIGINT NOT NULL,
+  admitted_at_millis BIGINT NOT NULL,
+  prompt_json TEXT NOT NULL,
+  correlation_id TEXT NOT NULL,
+  causation_id TEXT,
+  in_reply_to TEXT,
+  metadata_json TEXT NOT NULL,
+  delivered_run_id TEXT,
+  steering_entry_id TEXT,
+  UNIQUE (target_session_id, message_id, idempotency_key),
+  UNIQUE (target_session_id, sequence)
+)`,
+    `CREATE INDEX IF NOT EXISTS baton_messages_pending_idx
+    ON baton_messages(target_session_id, sequence) WHERE delivered_run_id IS NULL`,
+    `CREATE INDEX IF NOT EXISTS baton_runs_claim_idx
+    ON baton_runs(status, lease_expires_at)
+    WHERE status IN ('queued', 'running', 'waiting', 'needs-resolution', 'cancelling')`,
+    `CREATE INDEX IF NOT EXISTS baton_lanes_head_idx ON baton_lanes(head_run_id)`,
+    `CREATE INDEX IF NOT EXISTS baton_run_operations_status_idx ON baton_run_operations(status)`,
+    `CREATE INDEX IF NOT EXISTS baton_run_waits_due_idx ON baton_run_waits(status, due_at)`,
+    `CREATE TABLE IF NOT EXISTS baton_fan_outs (
+  fan_out_id TEXT PRIMARY KEY,
+  parent_run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+  idempotency_key TEXT NOT NULL,
+  input_digest TEXT NOT NULL,
+  join_json TEXT NOT NULL,
+  remainder TEXT NOT NULL,
+  concurrency INTEGER NOT NULL,
+  status TEXT NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL,
+  UNIQUE (parent_run_id, idempotency_key)
+)`,
+    `CREATE TABLE IF NOT EXISTS baton_fan_out_members (
+  fan_out_id TEXT NOT NULL REFERENCES baton_fan_outs(fan_out_id),
+  ordinal INTEGER NOT NULL,
+  member_key TEXT NOT NULL,
+  selection TEXT NOT NULL,
+  display_label TEXT,
+  prompt_json TEXT NOT NULL,
+  origin_json TEXT,
+  child_run_id TEXT NOT NULL UNIQUE REFERENCES baton_runs(run_id),
+  depth INTEGER NOT NULL,
+  status TEXT NOT NULL,
+  terminal_event_id TEXT,
+  outcome_json TEXT,
+  PRIMARY KEY (fan_out_id, ordinal),
+  UNIQUE (fan_out_id, member_key)
+)`,
+    `CREATE INDEX IF NOT EXISTS baton_fan_out_members_status_idx ON baton_fan_out_members(fan_out_id, status, ordinal)`,
+    `CREATE TABLE IF NOT EXISTS baton_tree_roots (
+  root_run_id TEXT PRIMARY KEY REFERENCES baton_runs(run_id),
+  earliest_position BIGINT NOT NULL DEFAULT 0,
+  last_position BIGINT NOT NULL DEFAULT -1
+)`,
+    `CREATE TABLE IF NOT EXISTS baton_tree_event_index (
+  root_run_id TEXT NOT NULL REFERENCES baton_tree_roots(root_run_id),
+  position BIGINT NOT NULL,
+  run_id TEXT NOT NULL,
+  run_sequence INTEGER NOT NULL,
+  event_id TEXT NOT NULL UNIQUE REFERENCES baton_run_events(event_id),
+  PRIMARY KEY (root_run_id, position),
+  UNIQUE (run_id, run_sequence),
+  FOREIGN KEY (run_id, run_sequence) REFERENCES baton_run_events(run_id, sequence)
+  )`,
+    `CREATE TABLE IF NOT EXISTS baton_program_runs (
+  run_id TEXT PRIMARY KEY REFERENCES baton_runs(run_id),
+  program_pin TEXT NOT NULL,
+  budget_json TEXT NOT NULL,
+  deadline_millis BIGINT NOT NULL,
+  tool_calls BIGINT NOT NULL DEFAULT 0,
+  agent_runs BIGINT NOT NULL DEFAULT 0,
+  tokens BIGINT NOT NULL DEFAULT 0,
+  log_bytes BIGINT NOT NULL DEFAULT 0,
+  active_slots BIGINT NOT NULL DEFAULT 0
+)`,
+    `CREATE TABLE IF NOT EXISTS baton_program_operations (
+  run_id TEXT NOT NULL REFERENCES baton_program_runs(run_id),
+  operation_name TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  capability TEXT NOT NULL,
+  input_digest TEXT NOT NULL,
+  input_json TEXT NOT NULL,
+  replay_policy TEXT NOT NULL,
+  status TEXT NOT NULL,
+  result_json TEXT,
+  error_json TEXT,
+  wait_id TEXT,
+  fan_out_id TEXT,
+  child_run_ids_json TEXT NOT NULL,
+  resolution_idempotency_key TEXT,
+  resolution_json TEXT,
+  PRIMARY KEY (run_id, operation_name)
+)`,
+    `CREATE TABLE IF NOT EXISTS baton_executable_registrations (
+  pin TEXT PRIMARY KEY,
+  codec TEXT NOT NULL,
+  version TEXT NOT NULL,
+  payload_json TEXT NOT NULL,
+  registration_digest TEXT NOT NULL
+)`,
+    `CREATE TABLE IF NOT EXISTS baton_run_registrations (
+  run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+  pin TEXT NOT NULL REFERENCES baton_executable_registrations(pin),
+  PRIMARY KEY (run_id, pin)
+  )`,
+    `CREATE INDEX IF NOT EXISTS baton_run_registrations_pin_idx ON baton_run_registrations(pin)`,
+    `CREATE TABLE IF NOT EXISTS baton_sessions (
+  session_id TEXT PRIMARY KEY,
+  leaf_id TEXT,
+  next_seq BIGINT NOT NULL DEFAULT 0,
+  owner_token TEXT,
+  updated_at TIMESTAMPTZ NOT NULL
+)`,
+    `CREATE TABLE IF NOT EXISTS baton_session_entries (
+  session_id TEXT NOT NULL,
+  entry_id TEXT NOT NULL,
+  parent_id TEXT,
+  seq BIGINT NOT NULL,
+  tag TEXT NOT NULL,
+  payload_json TEXT NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  PRIMARY KEY (session_id, entry_id)
+)`,
+    `CREATE UNIQUE INDEX IF NOT EXISTS baton_session_entries_seq_idx ON baton_session_entries(session_id, seq)`,
+    `CREATE INDEX IF NOT EXISTS baton_session_entries_parent_idx ON baton_session_entries(session_id, parent_id)`,
+];
+export const schemaChecksum = () => {
+    const hasher = new Bun.CryptoHasher("sha256");
+    hasher.update(SCHEMA_STATEMENTS.join("\n"));
+    hasher.update(`\nversion=${SCHEMA_VERSION}`);
+    hasher.update("\ndialect=postgres");
+    return hasher.digest("hex");
+};

package/dist/postgres/session-cancellation.d.ts

@@ -0,0 +1,11 @@
+import { Effect } from "effect";
+import type { PgClient } from "@effect/sql-pg";
+import type { SqlClient } from "effect/unstable/sql";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { RunNotFound, RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
+export declare const cancelSessionRuns: (input: {
+    readonly lockRun: (runId: string) => Effect.Effect<void, SqlError, SqlClient.SqlClient>;
+    readonly cancelRun: (runId: string, reason?: string) => Effect.Effect<void, RunNotFound | RuntimeUnavailable | SqlError, SqlClient.SqlClient | PgClient.PgClient>;
+    readonly sessionId: string;
+    readonly reason?: string;
+}) => Effect.Effect<string[], RuntimeUnavailable | SqlError, PgClient.PgClient | SqlClient.SqlClient>;

package/dist/postgres/session-cancellation.js

@@ -0,0 +1,15 @@
+import { Effect } from "effect";
+import { activeSessionRuns, sessionRoots, sessionRuns } from "tenetkit/runtime/driver/sql/session-lifecycle";
+export const cancelSessionRuns = (input) => Effect.gen(function* () {
+    const roots = yield* sessionRoots(input.sessionId);
+    const runs = yield* sessionRuns(input.sessionId);
+    const active = yield* activeSessionRuns(input.sessionId);
+    for (const runId of runs)
+        yield* input.lockRun(runId);
+    for (const runId of roots) {
+        yield* input
+            .cancelRun(runId, input.reason)
+            .pipe(Effect.catchTag("tenetkit/runtime/RunNotFound", () => Effect.void));
+    }
+    return active;
+});

package/dist/postgres/session-storage.d.ts

@@ -0,0 +1,32 @@
+import { Effect } from "effect";
+import { Session } from "tenetkit";
+import { SqlClient } from "effect/unstable/sql";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+import { type EntryRow, type SessionRow } from "tenetkit/runtime/driver/sql/session-store";
+declare const insertEntry: (input: {
+    readonly sessionId: string;
+    readonly id: string;
+    readonly parentId: string | null;
+    readonly seq: number;
+    readonly tag: string;
+    readonly payload: Session.EntryPayload;
+}) => Effect.Effect<void, SqlError, SqlClient.SqlClient>;
+declare const advanceSession: (input: {
+    readonly sessionId: string;
+    readonly leafId: string | null;
+    readonly nextSeq: number;
+    readonly ownerToken?: string;
+}) => Effect.Effect<void, SqlError, SqlClient.SqlClient>;
+export declare const PostgresSessionStorage: {
+    readonly encodePayload: (payload: Session.EntryPayload) => string;
+    readonly entryPayloadEquivalence: (self: Session.EntryPayload, that: Session.EntryPayload) => boolean;
+    readonly storeError: (message: string) => Session.SessionStoreError;
+    readonly toEntry: (row: EntryRow) => Session.Entry;
+    readonly lockSession: (sessionId: string) => Effect.Effect<SessionRow, Session.SessionStoreError | SqlError, SqlClient.SqlClient>;
+    readonly loadEntries: (sessionId: string) => Effect.Effect<ReadonlyArray<EntryRow>, SqlError, SqlClient.SqlClient>;
+    readonly pathFromRows: (rows: ReadonlyArray<EntryRow>, leaf: string | null) => ReadonlyArray<Session.Entry> | Session.SessionStoreError;
+    readonly requireActive: (rows: ReadonlyArray<EntryRow>, leaf: string | null, entryId: string, reason?: "stale-leaf" | "checkpoint-not-on-active-path") => Session.SessionConflict | undefined;
+    readonly insertEntry: typeof insertEntry;
+    readonly advanceSession: typeof advanceSession;
+};
+export {};

package/dist/postgres/session-storage.js

@@ -0,0 +1,63 @@
+import { Effect } from "effect";
+import { Session } from "tenetkit";
+import { SqlClient } from "effect/unstable/sql";
+import { SessionStorage } from "tenetkit/runtime/driver/sql/session-store";
+const { encodePayload, entryPayloadEquivalence, pathFromRows, requireActive, storeError, toEntry } = SessionStorage;
+const lockSession = (sessionId) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    yield* sql `
+      INSERT INTO baton_sessions (session_id, leaf_id, next_seq, owner_token, updated_at)
+      VALUES (${sessionId}, NULL, 0, NULL, NOW())
+      ON CONFLICT (session_id) DO NOTHING
+    `;
+    const rows = yield* sql `
+      SELECT leaf_id, next_seq, owner_token FROM baton_sessions
+      WHERE session_id = ${sessionId}
+      FOR UPDATE
+    `;
+    const row = rows[0];
+    return row === undefined ? yield* storeError(`Session ${sessionId} could not be initialized`) : row;
+});
+const loadEntries = (sessionId) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    return yield* sql `
+      SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+      WHERE session_id = ${sessionId} ORDER BY seq
+    `;
+});
+const insertEntry = (input) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    yield* sql `
+      INSERT INTO baton_session_entries (session_id, entry_id, parent_id, seq, tag, payload_json, created_at)
+      VALUES (${input.sessionId}, ${input.id}, ${input.parentId}, ${input.seq}, ${input.tag},
+        ${encodePayload(input.payload)}, NOW())
+    `;
+});
+const advanceSession = (input) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    if (input.ownerToken === undefined) {
+        yield* sql `
+        UPDATE baton_sessions SET leaf_id = ${input.leafId}, next_seq = ${input.nextSeq}, updated_at = NOW()
+        WHERE session_id = ${input.sessionId}
+      `;
+    }
+    else {
+        yield* sql `
+        UPDATE baton_sessions SET leaf_id = ${input.leafId}, next_seq = ${input.nextSeq},
+          owner_token = ${input.ownerToken}, updated_at = NOW()
+        WHERE session_id = ${input.sessionId}
+      `;
+    }
+});
+export const PostgresSessionStorage = {
+    encodePayload,
+    entryPayloadEquivalence,
+    storeError,
+    toEntry,
+    lockSession,
+    loadEntries,
+    pathFromRows,
+    requireActive,
+    insertEntry,
+    advanceSession,
+};

package/dist/postgres/session-store.d.ts

@@ -0,0 +1,24 @@
+import { Effect } from "effect";
+import { Session } from "tenetkit";
+import { SqlClient } from "effect/unstable/sql";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { CompletedSessionEntry } from "tenetkit/runtime/driver/model-response-commit";
+import type { InterruptedSessionEntry } from "tenetkit/runtime/driver/agent-event";
+import { type HandoffSessionEntry } from "tenetkit/runtime/driver/handoff-session";
+import type { RunFn } from "./store-ops.js";
+/** Append or verify one exact completed assistant projection in the caller's PostgreSQL transaction. */
+export declare const appendCompletedSessionEntry: (input: CompletedSessionEntry) => Effect.Effect<Session.Entry, Session.SessionConflict | Session.SessionStoreError | SqlError, SqlClient.SqlClient>;
+/** Verify an exact completed assistant projection in the caller's PostgreSQL transaction. */
+export declare const verifyCompletedSessionEntry: (input: CompletedSessionEntry) => Effect.Effect<void, Session.SessionConflict | Session.SessionStoreError | SqlError, SqlClient.SqlClient>;
+/** Append or verify one exact nonempty interrupted assistant projection in the caller's transaction. */
+export declare const appendInterruptedSessionEntry: (input: InterruptedSessionEntry) => Effect.Effect<Session.Entry, Session.SessionConflict | Session.SessionStoreError | SqlError, SqlClient.SqlClient>;
+export declare const verifyInterruptedSessionEntry: (input: InterruptedSessionEntry) => Effect.Effect<void, Session.SessionConflict | Session.SessionStoreError | SqlError, SqlClient.SqlClient>;
+/** Append or verify one exact handoff projection in the caller's PostgreSQL transaction. */
+export declare const appendHandoffSessionEntry: (input: HandoffSessionEntry) => Effect.Effect<Session.HandoffEntry, Session.SessionConflict | Session.SessionStoreError | SqlError, SqlClient.SqlClient>;
+export declare const verifyHandoffSessionEntry: (input: HandoffSessionEntry) => Effect.Effect<void, Session.SessionConflict | Session.SessionStoreError | SqlError, SqlClient.SqlClient>;
+/** Dialect-native durable PostgreSQL Session authority bound to one session identity. */
+export declare const makePostgresSessionStore: (options: {
+    readonly sessionId: string;
+    readonly run: RunFn;
+    readonly runNoTxn: RunFn;
+}) => Session.Interface;