@osolmaz/pi-workflows 0.15.2 → 0.15.3

package/src/host/runner.ts

@@ -526,14 +526,37 @@ export class WorkflowHost {
       case "run.pause": {
         const runId = requireRunId(request);
         const active = this.activeRuns.get(runId);
-        if (active === undefined) return { outcome: "rejected", error: "Run is not active" };
-        this.commitActivePause(active);
-        active.control = "pause";
-        afterCommit.push(() => void active.supervisor.stop("cancelled"));
-        return { outcome: "accepted", receipt: { runId, status: "parked", paused: true } };
+        if (active !== undefined) {
+          if (active.control === "pause") {
+            return { outcome: "adopted", receipt: { runId, status: "parked", paused: true } };
+          }
+          if (active.control === "handoff") {
+            const paused = this.queue.pauseParkedWorkflowRun({ runId });
+            return paused
+              ? { outcome: "accepted", receipt: { runId, status: "parked", paused: true } }
+              : { outcome: "rejected", error: "Run handoff is not pausable" };
+          }
+          if (active.control !== undefined) {
+            return { outcome: "rejected", error: `Run is already handling ${active.control}` };
+          }
+          this.commitActivePause(active);
+          active.control = "pause";
+          afterCommit.push(() => void active.supervisor.stop("cancelled"));
+          return { outcome: "accepted", receipt: { runId, status: "parked", paused: true } };
+        }
+        const paused = this.queue.pauseParkedWorkflowRun({ runId });
+        return paused
+          ? { outcome: "accepted", receipt: { runId, status: "parked", paused: true } }
+          : { outcome: "rejected", error: "Run is not pausable" };
       }
       case "run.resume": {
         const runId = requireRunId(request);
+        if (this.queue.resumePausedInteraction({ runId })) {
+          return {
+            outcome: "accepted",
+            receipt: { runId, status: "parked", paused: false, waitingForInteraction: true },
+          };
+        }
         if (this.activeRuns.has(runId) || this.pendingStarts.has(runId)) {
           return { outcome: "adopted", receipt: { runId, active: true } };
         }
@@ -570,20 +593,27 @@ export class WorkflowHost {
       case "interaction.update": {
         const payload = requireRecord(request.payload, "interaction update payload");
         if (payload.claimPresentation === true) {
-          const interaction = this.hostState.claimInteractionPresentation({
-            requestId: requireString(payload.requestId, "requestId"),
-            expectedRevision: requireNonNegativeInteger(
-              request.expectedRevision,
-              "expectedRevision",
-            ),
-            presenterId: request.clientId,
-            leaseMs: PRESENTATION_CLAIM_LEASE_MS,
-          });
-          return {
-            outcome: "accepted",
-            revision: interaction.revision,
-            receipt: interaction as unknown as JsonValue,
-          };
+          try {
+            const interaction = this.hostState.claimInteractionPresentation({
+              requestId: requireString(payload.requestId, "requestId"),
+              expectedRevision: requireNonNegativeInteger(
+                request.expectedRevision,
+                "expectedRevision",
+              ),
+              presenterId: request.clientId,
+              leaseMs: PRESENTATION_CLAIM_LEASE_MS,
+            });
+            return {
+              outcome: "accepted",
+              revision: interaction.revision,
+              receipt: interaction as unknown as JsonValue,
+            };
+          } catch (error) {
+            if (errorMessage(error) === "Interactive request presentation claim conflict") {
+              return { outcome: "conflict", error: errorMessage(error) };
+            }
+            throw error;
+          }
         }
         if (typeof payload.sessionEntryId === "string") {
           const interaction = this.hostState.markInteractionPresented({
@@ -722,17 +752,18 @@ export class WorkflowHost {
     };
   }
 
-  private rememberDeliveryClaim(options: Omit<DeliveryClaim, "expiresAt">): string {
+  private rememberDeliveryClaim(options: Omit<DeliveryClaim, "expiresAt">): {
+    claimId: string;
+    claimExpiresAt: string;
+  } {
     const now = Date.now();
     for (const [claimId, claim] of this.deliveryClaims) {
       if (claim.expiresAt <= now) this.deliveryClaims.delete(claimId);
     }
     const claimId = randomUUID();
-    this.deliveryClaims.set(claimId, {
-      ...options,
-      expiresAt: now + DELIVERY_CLAIM_LEASE_MS,
-    });
-    return claimId;
+    const expiresAt = now + DELIVERY_CLAIM_LEASE_MS;
+    this.deliveryClaims.set(claimId, { ...options, expiresAt });
+    return { claimId, claimExpiresAt: new Date(expiresAt).toISOString() };
   }
 
   private deliveryClaim(
@@ -757,8 +788,39 @@ export class WorkflowHost {
     return claim;
   }
 
+  private validateDelivery(
+    command: HostRequest,
+    payload: Record<string, unknown>,
+    kind: DeliveryClaim["kind"],
+  ): Omit<HostResponse, "schema" | "requestId"> {
+    const resourceId = requireString(payload.resourceId, "resourceId");
+    const targetSessionId = requireString(payload.targetSessionId, "targetSessionId");
+    const claimId = requireString(payload.claimId, "claimId");
+    const claim = this.deliveryClaim(claimId, command.clientId, kind, resourceId, targetSessionId);
+    if (claim === undefined) {
+      return { outcome: "accepted", receipt: { claimId, live: false } };
+    }
+    const live =
+      kind === "notification"
+        ? this.queue.isWorkflowNotificationClaimLive({
+            notificationId: resourceId,
+            targetSessionId,
+            claimToken: claim.token,
+          })
+        : this.queue.isWorkflowTurnIntentClaimLive({
+            intentId: resourceId,
+            targetSessionId,
+            claimToken: claim.token,
+          });
+    if (!live) this.deliveryClaims.delete(claimId);
+    return { outcome: "accepted", receipt: { claimId, live } };
+  }
+
   private claimNotification(command: HostRequest): Omit<HostResponse, "schema" | "requestId"> {
     const payload = requireRecord(command.payload, "notification claim payload");
+    if (payload.validateClaim === true) {
+      return this.validateDelivery(command, payload, "notification");
+    }
     const targetSessionId = requireString(payload.targetSessionId, "targetSessionId");
     const token = randomUUID();
     const notification = this.queue.claimPendingWorkflowNotifications({
@@ -770,7 +832,7 @@ export class WorkflowHost {
     if (notification === undefined) {
       return { outcome: "accepted", receipt: { notification: null } };
     }
-    const claimId = this.rememberDeliveryClaim({
+    const claim = this.rememberDeliveryClaim({
       clientId: command.clientId,
       token,
       targetSessionId,
@@ -779,7 +841,7 @@ export class WorkflowHost {
     });
     return {
       outcome: "accepted",
-      receipt: { claimId, notification } as unknown as JsonValue,
+      receipt: { ...claim, notification } as unknown as JsonValue,
     };
   }
 
@@ -811,6 +873,9 @@ export class WorkflowHost {
 
   private claimTurn(command: HostRequest): Omit<HostResponse, "schema" | "requestId"> {
     const payload = requireRecord(command.payload, "turn claim payload");
+    if (payload.validateClaim === true) {
+      return this.validateDelivery(command, payload, "turn");
+    }
     const targetSessionId = requireString(payload.targetSessionId, "targetSessionId");
     const token = randomUUID();
     const intent = this.queue.claimEligibleWorkflowTurnIntents({
@@ -822,7 +887,7 @@ export class WorkflowHost {
     if (intent === undefined) {
       return { outcome: "accepted", receipt: { turn: null } };
     }
-    const claimId = this.rememberDeliveryClaim({
+    const claim = this.rememberDeliveryClaim({
       clientId: command.clientId,
       token,
       targetSessionId,
@@ -831,7 +896,7 @@ export class WorkflowHost {
     });
     return {
       outcome: "accepted",
-      receipt: { claimId, turn: intent } as unknown as JsonValue,
+      receipt: { ...claim, turn: intent } as unknown as JsonValue,
     };
   }
 
@@ -913,6 +978,9 @@ export class WorkflowHost {
     if (interaction === undefined || interaction.kind !== "decision") {
       return { outcome: "notFound", error: `Decision request not found: ${requestId}` };
     }
+    if (this.queue.isWorkflowRunPaused(interaction.runId)) {
+      return { outcome: "conflict", error: "Workflow run is paused" };
+    }
     const request = interaction.contract as unknown as HumanDecisionRequest;
     const response = payload.response as HumanDecisionResponse;
     const accepted = this.decisions.acceptSync(request, {
@@ -1085,6 +1153,9 @@ export class WorkflowHost {
     if (interaction === undefined || interaction.runId !== runId) {
       return { outcome: "notFound", error: `Interactive request not found: ${requestId}` };
     }
+    if (this.queue.isWorkflowRunPaused(runId)) {
+      return { outcome: "conflict", error: "Workflow run is paused" };
+    }
     const attemptId = requireString(payload.attempt, "attempt");
     const nodeId = requireString(payload.step, "step");
     const storedContract = requireRecord(interaction.contract, "interactive contract");
@@ -1148,6 +1219,9 @@ export class WorkflowHost {
     if (current === undefined || current.runId !== requireRunId(request)) {
       return { outcome: "notFound", error: `Interactive request not found: ${requestId}` };
     }
+    if (this.queue.isWorkflowRunPaused(current.runId)) {
+      return { outcome: "conflict", error: "Workflow run is paused" };
+    }
     const attemptId = requireString(payload.attempt, "attempt");
     const nodeId = requireString(payload.step, "step");
     const storedContract = requireRecord(current.contract, "interactive contract");

package/src/host/state.ts

@@ -65,6 +65,8 @@ export type InteractiveRequestRecord = {
   contract: JsonValue;
   revision: number;
   status: "pending" | "presenting" | "settled" | "cancelled";
+  presenterId: string | null;
+  presentationClaimExpiresAt: string | null;
   presentationSessionEntryId: string | null;
   acceptedSubmissionId: string | null;
   createdAt: string;
@@ -886,7 +888,9 @@ export class HostStateStore {
       .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, presentation_session_entry_id AS presentationSessionEntryId,
+                revision, status, presenter_id AS presenterId,
+                presentation_claim_expires_at AS presentationClaimExpiresAt,
+                presentation_session_entry_id AS presentationSessionEntryId,
                 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 = ?`,
@@ -902,6 +906,8 @@ export class HostStateStore {
       contract: this.state.readJson(row.contractHash),
       revision: row.revision,
       status: row.status,
+      presenterId: row.presenterId,
+      presentationClaimExpiresAt: iso(row.presentationClaimExpiresAt),
       presentationSessionEntryId: row.presentationSessionEntryId,
       acceptedSubmissionId: row.acceptedSubmissionId,
       createdAt: new Date(row.createdAt).toISOString(),
@@ -997,6 +1003,8 @@ type InteractiveRequestRow = {
   contractHash: Buffer;
   revision: number;
   status: InteractiveRequestRecord["status"];
+  presenterId: string | null;
+  presentationClaimExpiresAt: number | null;
   presentationSessionEntryId: string | null;
   acceptedSubmissionId: string | null;
   createdAt: number;
@@ -1115,6 +1123,8 @@ function isInteractiveRequestRow(value: unknown): value is InteractiveRequestRow
     Buffer.isBuffer(value.contractHash) &&
     typeof value.revision === "number" &&
     ["pending", "presenting", "settled", "cancelled"].includes(value.status as string) &&
+    nullableString(value.presenterId) &&
+    nullableNumber(value.presentationClaimExpiresAt) &&
     nullableString(value.presentationSessionEntryId) &&
     nullableString(value.acceptedSubmissionId) &&
     typeof value.createdAt === "number" &&