@osolmaz/pi-workflows 0.16.1 → 0.16.2

package/src/host/view.ts

@@ -804,7 +804,8 @@ export class HostViewStore {
       .prepare(
         `SELECT t.target_session_id AS targetSessionId FROM workflow_turns t
          JOIN workflow_messages m ON m.workflow_message_id = t.workflow_message_id
-         WHERE t.run_id = ? AND t.state = 'started' AND m.kind IN ('step', 'terminal') LIMIT 1`,
+         WHERE t.run_id = ? AND t.state = 'started'
+           AND m.kind IN ('step', 'terminal', 'followUp') LIMIT 1`,
       )
       .get(runId);
     return (
@@ -920,7 +921,10 @@ export function reduceWorkflowDisplay(facts: WorkflowDisplayFacts): WorkflowDisp
     reason = "The workflow is waiting for origin-session input.";
   } else if (facts.queueStatus === "parked" || facts.queueStatus === "queued") {
     status = "queued";
-    reason = facts.queueStatus === "parked" ? "The workflow is ready to resume." : null;
+    reason =
+      facts.queueStatus === "parked"
+        ? (facts.errorMessage ?? "The workflow is ready to resume.")
+        : null;
   } else if (facts.queueStatus === "done") {
     status = "completed";
   } else if (facts.queueStatus === "failed" || facts.queueStatus === "cancelled") {

package/src/host/worker-entry.ts

@@ -31,6 +31,7 @@ import {
   parseWorkerResponse,
   type WorkerMessage,
   type WorkerResponse,
+  type WorkerRunCommand,
 } from "./worker-protocol.js";
 import { HostBackedWorkflowStore, type WorkerStoreTransport } from "./worker-store.js";
 
@@ -38,14 +39,10 @@ const STARTUP_ENV = "PI_WORKFLOWS_WORKER_LAUNCH";
 const PRESENTATION_TIMEOUT_MS = 30_000;
 
 type WorkerBootstrap = {
-  initialized: boolean;
-  input: JsonValue;
-  launchOptions: JsonValue;
-  parentRunId: string | null;
+  command: WorkerRunCommand;
   originSessionId: string | null;
   stateDirectory: string;
   piArgs?: string[];
-  resumeInteractionAttemptId?: string;
   candidateInteraction?: {
     requestId: string;
     attemptId: string;
@@ -278,6 +275,35 @@ export function validateAcceptedAssistantSubmission(
   };
 }
 
+export async function executeWorkerRunCommand(
+  engine: Pick<WorkflowEngine, "run" | "resumeRun" | "continueRun">,
+  workflow: WorkflowDefinition,
+  runId: string,
+  workflowSource: WorkflowSource,
+  command: WorkerRunCommand,
+) {
+  switch (command.kind) {
+    case "start":
+    case "restart":
+      return await engine.run(workflow, command.input, { runId, workflowSource });
+    case "resume":
+      return await engine.resumeRun(workflow, runId, {
+        workflowSource,
+        ...(command.resumeInteractionAttemptId === undefined
+          ? {}
+          : { resumeInteractionAttemptId: command.resumeInteractionAttemptId }),
+      });
+    case "continue":
+      return await engine.continueRun(workflow, command.parentRunId, command.input, {
+        runId,
+        workflowSource,
+        ...(command.humanDecision === undefined
+          ? {}
+          : { humanDecision: command.humanDecision as ResolvedHumanDecision }),
+      });
+  }
+}
+
 export async function runWorkflowWorker(): Promise<number> {
   const launch = readLaunchEnvelope();
   const transport = new StdioWorkerTransport(launch);
@@ -360,32 +386,14 @@ export async function runWorkflowWorker(): Promise<number> {
         await store.requestPresentation(instructions);
       },
     });
-    const launchOptions =
-      typeof bootstrap.launchOptions === "object" &&
-      bootstrap.launchOptions !== null &&
-      !Array.isArray(bootstrap.launchOptions)
-        ? (bootstrap.launchOptions as Record<string, unknown>)
-        : {};
     try {
-      const result = bootstrap.initialized
-        ? await engine.resumeRun(workflow, launch.runId, {
-            workflowSource: workflowSource.root,
-            ...(bootstrap.resumeInteractionAttemptId === undefined
-              ? {}
-              : { resumeInteractionAttemptId: bootstrap.resumeInteractionAttemptId }),
-          })
-        : bootstrap.parentRunId === null
-          ? await engine.run(workflow, bootstrap.input, {
-              runId: launch.runId,
-              workflowSource: workflowSource.root,
-            })
-          : await engine.continueRun(workflow, bootstrap.parentRunId, bootstrap.input, {
-              runId: launch.runId,
-              workflowSource: workflowSource.root,
-              ...(launchOptions.humanDecision === undefined
-                ? {}
-                : { humanDecision: launchOptions.humanDecision as ResolvedHumanDecision }),
-            });
+      const result = await executeWorkerRunCommand(
+        engine,
+        workflow,
+        launch.runId,
+        workflowSource.root,
+        bootstrap.command,
+      );
       await transport.control("worker.exiting", {
         status: result.state.status,
         traceSeq: result.state.traceSeq,

package/src/host/worker-protocol.ts

@@ -4,6 +4,17 @@ import { canonicalJson, parseJson, type JsonValue } from "../state/json.js";
 export const WORKER_MESSAGE_SCHEMA = "pi-workflows.worker-message.v1" as const;
 export const WORKER_RESPONSE_SCHEMA = "pi-workflows.worker-response.v1" as const;
 
+export type WorkerRunCommand =
+  | { kind: "start"; input: JsonValue }
+  | { kind: "resume"; resumeInteractionAttemptId?: string }
+  | {
+      kind: "continue";
+      parentRunId: string;
+      input: JsonValue;
+      humanDecision?: JsonValue;
+    }
+  | { kind: "restart"; input: JsonValue };
+
 export const WORKER_MESSAGE_KINDS = [
   "worker.ready",
   "node.started",

package/src/state/workflow-messages.ts

@@ -279,6 +279,12 @@ export class WorkflowMessageStore {
         throw new Error("Workflow turn does not match its message");
       }
       if (message.status !== "sent") throw new Error("Workflow turn requires a sent message");
+      const open = this.openTurnForMessage(options.workflowMessageId);
+      if (open !== undefined) {
+        throw new Error(
+          `Workflow message ${options.workflowMessageId} already has open turn ${open.workflowTurnId}`,
+        );
+      }
       this.state.connection
         .prepare(
           `INSERT INTO workflow_turns(
@@ -337,6 +343,51 @@ export class WorkflowMessageStore {
     });
   }
 
+  settleOpenTurnsForRun(
+    runId: string,
+    stopReason: WorkflowTurnStopReason = "lost",
+    now: number = Date.now(),
+  ): WorkflowTurn[] {
+    return this.state.transaction(() => {
+      const open = this.state.connection
+        .prepare(
+          `SELECT workflow_turn_id AS workflowTurnId, workflow_message_id AS workflowMessageId,
+                  run_id AS runId, target_session_id AS targetSessionId, state,
+                  stop_reason AS stopReason, response_session_entry_id AS responseSessionEntryId,
+                  started_at AS startedAt, ended_at AS endedAt
+           FROM workflow_turns WHERE run_id = ? AND state = 'started' ORDER BY started_at`,
+        )
+        .all(runId)
+        .filter(isWorkflowTurnRow)
+        .map(mapTurn);
+      this.state.connection
+        .prepare(
+          `UPDATE workflow_turns SET state = 'ended', stop_reason = ?, ended_at = ?
+           WHERE run_id = ? AND state = 'started'`,
+        )
+        .run(stopReason, now, runId);
+      return open.map((turn) => this.requireTurn(turn.workflowTurnId));
+    });
+  }
+
+  cancelPendingForRun(
+    runId: string,
+    now: number = Date.now(),
+    kinds: readonly WorkflowMessageKind[] = ["step", "decision", "followUp"],
+  ): number {
+    if (kinds.length === 0) return 0;
+    return this.state.transaction(
+      () =>
+        this.state.connection
+          .prepare(
+            `UPDATE workflow_messages SET status = 'cancelled', updated_at = ?
+             WHERE run_id = ? AND status = 'pending'
+               AND kind IN (${kinds.map(() => "?").join(", ")})`,
+          )
+          .run(now, runId, ...kinds).changes,
+    );
+  }
+
   getTurn(workflowTurnId: string): WorkflowTurn | undefined {
     const row = this.state.connection
       .prepare(

package/src/workflows/composition.ts

@@ -589,15 +589,10 @@ function wrappedEffect(
   project: (context: WorkflowNodeContext) => WorkflowNodeContext,
 ): WorkflowManagedEffect | undefined {
   if (node.effect === undefined) return undefined;
-  const idempotencyKey = node.effect.idempotencyKey;
   const request = node.effect.request;
   return {
     type: node.effect.type,
     recovery: node.effect.recovery,
-    idempotencyKey:
-      typeof idempotencyKey === "function"
-        ? (context: WorkflowNodeContext) => idempotencyKey(project(context))
-        : idempotencyKey,
     request:
       typeof request === "function"
         ? (context: WorkflowNodeContext) => request(project(context))

package/src/workflows/definition.ts

@@ -191,14 +191,6 @@ function workflowEffect(
   return {
     type: normalized,
     recovery,
-    idempotencyKey: ({ state }: WorkflowNodeContext) => {
-      const nodeId = state.currentNode;
-      if (nodeId === undefined) {
-        throw new Error("Managed effect resolution requires an active workflow node");
-      }
-      const nodeInvocation = state.steps.filter((step) => step.nodeId === nodeId).length + 1;
-      return `${state.runId}:${normalized}:${nodeId}:${nodeInvocation}`;
-    },
     request: ({ input, outputs }: WorkflowNodeContext) => ({ input, outputs }),
   };
 }

package/src/workflows/engine.ts

@@ -1563,17 +1563,15 @@ export class WorkflowEngine {
       );
     }
     const effectType = node.effect.type.trim();
-    const idempotencyKey =
-      typeof node.effect.idempotencyKey === "function"
-        ? await node.effect.idempotencyKey(context)
-        : node.effect.idempotencyKey;
+    const invocation = context.state.steps.filter((step) => step.nodeId === nodeId).length + 1;
+    const idempotencyKey = `${context.state.runId}:${effectType}:${nodeId}:${invocation}`;
     const request =
       typeof node.effect.request === "function"
         ? await node.effect.request(context)
         : node.effect.request;
     /* istanbul ignore if -- definition validation and effect helpers reject empty fields */
-    if (effectType.length === 0 || idempotencyKey.trim().length === 0) {
-      throw new Error("Managed effect type and idempotency key must be nonempty text");
+    if (effectType.length === 0) {
+      throw new Error("Managed effect type must be nonempty text");
     }
     canonicalJson(request);
     const reservation = await this.store.reserveEffect({

package/src/workflows/schema.ts

@@ -113,12 +113,6 @@ export function assertValidActionNode(node: ActionNodeDefinition, nodeId = "acti
   if (node.effect.recovery !== "idempotent" && node.effect.recovery !== "manual") {
     fail(`node ${nodeId} effect recovery must be idempotent or manual`);
   }
-  if (
-    typeof node.effect.idempotencyKey !== "string" &&
-    typeof node.effect.idempotencyKey !== "function"
-  ) {
-    fail(`node ${nodeId} effect idempotencyKey must be text or a function`);
-  }
   if (!("request" in node.effect)) {
     fail(`node ${nodeId} effect requires request data or a request function`);
   }

package/src/workflows/store.ts

@@ -143,6 +143,17 @@ export type WorkflowRunDisplayState = {
   error: string | null;
 };
 
+export type WorkflowRunTerminalData = {
+  runId: string;
+  status: "completed" | "failed" | "timed_out" | "cancelled";
+  statusDetail: string | null;
+  input: JsonValue;
+  finalOutput: JsonValue | null;
+  error: string | null;
+  presentationInstructions: string;
+  restartNumber: number;
+};
+
 export type WorkflowRunStoreOptions = {
   authorityProvider?: (runId: string) => RunWriteAuthority | undefined;
   /** Host-owned projection updates that must commit with each run snapshot. */
@@ -2182,6 +2193,59 @@ export class WorkflowRunStore {
     };
   }
 
+  readRunInput(runId: string): JsonValue | null {
+    const row = this.readRunRow(runId);
+    return row === undefined ? null : this.state.readJson(row.inputHash);
+  }
+
+  readRunFinalOutput(runId: string): JsonValue | null {
+    const row = this.readRunRow(runId);
+    return row?.finalOutputHash == null ? null : this.state.readJson(row.finalOutputHash);
+  }
+
+  readRunError(runId: string): string | null {
+    const row = this.readRunRow(runId);
+    return row?.errorHash == null ? null : this.readText(row.errorHash);
+  }
+
+  readPresentationInstructions(runId: string): string {
+    const row = this.state.connection
+      .prepare("SELECT presentation_prompt_hash AS hash FROM runs WHERE run_id = ?")
+      .get(runId) as { hash?: Buffer | null } | undefined;
+    if (row?.hash == null) {
+      return "Explain the final workflow result to the user in a normal response.";
+    }
+    return this.readText(row.hash);
+  }
+
+  readTerminalData(runId: string): WorkflowRunTerminalData | null {
+    const row = this.state.connection
+      .prepare(
+        `SELECT status, status_detail AS statusDetail, restart_number AS restartNumber
+         FROM runs WHERE run_id = ?`,
+      )
+      .get(runId) as
+      | { status?: unknown; statusDetail?: unknown; restartNumber?: unknown }
+      | undefined;
+    if (
+      row === undefined ||
+      !["completed", "failed", "timed_out", "cancelled"].includes(String(row.status)) ||
+      typeof row.restartNumber !== "number"
+    ) {
+      return null;
+    }
+    return {
+      runId,
+      status: row.status as WorkflowRunTerminalData["status"],
+      statusDetail: typeof row.statusDetail === "string" ? row.statusDetail : null,
+      input: this.readRunInput(runId) as JsonValue,
+      finalOutput: this.readRunFinalOutput(runId),
+      error: this.readRunError(runId),
+      presentationInstructions: this.readPresentationInstructions(runId),
+      restartNumber: row.restartNumber,
+    };
+  }
+
   readRun(runId: string, options: ReadWorkflowRunOptions = {}): LoadedWorkflowRun | null {
     const row = this.readRunRow(runId);
     if (row === undefined) return null;

package/src/workflows/types.ts

@@ -53,9 +53,7 @@ export type WorkflowEffectRecovery = "idempotent" | "manual";
 export type WorkflowManagedEffect = {
   /** Stable external effect category, for example `github.comment`. */
   type: string;
-  /** Stable key. Idempotent adapters must pass this key to the external system. */
-  idempotencyKey: string | ((context: WorkflowNodeContext) => MaybePromise<string>);
-  /** Canonical request data used to reject key reuse with another operation. */
+  /** Canonical request data used to reject engine-owned key reuse with another operation. */
   request: unknown | ((context: WorkflowNodeContext) => MaybePromise<unknown>);
   /** `manual` never retries after an uncertain child exit. */
   recovery: WorkflowEffectRecovery;