@tenetkit/pg 0.28.0

package/dist/postgres/store-claims.js

@@ -0,0 +1,72 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import { AgentExecutionFailure, RunNotFound, RunTerminal, RuntimeUnavailable, failureMessage, } from "tenetkit/runtime/driver/errors";
+import { isTerminal } from "tenetkit/runtime/driver/run";
+import { StaleClaim } from "tenetkit/runtime/driver/sql/errors";
+import { claimReadyRuns, refreshLease, releaseClaim } from "./claims.js";
+import { RunClaims } from "tenetkit/runtime/driver/sql/run-claims";
+import { afterTerminal, appendEvent, completeRun, loadEventsAfter, loadRun, settleParent } from "./pg-helpers.js";
+import { lockRunHierarchy } from "./locks.js";
+export const makePostgresClaims = (input) => {
+    const { hub, run, cancelRun } = input;
+    return RunClaims.of({
+        claimReadyRuns: (claimInput) => run(Effect.gen(function* () {
+            const claimed = yield* claimReadyRuns({
+                workerId: claimInput.workerId,
+                limit: claimInput.limit,
+                lease: claimInput.lease ?? "30 seconds",
+            });
+            for (const item of claimed) {
+                const fresh = (yield* loadRun(item.run.runId));
+                const events = yield* loadEventsAfter(item.run.runId, -1);
+                const hasAttempt = events.some((event) => event._tag === "RunAttemptStarted" && event.attempt === fresh.attempt);
+                if (!hasAttempt && fresh.attempt > 0) {
+                    yield* appendEvent(hub, fresh, { _tag: "RunAttemptStarted", attempt: fresh.attempt }, "running");
+                }
+            }
+            return claimed;
+        })),
+        refreshLease: (leaseInput) => run(refreshLease({
+            runId: leaseInput.runId,
+            workerId: leaseInput.workerId,
+            attemptFence: leaseInput.attemptFence,
+            lease: leaseInput.lease ?? "30 seconds",
+        })),
+        releaseClaim: (releaseInput) => run(releaseClaim({
+            runId: releaseInput.runId,
+            workerId: releaseInput.workerId,
+            attemptFence: releaseInput.attemptFence,
+        })),
+        commitWithClaim: (commitInput) => run(Effect.gen(function* () {
+            yield* lockRunHierarchy(commitInput.runId);
+            const loaded = yield* loadRun(commitInput.runId);
+            if (loaded === undefined ||
+                loaded.ownerWorkerId !== commitInput.workerId ||
+                loaded.attemptFence !== commitInput.attemptFence) {
+                return yield* StaleClaim.make({
+                    runId: commitInput.runId,
+                    workerId: commitInput.workerId,
+                    attemptFence: commitInput.attemptFence,
+                });
+            }
+            if (commitInput.transition === "cancel") {
+                yield* cancelRun(commitInput.runId, commitInput.reason);
+                return;
+            }
+            if (isTerminal(loaded.status)) {
+                return yield* RunTerminal.make({ runId: loaded.runId, status: loaded.status });
+            }
+            if (commitInput.transition === "complete") {
+                yield* completeRun(hub, loaded, commitInput.result);
+                return;
+            }
+            const event = yield* appendEvent(hub, loaded, {
+                _tag: "RunFailed",
+                error: AgentExecutionFailure.make({ message: failureMessage(commitInput.error?.message ?? "failed") }),
+            }, "failed");
+            const settled = (yield* loadRun(loaded.runId));
+            yield* settleParent(hub, settled, event.eventId);
+            yield* afterTerminal(hub, settled);
+        })),
+    });
+};

package/dist/postgres/store-fan-out.d.ts

@@ -0,0 +1,21 @@
+import { Effect } from "effect";
+import type { PgClient } from "@effect/sql-pg";
+import type { SqlClient } from "effect/unstable/sql";
+import type { Interface as RunStoreInterface } from "tenetkit/runtime/driver/run-store";
+import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
+import type { WithoutSqlError } from "tenetkit/runtime/driver/sql/sql-effect";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+type SqlR = SqlClient.SqlClient | PgClient.PgClient;
+export type Run = <A, E>(effect: Effect.Effect<A, E | SqlError, SqlR>) => Effect.Effect<A, WithoutSqlError<E | SqlError> | import("tenetkit/runtime/driver/errors").RuntimeUnavailable>;
+export declare const fanOutStoreMethods: (input: {
+    readonly sql: SqlClient.SqlClient;
+    readonly pg: PgClient.PgClient;
+    readonly hub: EventHub;
+    readonly run: Run;
+    readonly runNoTxn: Run;
+}) => Pick<RunStoreInterface, "admitFanOut" | "inspectFanOut">;
+export declare const cancelOwnedFanOuts: {
+    (parentRunId: string): (sql: SqlClient.SqlClient) => Effect.Effect<string[], SqlError, never>;
+    (sql: SqlClient.SqlClient, parentRunId: string): Effect.Effect<string[], SqlError, never>;
+};
+export {};

package/dist/postgres/store-fan-out.js

@@ -0,0 +1,17 @@
+import { Effect, Function } from "effect";
+import { admitFanOut, inspectFanOut } from "tenetkit/runtime/driver/sql/store-fan-out";
+import { NOTIFY_CHANNEL } from "./schema.js";
+export const fanOutStoreMethods = (input) => ({
+    admitFanOut: (fanOut) => input
+        .run(input.sql `SELECT run_id FROM baton_runs WHERE run_id = ${fanOut.parentRunId} FOR UPDATE`.pipe(Effect.andThen(input.sql `SELECT pg_advisory_xact_lock(hashtext(${`fanout:${fanOut.parentRunId}:${fanOut.idempotencyKey}`}))`), Effect.andThen(admitFanOut(input.hub, fanOut))))
+        .pipe(Effect.tap((receipt) => input.runNoTxn(Effect.forEach([receipt.parentRunId, ...receipt.childRunIds], (runId) => input.pg.notify(NOTIFY_CHANNEL, runId), { discard: true })))),
+    inspectFanOut: (fanOutId) => input.runNoTxn(inspectFanOut(fanOutId)),
+});
+export const cancelOwnedFanOuts = Function.dual(2, (sql, parentRunId) => Effect.gen(function* () {
+    const owned = yield* sql `
+      SELECT m.child_run_id FROM baton_fan_outs f
+      JOIN baton_fan_out_members m ON m.fan_out_id = f.fan_out_id
+      WHERE f.parent_run_id = ${parentRunId} AND f.status = 'running' ORDER BY m.ordinal ASC
+    `;
+    return owned.map((row) => row.child_run_id);
+}));

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

@@ -0,0 +1,12 @@
+import type { PgClient } from "@effect/sql-pg";
+import type { Interface as RunStoreInterface } from "tenetkit/runtime/driver/run-store";
+import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
+import type { RunFn } from "./store-ops.js";
+import type { Run } from "./store-fan-out.js";
+export declare const inspectionStoreMethods: (deps: {
+    readonly hub: EventHub;
+    readonly pg: PgClient.PgClient;
+    readonly run: Run;
+    readonly runNoTxn: Run;
+    readonly runInspection: RunFn;
+}) => Pick<RunStoreInterface, "inspect" | "snapshot" | "sessionRoots" | "inspectTree" | "history" | "treeHistory" | "treeChanges">;

package/dist/postgres/store-inspection.js

@@ -0,0 +1,44 @@
+import { Effect, Stream } from "effect";
+import { CursorExpired } from "tenetkit/runtime/driver/errors";
+import { loadRunSnapshot, loadTreeInspection } from "tenetkit/runtime/driver/sql/inspection";
+import { sessionRoots } from "tenetkit/runtime/driver/sql/session-lifecycle";
+import { loadChildReadiness } from "tenetkit/runtime/driver/sql/store-child-capacity";
+import { loadRunWait } from "tenetkit/runtime/driver/sql/store-helpers";
+import { loadTreeHistory } from "tenetkit/runtime/driver/sql/tree-history";
+import { loadEventsAfter, loadRun, requireRun } from "./pg-helpers.js";
+import { NOTIFY_CHANNEL } from "./schema.js";
+export const inspectionStoreMethods = (deps) => ({
+    inspect: (runId) => deps.runNoTxn(Effect.gen(function* () {
+        const loaded = yield* requireRun(runId);
+        const wait = yield* loadRunWait(runId, loaded.activeWaitId);
+        const childReadiness = yield* loadChildReadiness(runId);
+        return {
+            runId: loaded.runId,
+            status: loaded.status,
+            executableRef: loaded.executableRef,
+            executableManifest: loaded.executableManifest,
+            depth: loaded.depth,
+            treePolicy: loaded.treePolicy,
+            lastSequence: loaded.lastSequence,
+            durability: "durable",
+            ...(loaded.parentRunId === undefined ? {} : { parentRunId: loaded.parentRunId }),
+            ...(childReadiness === undefined ? {} : { childReadiness }),
+            ...(wait === undefined ? {} : { wait }),
+        };
+    })),
+    snapshot: (runId) => deps.runInspection(loadRunSnapshot(runId)),
+    sessionRoots: (sessionId) => deps.runNoTxn(sessionRoots(sessionId)),
+    inspectTree: (rootRunId) => deps.runInspection(loadTreeInspection(rootRunId)),
+    history: (input) => deps.runNoTxn(Effect.gen(function* () {
+        const loaded = yield* requireRun(input.runId);
+        if (input.cursor < -1 || input.cursor > loaded.lastSequence) {
+            return yield* CursorExpired.make({ runId: input.runId, cursor: input.cursor, earliestSequence: 0 });
+        }
+        return (yield* loadEventsAfter(input.runId, input.cursor)).slice(0, input.limit);
+    })),
+    treeHistory: (input) => deps.runNoTxn(loadTreeHistory(input)),
+    treeChanges: (rootRunId) => deps.hub.subscribeTree({
+        rootRunId,
+        onSubscribed: deps.pg.listen(NOTIFY_CHANNEL).pipe(Stream.runForEach((runId) => deps.runNoTxn(loadRun(String(runId))).pipe(Effect.flatMap((loaded) => (loaded?.rootRunId === rootRunId ? deps.hub.wakeTree(rootRunId) : Effect.void)), Effect.ignore)), Effect.ignore),
+    }),
+});

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

@@ -0,0 +1,14 @@
+import { Effect } from "effect";
+import type { SqlClient } from "effect/unstable/sql";
+import type { Interface as RunStoreInterface } from "tenetkit/runtime/driver/run-store";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { RunFn } from "./store-ops.js";
+import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
+/** The addressed-messaging half of the Postgres RunStore, kept beside the store it completes. */
+export declare const messagingStoreMethods: (input: {
+    readonly run: RunFn;
+    readonly runNoTxn: RunFn;
+    readonly hub: EventHub;
+    readonly lockRun: (runId: string) => Effect.Effect<void, SqlError, SqlClient.SqlClient>;
+    readonly lockMailbox: (targetSessionId: string) => Effect.Effect<void, SqlError, SqlClient.SqlClient>;
+}) => Pick<RunStoreInterface, "directory" | "resolveAddress" | "registerAgentName" | "listRelated" | "admitMessage" | "pendingMessages" | "deliverPendingMessages">;

package/dist/postgres/store-messaging.js

@@ -0,0 +1,12 @@
+import { Effect } from "effect";
+import { admitMessage, deliverPendingMessages, directory, listRelated, pendingMessages, registerAgentName, resolveAddress, } from "tenetkit/runtime/driver/sql/store-directory";
+/** The addressed-messaging half of the Postgres RunStore, kept beside the store it completes. */
+export const messagingStoreMethods = (input) => ({
+    directory: (runId) => input.runNoTxn(directory(runId)),
+    resolveAddress: (address) => input.runNoTxn(resolveAddress(address)),
+    registerAgentName: (request) => input.run(input.lockRun(request.runId).pipe(Effect.andThen(registerAgentName(request)))),
+    listRelated: (runId) => input.runNoTxn(listRelated(runId)),
+    admitMessage: (request) => input.run(input.lockMailbox(request.targetSessionId).pipe(Effect.andThen(admitMessage(request)))),
+    pendingMessages: (request) => input.runNoTxn(pendingMessages(request)),
+    deliverPendingMessages: (request) => input.run(input.lockRun(request.runId).pipe(Effect.andThen(directory(request.runId)), Effect.flatMap((entry) => input.lockMailbox(entry.sessionId)), Effect.andThen(deliverPendingMessages(input.hub, request)))),
+});

package/dist/postgres/store-model-response.d.ts

@@ -0,0 +1,18 @@
+import { Effect } from "effect";
+import type { PgClient } from "@effect/sql-pg";
+import { SqlClient } from "effect/unstable/sql";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+import { RuntimeUnavailable, type RunNotFound } from "tenetkit/runtime/driver/errors";
+import type { Interface as RunStoreInterface } from "tenetkit/runtime/driver/run-store";
+import type { DecodedRun } from "tenetkit/runtime/driver/sql/rows";
+import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
+import type { RunFn } from "./store-ops.js";
+type SqlR = SqlClient.SqlClient | PgClient.PgClient;
+export declare const postgresModelResponseOperations: (input: {
+    readonly sql: SqlClient.SqlClient;
+    readonly hub: EventHub;
+    readonly run: RunFn;
+    readonly requireRun: (runId: string) => Effect.Effect<DecodedRun, RunNotFound | RuntimeUnavailable | SqlError, SqlR>;
+    readonly requireClaim: (claim: import("tenetkit/runtime/driver/run-store").ExecutionClaim) => Effect.Effect<void, import("tenetkit/runtime/driver/sql/errors").StaleClaim | RunNotFound | RuntimeUnavailable | SqlError, SqlR>;
+}) => Pick<RunStoreInterface, "commitModelResponse" | "commitInterruptedModelResponse">;
+export {};

package/dist/postgres/store-model-response.js

@@ -0,0 +1,156 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import { RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
+import { appendEvent, loadEventsAfter, toOperationRecord } from "./pg-helpers.js";
+import { encodeExecutableRef, encodeJson, encodeJsonValue } from "tenetkit/runtime/driver/sql/codecs";
+import { ExecutionCheckpoint } from "tenetkit/runtime/driver/execution-state";
+import { encodeContinuation } from "tenetkit/runtime/driver/steering";
+import { checkpointRef } from "tenetkit/runtime/driver/executable-manifest";
+import { sameModelResponseEvent, validateModelResponseCommit } from "tenetkit/runtime/driver/model-response-commit";
+import { sameInterruptedModelOutcome, sameInterruptedModelResponse, validateInterruptedModelResponse, } from "tenetkit/runtime/driver/model-response-interrupted";
+import { appendCompletedSessionEntry, appendInterruptedSessionEntry, verifyCompletedSessionEntry, verifyInterruptedSessionEntry, } from "./session-store.js";
+export const postgresModelResponseOperations = (input) => {
+    const { sql, hub, run, requireRun, requireClaim } = input;
+    const fenced = (claim, effect) => run(sql `SELECT run_id FROM baton_runs WHERE run_id = ${claim.runId} FOR UPDATE`.pipe(Effect.andThen(requireClaim(claim)), Effect.andThen(effect)));
+    return {
+        commitInterruptedModelResponse: (op) => fenced(op, Effect.gen(function* () {
+            const loaded = yield* requireRun(op.runId);
+            const rows = yield* sql `
+            SELECT * FROM baton_run_operations
+            WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+            FOR UPDATE
+          `;
+            const row = rows[0];
+            if (row === undefined)
+                return yield* RuntimeUnavailable.make({ message: "operation missing" });
+            const current = toOperationRecord(row);
+            const validated = validateInterruptedModelResponse({
+                runId: op.runId,
+                sessionId: loaded.message.sessionId,
+                record: current,
+                outcome: op.outcome,
+                event: op.event,
+            });
+            if (Schema.is(RuntimeUnavailable)(validated))
+                return yield* validated;
+            const sessionEntry = validated.entry;
+            if (current.status === "failed") {
+                if (!sameInterruptedModelOutcome({ left: { _tag: "Failed", error: current.error }, right: op.outcome })) {
+                    return yield* RuntimeUnavailable.make({
+                        message: `model operation ${op.operationId} has a divergent interrupted outcome retry`,
+                    });
+                }
+                const prior = (yield* loadEventsAfter(op.runId, -1)).filter((event) => event._tag === "ModelResponseInterrupted" && event.operationKey === op.event.operationKey);
+                if (prior.length !== 1 ||
+                    prior[0]?._tag !== "ModelResponseInterrupted" ||
+                    !sameInterruptedModelResponse({ left: prior[0], right: validated.event })) {
+                    return yield* RuntimeUnavailable.make({
+                        message: `model operation ${op.operationId} has a divergent interrupted outbox retry`,
+                    });
+                }
+                yield* verifyInterruptedSessionEntry(sessionEntry).pipe(Effect.mapError((error) => RuntimeUnavailable.make({ message: error.message })));
+                return current;
+            }
+            if (current.status !== "running") {
+                return yield* RuntimeUnavailable.make({
+                    message: `model operation ${op.operationId} cannot commit an interruption from ${current.status}`,
+                });
+            }
+            yield* appendInterruptedSessionEntry(sessionEntry).pipe(Effect.mapError((error) => RuntimeUnavailable.make({ message: error.message })));
+            yield* sql `
+            UPDATE baton_run_operations
+            SET status = 'failed', error_json = ${encodeJsonValue(op.outcome.error)}, finished_at = NOW()
+            WHERE run_id = ${op.runId} AND operation_id = ${op.operationId} AND status = 'running'
+          `;
+            yield* appendEvent(hub, yield* requireRun(op.runId), validated.event);
+            const completed = yield* sql `
+            SELECT * FROM baton_run_operations WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+          `;
+            return toOperationRecord(completed[0]);
+        })),
+        commitModelResponse: (op) => fenced(op, Effect.gen(function* () {
+            const loaded = yield* requireRun(op.runId);
+            const existing = yield* sql `
+            SELECT * FROM baton_run_operations
+            WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+            FOR UPDATE
+          `;
+            const row = existing[0];
+            if (row === undefined)
+                return yield* RuntimeUnavailable.make({ message: "operation missing" });
+            const current = toOperationRecord(row);
+            const validated = validateModelResponseCommit({
+                record: current,
+                input: op,
+                sessionId: loaded.message.sessionId,
+            });
+            if (Schema.is(RuntimeUnavailable)(validated))
+                return yield* validated;
+            const sessionEntry = validated.entry;
+            if (current.status === "succeeded") {
+                const priorValidation = validateModelResponseCommit({
+                    record: current,
+                    input: {
+                        ...op,
+                        outcome: { _tag: "Succeeded", value: current.result },
+                    },
+                    sessionId: loaded.message.sessionId,
+                });
+                if (Schema.is(RuntimeUnavailable)(priorValidation))
+                    return yield* priorValidation;
+                const prior = (yield* loadEventsAfter(op.runId, -1)).filter((event) => event._tag === "ModelResponseCommitted" && event.operationKey === op.event.operationKey);
+                if (prior.length !== 1 ||
+                    prior[0]?._tag !== "ModelResponseCommitted" ||
+                    !sameModelResponseEvent({ left: prior[0], right: validated.event })) {
+                    return yield* RuntimeUnavailable.make({
+                        message: `model operation ${op.operationId} has a divergent outbox retry`,
+                    });
+                }
+                yield* verifyCompletedSessionEntry(sessionEntry).pipe(Effect.mapError((error) => RuntimeUnavailable.make({ message: error.message })));
+                return current;
+            }
+            if (current.status === "failed" || current.status === "unknown") {
+                return yield* RuntimeUnavailable.make({
+                    message: `model operation ${op.operationId} already completed as ${current.status}`,
+                });
+            }
+            for (const entryId of new Set(op.steeringEntryIds ?? [])) {
+                const rows = yield* sql `
+              SELECT consumed_operation_id FROM baton_run_steering
+              WHERE run_id = ${op.runId} AND entry_id = ${entryId}
+            `;
+                if (rows[0]?.consumed_operation_id !== op.operationId) {
+                    return yield* RuntimeUnavailable.make({
+                        message: `steering entry ${entryId} does not belong to operation`,
+                    });
+                }
+            }
+            const executableRef = yield* Effect.try({
+                try: () => checkpointRef(loaded.executableRef, loaded.executableManifest, op.checkpoint),
+                catch: (error) => RuntimeUnavailable.make({ message: String(error) }),
+            });
+            yield* appendCompletedSessionEntry(sessionEntry).pipe(Effect.mapError((error) => RuntimeUnavailable.make({ message: error.message })));
+            yield* sql `
+            UPDATE baton_run_operations
+            SET status = 'succeeded', result_json = ${encodeJsonValue(validated.reference)}, finished_at = NOW()
+            WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+              AND status IN ('requested', 'running')
+          `;
+            yield* sql `
+            UPDATE baton_runs SET
+              driver_checkpoint_json = COALESCE(${op.checkpoint === undefined ? null : encodeJson(ExecutionCheckpoint, op.checkpoint)}, driver_checkpoint_json),
+              executable_ref_json = ${encodeExecutableRef(executableRef)},
+              continuation_json = CASE WHEN ${op.continuation === undefined ? 0 : 1} = 1
+                THEN ${op.continuation === null || op.continuation === undefined ? null : encodeContinuation(op.continuation)}
+                ELSE continuation_json END,
+              updated_at = NOW()
+            WHERE run_id = ${op.runId}
+          `;
+            yield* appendEvent(hub, yield* requireRun(op.runId), validated.event);
+            const rows = yield* sql `
+            SELECT * FROM baton_run_operations WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+          `;
+            return toOperationRecord(rows[0]);
+        })),
+    };
+};

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

@@ -0,0 +1,21 @@
+import { Effect } from "effect";
+import type { PgClient } from "@effect/sql-pg";
+import { SqlClient } from "effect/unstable/sql";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+import { RunNotFound, RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
+import type { Interface as RunStoreInterface } from "tenetkit/runtime/driver/run-store";
+import type { DecodedRun } from "tenetkit/runtime/driver/sql/rows";
+import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
+import type { WithoutSqlError } from "tenetkit/runtime/driver/sql/sql-effect";
+type SqlR = SqlClient.SqlClient | PgClient.PgClient;
+export type RunFn = <A, E>(effect: Effect.Effect<A, E | SqlError, SqlR>) => Effect.Effect<A, WithoutSqlError<E | SqlError> | RuntimeUnavailable>;
+export declare const postgresOperations: (input: {
+    readonly sql: SqlClient.SqlClient;
+    readonly hub: EventHub;
+    readonly run: RunFn;
+    readonly runNoTxn: RunFn;
+    readonly requireRun: (runId: string) => Effect.Effect<DecodedRun, RunNotFound | RuntimeUnavailable | SqlError, SqlR>;
+    readonly requireClaim: (claim: import("tenetkit/runtime/driver/run-store").ExecutionClaim) => Effect.Effect<void, import("tenetkit/runtime/driver/sql/errors").StaleClaim | RunNotFound | RuntimeUnavailable | SqlError, SqlR>;
+    readonly nextId: (prefix: string) => Effect.Effect<string>;
+}) => Pick<RunStoreInterface, "recordOperation" | "startOperation" | "completeOperation" | "commitModelResponse" | "commitInterruptedModelResponse" | "expireRunningOperation" | "getOperation" | "getOperationByKey" | "resolveOperation">;
+export {};