@osolmaz/pi-workflows 0.16.5 → 0.16.7

package/dist/server/state.js

@@ -1,14 +1,17 @@
 import { createHash, randomBytes } from "node:crypto";
 import { CLIENT_PROTOCOL_SCHEMA, clientRequestFingerprint, } from "../client/protocol.js";
+import { AttemptTime } from "../state/attempt-time.js";
 import { StateDatabase } from "../state/database.js";
 import { canonicalJson } from "../state/json.js";
 import { tokenHash } from "../state/mutation.js";
 import { WorkflowMessageStore, workflowMessageIdFor, } from "../state/workflow-messages.js";
-import { decisionWorkflowMessageContent, stepWorkflowMessageContent, } from "../workflows/workflow-message-content.js";
+import { ensureWorkflowRequest, readWorkflowRequest, recordWorkflowSubmission, } from "../workflows/requests.js";
+import { decisionWorkflowMessageContent, checkpointWorkflowMessageContent, stepWorkflowMessageContent, } from "../workflows/workflow-message-content.js";
 export class ServerStateStore {
     state;
     ownsState;
     workflowMessages;
+    attemptTime;
     constructor(databasePath, options = {}) {
         this.ownsState = options.state === undefined;
         this.state =
@@ -18,6 +21,7 @@ export class ServerStateStore {
                     mode: options.readOnly === true ? "read-only" : "read-write",
                 });
         this.workflowMessages = new WorkflowMessageStore(this.state);
+        this.attemptTime = new AttemptTime(this.state, options.clock);
     }
     close() {
         if (this.ownsState)
@@ -234,48 +238,21 @@ export class ServerStateStore {
         });
     }
     createInteractiveRequest(options) {
-        const now = Date.now();
         return this.state.transaction(() => {
-            const existing = this.interactiveRequest(options.requestId);
-            if (existing !== undefined) {
-                if (existing.runId !== options.runId ||
-                    existing.attemptId !== options.attemptId ||
-                    canonicalJson(existing.contract) !== canonicalJson(options.contract)) {
-                    throw new Error(`Interactive request conflicts: ${options.requestId}`);
-                }
-                if (existing.status === "settled" && existing.consumedAt === null) {
-                    this.state.connection
-                        .prepare(`UPDATE interactive_requests
-               SET status = 'pending', accepted_submission_id = NULL,
-                   settled_at = NULL, consumed_at = NULL, revision = revision + 1, updated_at = ?
-               WHERE request_id = ? AND status = 'settled' AND consumed_at IS NULL`)
-                        .run(now, options.requestId);
-                    const reopened = this.requireInteractiveRequest(options.requestId);
-                    this.ensureInteractionMessage(reopened, "resumed", now);
-                    return reopened;
-                }
-                if (existing.status === "pending")
-                    this.ensureInteractionMessage(existing, "initial", now);
-                return existing;
-            }
-            const contractHash = this.state.putJson(options.contract, now);
-            this.state.connection
-                .prepare(`INSERT INTO interactive_requests(
-             request_id, run_id, attempt_id, target_session_id, kind, contract_hash,
-             revision, status, created_at, updated_at
-           ) VALUES (?, ?, ?, ?, ?, ?, 1, 'pending', ?, ?)`)
-                .run(options.requestId, options.runId, options.attemptId, options.targetSessionId, options.kind, contractHash, now, now);
-            const created = this.requireInteractiveRequest(options.requestId);
-            this.ensureInteractionMessage(created, "initial", now);
-            return created;
+            const request = ensureWorkflowRequest(this.state, options);
+            if (request.status === "pending")
+                this.ensureInteractionMessage(request, "initial");
+            return request;
         });
     }
     ensureInteractionMessage(request, reason, now = Date.now()) {
-        const kind = request.kind === "decision" ? "decision" : "step";
+        const kind = request.kind === "decision" || request.kind === "checkpoint" ? "decision" : "step";
         const idempotencyKey = `${request.revision}:${reason}`;
         const workflowMessageId = workflowMessageIdFor(kind, request.requestId, idempotencyKey);
         const content = kind === "decision"
-            ? decisionWorkflowMessageContent({
+            ? (request.kind === "checkpoint"
+                ? checkpointWorkflowMessageContent
+                : decisionWorkflowMessageContent)({
                 workflowMessageId,
                 requestId: request.requestId,
                 runId: request.runId,
@@ -307,7 +284,7 @@ export class ServerStateStore {
             if (!isRequestIdRow(row))
                 throw new Error("Pending workflow interaction is missing");
             const current = this.requireInteractiveRequest(row.requestId);
-            if (current.kind === "decision")
+            if (current.kind === "decision" || current.kind === "checkpoint")
                 return current;
             this.workflowMessages.cancelPendingForSource(current.requestId, "step", now);
             const changed = this.state.connection
@@ -321,113 +298,77 @@ export class ServerStateStore {
             return request;
         });
     }
-    beginInteractionModelTurn(requestId, now = Date.now()) {
-        const row = this.state.connection
-            .prepare(`SELECT i.attempt_id AS attemptId, i.created_at AS createdAt,
-                a.started_at AS startedAt, a.deadline_at AS deadlineAt,
-                (SELECT MAX(t.ended_at)
-                 FROM workflow_messages m
-                 JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id
-                 WHERE m.source_id = i.request_id AND m.kind = 'step'
-                   AND t.state = 'ended') AS previousTurnEndedAt
-         FROM interactive_requests i
-         JOIN node_attempts a ON a.attempt_id = i.attempt_id
-         WHERE i.request_id = ? AND i.status = 'pending'`)
-            .get(requestId);
-        if (!isInteractionTimeoutRow(row)) {
-            throw new Error("Pending workflow interaction timeout is missing");
+    syncActiveTime() {
+        this.attemptTime.sample();
+    }
+    beginInteractionModelTurn(requestId) {
+        const request = this.requireInteractiveRequest(requestId);
+        if (request.status !== "pending" || !["agent", "assistant"].includes(request.kind)) {
+            throw new Error("Only a pending agent request can start active model time");
         }
-        this.shiftInteractionTimeout(row, Math.max(0, now - (row.previousTurnEndedAt ?? row.startedAt ?? row.createdAt)), now);
+        const run = this.state.connection
+            .prepare("SELECT paused FROM runs WHERE run_id = ?")
+            .get(request.runId);
+        if (run.paused !== 0)
+            throw new Error("Paused workflow cannot start active model time");
+        this.attemptTime.start(request.attemptId);
     }
-    interactionPauseStartedAt(runId) {
-        const row = this.state.connection
-            .prepare(`SELECT r.updated_at AS pausedAt
-         FROM runs r
-         JOIN interactive_requests i ON i.run_id = r.run_id AND i.status = 'pending'
-         WHERE r.run_id = ? AND r.paused = 1 LIMIT 1`)
-            .get(runId);
-        return isPausedAtRow(row) ? row.pausedAt : undefined;
+    endInteractionModelTurn(requestId) {
+        this.attemptTime.stop(this.requireInteractiveRequest(requestId).attemptId);
     }
-    resumeInteractionModelTurn(runId, pausedAt, now = Date.now()) {
-        if (pausedAt === undefined)
-            return;
-        const row = this.state.connection
-            .prepare(`SELECT i.attempt_id AS attemptId, i.created_at AS createdAt,
-                a.started_at AS startedAt, a.deadline_at AS deadlineAt,
-                t.ended_at AS previousTurnEndedAt
-         FROM interactive_requests i
-         JOIN node_attempts a ON a.attempt_id = i.attempt_id
-         JOIN workflow_messages m ON m.source_id = i.request_id AND m.kind = 'step'
-         JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id
-         WHERE i.run_id = ? AND i.status = 'pending' AND t.started_at <= ?
-           AND (t.ended_at IS NULL OR t.ended_at > ?)
-         ORDER BY t.started_at DESC LIMIT 1`)
-            .get(runId, pausedAt, pausedAt);
-        if (!isInteractionTimeoutRow(row))
-            return;
-        const modelTurnStoppedAt = Math.min(now, row.previousTurnEndedAt ?? now);
-        this.shiftInteractionTimeout(row, Math.max(0, modelTurnStoppedAt - pausedAt), now);
+    resumeInteractionModelTurn(runId) {
+        const rows = this.state.connection
+            .prepare(`SELECT DISTINCT i.attempt_id AS attemptId FROM interactive_requests i
+       JOIN runs r ON r.run_id = i.run_id
+       JOIN workflow_messages m ON m.source_id = i.request_id AND m.kind = 'step'
+       JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id AND t.state = 'started'
+       WHERE i.run_id = ? AND i.status = 'pending' AND r.paused = 0`)
+            .all(runId);
+        for (const row of rows) {
+            this.attemptTime.start(row.attemptId);
+            this.state.connection
+                .prepare("UPDATE node_attempts SET status = 'waiting' WHERE attempt_id = ?")
+                .run(row.attemptId);
+        }
     }
     markSessionModelTurnsInactive(targetSessionId, now = Date.now()) {
-        this.state.connection
-            .prepare(`UPDATE node_attempts SET status = 'interrupted', updated_at = ?
-         WHERE status <> 'interrupted' AND attempt_id IN (
-           SELECT DISTINCT i.attempt_id
-           FROM interactive_requests i
-           JOIN workflow_messages m ON m.source_id = i.request_id AND m.kind = 'step'
-           JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id
-                                AND t.state = 'started'
-           WHERE i.target_session_id = ? AND i.status = 'pending'
-         )`)
-            .run(now, targetSessionId);
-    }
-    recoverInactiveModelTurns(previousHeartbeatAt, now = Date.now()) {
         const rows = this.state.connection
-            .prepare(`SELECT i.attempt_id AS attemptId, a.status, a.started_at AS startedAt,
-                a.deadline_at AS deadlineAt, a.updated_at AS updatedAt,
-                MAX(t.started_at) AS turnStartedAt
-         FROM interactive_requests i
-         JOIN node_attempts a ON a.attempt_id = i.attempt_id
-         JOIN workflow_messages m ON m.source_id = i.request_id AND m.kind = 'step'
-         JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id
-                              AND t.state = 'started'
-         WHERE i.status = 'pending'
-         GROUP BY i.attempt_id`)
-            .all()
-            .filter(isInactiveInteractionTimeoutRow);
+            .prepare(`SELECT DISTINCT i.attempt_id AS attemptId FROM interactive_requests i
+       JOIN workflow_messages m ON m.source_id = i.request_id AND m.kind = 'step'
+       JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id AND t.state = 'started'
+       WHERE i.target_session_id = ? AND i.status = 'pending'`)
+            .all(targetSessionId);
         for (const row of rows) {
-            const inactiveAt = row.status === "interrupted"
-                ? row.updatedAt
-                : previousHeartbeatAt === undefined
-                    ? row.updatedAt
-                    : Math.max(previousHeartbeatAt, row.turnStartedAt);
-            this.shiftInteractionTimeout(row, Math.max(0, now - inactiveAt), now);
+            this.attemptTime.stop(row.attemptId);
             this.state.connection
-                .prepare(`UPDATE node_attempts SET status = 'interrupted', updated_at = ?
-           WHERE attempt_id = ? AND status IN ('pending', 'running', 'waiting', 'interrupted')`)
+                .prepare("UPDATE node_attempts SET status = 'interrupted', updated_at = ? WHERE attempt_id = ?")
                 .run(now, row.attemptId);
         }
     }
+    recoverInactiveModelTurns(now = Date.now()) {
+        this.attemptTime.recover();
+        this.state.connection
+            .prepare(`UPDATE node_attempts SET status = 'interrupted', updated_at = ? WHERE attempt_id IN (
+         SELECT i.attempt_id FROM interactive_requests i
+         JOIN workflow_messages m ON m.source_id = i.request_id AND m.kind = 'step'
+         JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id AND t.state = 'started'
+         WHERE i.status = 'pending'
+       )`)
+            .run(now);
+    }
     resumeSessionModelTurns(targetSessionId, now = Date.now()) {
         const rows = this.state.connection
-            .prepare(`SELECT i.attempt_id AS attemptId, a.status, a.started_at AS startedAt,
-                a.deadline_at AS deadlineAt, a.updated_at AS updatedAt,
-                MAX(t.started_at) AS turnStartedAt
-         FROM interactive_requests i
-         JOIN node_attempts a ON a.attempt_id = i.attempt_id
-         JOIN workflow_messages m ON m.source_id = i.request_id AND m.kind = 'step'
-         JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id
-                              AND t.state = 'started'
-         WHERE i.target_session_id = ? AND i.status = 'pending'
-           AND a.status = 'interrupted'
-         GROUP BY i.attempt_id`)
-            .all(targetSessionId)
-            .filter(isInactiveInteractionTimeoutRow);
+            .prepare(`SELECT DISTINCT i.attempt_id AS attemptId FROM interactive_requests i
+       JOIN runs r ON r.run_id = i.run_id
+       JOIN node_attempts a ON a.attempt_id = i.attempt_id
+       JOIN workflow_messages m ON m.source_id = i.request_id AND m.kind = 'step'
+       JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id AND t.state = 'started'
+       WHERE i.target_session_id = ? AND i.status = 'pending' AND r.paused = 0 AND a.status = 'interrupted'`)
+            .all(targetSessionId);
         for (const row of rows) {
-            this.shiftInteractionTimeout(row, Math.max(0, now - row.updatedAt), now);
+            this.attemptTime.start(row.attemptId);
             this.state.connection
-                .prepare(`UPDATE node_attempts SET status = 'waiting', updated_at = ?
-           WHERE attempt_id = ? AND status = 'interrupted'`)
+                .prepare("UPDATE node_attempts SET status = 'waiting', updated_at = ? WHERE attempt_id = ?")
                 .run(now, row.attemptId);
         }
     }
@@ -475,55 +416,51 @@ export class ServerStateStore {
             payload: this.state.readJson(row.payloadHash),
         };
     }
-    validatingInteractionRunIds() {
+    readyInteractionRunIds() {
         return this.state.connection
             .prepare(`SELECT i.run_id AS runId
          FROM interactive_requests i
          JOIN interactive_submissions s ON s.request_id = i.request_id
          JOIN run_queue q ON q.run_id = i.run_id
-         WHERE i.status = 'pending' AND s.outcome = 'validating'
+         JOIN node_attempts a ON a.attempt_id = i.attempt_id
+         WHERE ((i.status = 'pending' AND s.outcome = 'validating')
+             OR (i.status = 'settled' AND i.accepted_submission_id = s.submission_id
+                 AND s.outcome = 'accepted' AND i.consumed_at IS NULL))
+           AND a.status IN ('pending', 'running', 'waiting', 'interrupted')
            AND q.status NOT IN ('done', 'failed', 'cancelled')
          GROUP BY i.run_id
          ORDER BY MIN(s.submitted_at), i.run_id`)
             .all()
             .flatMap((row) => (isRunIdRow(row) ? [row.runId] : []));
     }
-    expiredInteractionRuns(now = Date.now()) {
+    expiredInteractionRuns() {
         return this.state.connection
             .prepare(`SELECT i.run_id AS runId, i.target_session_id AS targetSessionId
-         FROM interactive_requests i
-         JOIN node_attempts a ON a.attempt_id = i.attempt_id
-         JOIN runs r ON r.run_id = i.run_id
-         JOIN run_queue q ON q.run_id = i.run_id
-         WHERE i.status = 'pending' AND r.paused = 0
-           AND a.deadline_at IS NOT NULL AND a.deadline_at <= ?
-           AND q.status NOT IN ('done', 'failed', 'cancelled')
-           AND EXISTS (
-             SELECT 1 FROM workflow_messages m
-             JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id
-             WHERE m.source_id = i.request_id AND m.kind = 'step' AND t.state = 'started'
-           )
-         GROUP BY i.run_id, i.target_session_id
-         ORDER BY MIN(a.deadline_at), i.run_id`)
-            .all(now)
+       FROM interactive_requests i
+       JOIN node_attempts a ON a.attempt_id = i.attempt_id
+       JOIN runs r ON r.run_id = i.run_id
+       JOIN run_queue q ON q.run_id = i.run_id
+       WHERE i.status = 'pending' AND r.paused = 0 AND a.timeout_ms > 0
+         AND (SELECT COALESCE(SUM(elapsed_ms), 0) FROM attempt_active_intervals t
+              WHERE t.attempt_id = a.attempt_id) >= a.timeout_ms
+         AND q.status NOT IN ('done', 'failed', 'cancelled')
+       GROUP BY i.run_id, i.target_session_id ORDER BY MIN(a.started_at), i.run_id`)
+            .all()
             .filter(isExpiredInteractionRunRow);
     }
     timedOutInteraction(runId) {
         const row = this.state.connection
             .prepare(`SELECT i.request_id AS requestId, i.attempt_id AS attemptId, a.node_id AS nodeId
-         FROM interactive_requests i
-         JOIN node_attempts a ON a.attempt_id = i.attempt_id
-         JOIN runs r ON r.run_id = i.run_id
-         WHERE i.run_id = ? AND i.status = 'cancelled' AND r.status = 'running'
-           AND r.paused = 0 AND a.deadline_at IS NOT NULL AND a.deadline_at <= ?
-           AND a.status IN ('pending', 'running', 'waiting', 'interrupted', 'timed_out')
-           AND EXISTS (
-             SELECT 1 FROM workflow_messages m
-             JOIN workflow_turns t ON t.workflow_message_id = m.workflow_message_id
-             WHERE m.source_id = i.request_id AND m.kind = 'step' AND t.state = 'started'
-           )
-         ORDER BY a.deadline_at, i.request_id LIMIT 1`)
-            .get(runId, Date.now());
+       FROM interactive_requests i
+       JOIN node_attempts a ON a.attempt_id = i.attempt_id
+       JOIN runs r ON r.run_id = i.run_id
+       WHERE i.run_id = ? AND i.status = 'cancelled' AND r.status = 'running'
+         AND r.paused = 0 AND a.timeout_ms > 0
+         AND (SELECT COALESCE(SUM(elapsed_ms), 0) FROM attempt_active_intervals t
+              WHERE t.attempt_id = a.attempt_id) >= a.timeout_ms
+         AND a.status IN ('pending', 'running', 'waiting', 'interrupted', 'timed_out')
+       ORDER BY a.started_at, i.request_id LIMIT 1`)
+            .get(runId);
         return isTimedOutInteractionRow(row) ? row : undefined;
     }
     interactionSubmission(requestId, submissionId) {
@@ -579,14 +516,6 @@ export class ServerStateStore {
             return settled;
         });
     }
-    consumeAcceptedInteraction(runId, attemptId, now = Date.now()) {
-        const changed = this.state.connection
-            .prepare(`UPDATE interactive_requests SET consumed_at = ?, updated_at = ?
-         WHERE run_id = ? AND attempt_id = ? AND status = 'settled'
-           AND accepted_submission_id IS NOT NULL AND consumed_at IS NULL`)
-            .run(now, now, runId, attemptId);
-        return changed.changes === 1;
-    }
     listPendingInteractions(sessionId) {
         return this.state.connection
             .prepare(`SELECT request_id AS requestId FROM interactive_requests
@@ -604,83 +533,24 @@ export class ServerStateStore {
             .flatMap((row) => isRequestIdRow(row) ? [this.requireInteractiveRequest(row.requestId)] : []);
     }
     submitInteraction(options) {
-        return this.recordInteractionSubmission({
+        return recordWorkflowSubmission(this.state, {
             ...options,
             outcome: options.accepted ? "accepted" : "rejected",
             settle: options.accepted,
         });
     }
+    hasInteractionSubmission(requestId, idempotencyKey) {
+        return (this.state.connection
+            .prepare("SELECT 1 FROM interactive_submissions WHERE request_id = ? AND idempotency_key = ?")
+            .get(requestId, idempotencyKey) !== undefined);
+    }
     beginInteractionValidation(options) {
-        return this.recordInteractionSubmission({
+        return recordWorkflowSubmission(this.state, {
             ...options,
             outcome: "validating",
             settle: false,
         });
     }
-    recordInteractionSubmission(options) {
-        const now = Date.now();
-        return this.state.transaction(() => {
-            const existing = this.state.connection
-                .prepare(`SELECT submission_id AS submissionId, payload_hash AS payloadHash,
-                  outcome, receipt_hash AS receiptHash
-           FROM interactive_submissions WHERE request_id = ? AND idempotency_key = ?`)
-                .get(options.requestId, options.idempotencyKey);
-            const payloadHash = createHash("sha256").update(canonicalJson(options.payload)).digest();
-            if (isSubmissionRow(existing)) {
-                if (!existing.payloadHash.equals(payloadHash)) {
-                    throw new Error("Interactive submission idempotency key conflicts");
-                }
-                return {
-                    interaction: this.requireInteractiveRequest(options.requestId),
-                    submissionId: existing.submissionId,
-                    outcome: "adopted",
-                    receipt: existing.receiptHash === null
-                        ? { requestId: options.requestId, submissionId: existing.submissionId }
-                        : this.state.readJson(existing.receiptHash),
-                };
-            }
-            if (options.outcome === "validating") {
-                const active = this.state.connection
-                    .prepare(`SELECT submission_id AS submissionId FROM interactive_submissions
-             WHERE request_id = ? AND outcome = 'validating' LIMIT 1`)
-                    .get(options.requestId);
-                if (isSubmissionIdRow(active)) {
-                    throw new Error("Interactive submission validation is already active");
-                }
-            }
-            const request = this.requireInteractiveRequest(options.requestId);
-            if (request.revision !== options.expectedRevision || request.status !== "pending") {
-                throw new Error("Interactive request revision conflict");
-            }
-            const savedPayloadHash = this.state.putJson(options.payload, now);
-            const receiptHash = options.receipt === undefined ? null : this.state.putJson(options.receipt, now);
-            this.state.connection
-                .prepare(`INSERT INTO interactive_submissions(
-             submission_id, request_id, idempotency_key, request_revision,
-             payload_hash, outcome, receipt_hash, submitted_at
-           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
-                .run(options.submissionId, options.requestId, options.idempotencyKey, options.expectedRevision, savedPayloadHash, options.outcome, receiptHash, now);
-            if (options.settle) {
-                this.state.connection
-                    .prepare(`UPDATE interactive_requests
-             SET status = 'settled', accepted_submission_id = ?, revision = revision + 1,
-                 updated_at = ?, settled_at = ?
-             WHERE request_id = ? AND revision = ? AND status = 'pending'`)
-                    .run(options.submissionId, now, now, options.requestId, options.expectedRevision);
-                this.workflowMessages.cancelPendingForSource(options.requestId, "step", now);
-                this.workflowMessages.cancelPendingForSource(options.requestId, "decision", now);
-            }
-            return {
-                interaction: this.requireInteractiveRequest(options.requestId),
-                submissionId: options.submissionId,
-                outcome: "accepted",
-                receipt: options.receipt ?? {
-                    requestId: options.requestId,
-                    submissionId: options.submissionId,
-                },
-            };
-        });
-    }
     serverRow() {
         const row = this.state.connection
             .prepare(`SELECT epoch, host_id AS serverId, token_hash AS tokenHash, pid,
@@ -708,44 +578,7 @@ export class ServerStateStore {
         };
     }
     interactiveRequest(requestId) {
-        const row = this.state.connection
-            .prepare(`SELECT request_id AS requestId, run_id AS runId, attempt_id AS attemptId,
-                target_session_id AS targetSessionId, kind, contract_hash AS contractHash,
-                revision, status, unproductive_turn_ends AS unproductiveTurnEnds,
-                accepted_submission_id AS acceptedSubmissionId, created_at AS createdAt,
-                updated_at AS updatedAt, settled_at AS settledAt, consumed_at AS consumedAt
-         FROM interactive_requests WHERE request_id = ?`)
-            .get(requestId);
-        if (!isInteractiveRequestRow(row))
-            return undefined;
-        return {
-            requestId: row.requestId,
-            runId: row.runId,
-            attemptId: row.attemptId,
-            targetSessionId: row.targetSessionId,
-            kind: row.kind,
-            contract: this.state.readJson(row.contractHash),
-            revision: row.revision,
-            status: row.status,
-            unproductiveTurnEnds: row.unproductiveTurnEnds,
-            acceptedSubmissionId: row.acceptedSubmissionId,
-            createdAt: new Date(row.createdAt).toISOString(),
-            updatedAt: new Date(row.updatedAt).toISOString(),
-            settledAt: iso(row.settledAt),
-            consumedAt: iso(row.consumedAt),
-        };
-    }
-    shiftInteractionTimeout(row, idleMs, now) {
-        if (idleMs === 0 || row.deadlineAt === null)
-            return;
-        const changed = this.state.connection
-            .prepare(`UPDATE node_attempts
-         SET started_at = CASE WHEN started_at IS NULL THEN NULL ELSE started_at + ? END,
-             deadline_at = deadline_at + ?, updated_at = ?
-         WHERE attempt_id = ? AND deadline_at = ?`)
-            .run(idleMs, idleMs, now, row.attemptId, row.deadlineAt);
-        if (changed.changes !== 1)
-            throw new Error("Workflow interaction timeout changed concurrently");
+        return readWorkflowRequest(this.state, requestId);
     }
     requireInteractiveRequest(requestId) {
         const request = this.interactiveRequest(requestId);
@@ -822,39 +655,9 @@ function isTimedOutInteractionRow(value) {
         typeof value.attemptId === "string" &&
         typeof value.nodeId === "string");
 }
-function isInteractionTimeoutRow(value) {
-    return (isRecord(value) &&
-        typeof value.attemptId === "string" &&
-        typeof value.createdAt === "number" &&
-        nullableNumber(value.startedAt) &&
-        nullableNumber(value.deadlineAt) &&
-        nullableNumber(value.previousTurnEndedAt));
-}
-function isInactiveInteractionTimeoutRow(value) {
-    return (isRecord(value) &&
-        typeof value.attemptId === "string" &&
-        ["pending", "running", "waiting", "interrupted"].includes(value.status) &&
-        nullableNumber(value.startedAt) &&
-        nullableNumber(value.deadlineAt) &&
-        typeof value.updatedAt === "number" &&
-        typeof value.turnStartedAt === "number");
-}
 function isExpiredInteractionRunRow(value) {
     return (isRecord(value) && typeof value.runId === "string" && typeof value.targetSessionId === "string");
 }
-function isPausedAtRow(value) {
-    return isRecord(value) && typeof value.pausedAt === "number";
-}
-function isSubmissionRow(value) {
-    return (isRecord(value) &&
-        typeof value.submissionId === "string" &&
-        Buffer.isBuffer(value.payloadHash) &&
-        typeof value.outcome === "string" &&
-        (value.receiptHash === null || Buffer.isBuffer(value.receiptHash)));
-}
-function isSubmissionIdRow(value) {
-    return isRecord(value) && typeof value.submissionId === "string";
-}
 function isSubmissionDetailRow(value) {
     return (isRecord(value) &&
         typeof value.requestId === "string" &&
@@ -865,23 +668,6 @@ function isSubmissionDetailRow(value) {
         (value.receiptHash === null || Buffer.isBuffer(value.receiptHash)) &&
         typeof value.submittedAt === "number");
 }
-function isInteractiveRequestRow(value) {
-    return (isRecord(value) &&
-        typeof value.requestId === "string" &&
-        typeof value.runId === "string" &&
-        typeof value.attemptId === "string" &&
-        typeof value.targetSessionId === "string" &&
-        ["agent", "assistant", "decision"].includes(value.kind) &&
-        Buffer.isBuffer(value.contractHash) &&
-        typeof value.revision === "number" &&
-        ["pending", "settled", "cancelled"].includes(value.status) &&
-        typeof value.unproductiveTurnEnds === "number" &&
-        nullableString(value.acceptedSubmissionId) &&
-        typeof value.createdAt === "number" &&
-        typeof value.updatedAt === "number" &&
-        nullableNumber(value.settledAt) &&
-        nullableNumber(value.consumedAt));
-}
 function runnerMessageFingerprint(message) {
     return createHash("sha256").update(canonicalJson(message)).digest();
 }