@aikirun/workflow 0.5.3 → 0.6.0

package/dist/index.d.ts

@@ -1,9 +1,12 @@
 import { WorkflowId, WorkflowVersionId } from '@aikirun/types/workflow';
-import { Client, Logger } from '@aikirun/types/client';
+import { Client, Logger, ApiClient } from '@aikirun/types/client';
 import { INTERNAL } from '@aikirun/types/symbols';
 import { WorkflowRun, WorkflowRunStatus, WorkflowRunStateCompleted, WorkflowRunStateInComplete, WorkflowRunState, WorkflowRunId, WorkflowOptions } from '@aikirun/types/workflow-run';
 import { SleepParams, SleepResult } from '@aikirun/types/sleep';
-import { TaskPath, TaskState } from '@aikirun/types/task';
+import { DurationObject } from '@aikirun/types/duration';
+import { EventSendOptions, EventWaitOptions, EventWaitState } from '@aikirun/types/event';
+import { TaskPath } from '@aikirun/types/task';
+import { WorkflowRunStateRequest, TaskStateRequest } from '@aikirun/types/workflow-run-api';
 import { SerializableInput } from '@aikirun/types/error';
 
 type NonEmptyArray<T> = [T, ...T[]];
@@ -25,10 +28,11 @@ type PathFromObjectInternal<T, IncludeArrayKeys extends boolean> = And<[
 type ExtractObjectType<T> = T extends object ? T : never;
 type TypeOfValueAtPath<T extends object, Path extends PathFromObject<T>> = Path extends keyof T ? T[Path] : Path extends `${infer First}.${infer Rest}` ? First extends keyof T ? undefined extends T[First] ? Rest extends PathFromObject<ExtractObjectType<T[First]>> ? TypeOfValueAtPath<ExtractObjectType<T[First]>, Rest> | undefined : never : Rest extends PathFromObject<ExtractObjectType<T[First]>> ? TypeOfValueAtPath<ExtractObjectType<T[First]>, Rest> : never : never : never;
 
-declare function workflowRunHandle<Input, Output>(client: Client<unknown>, id: WorkflowRunId): Promise<WorkflowRunHandle<Input, Output>>;
-declare function workflowRunHandle<Input, Output>(client: Client<unknown>, run: WorkflowRun<Input, Output>, logger?: Logger): Promise<WorkflowRunHandle<Input, Output>>;
-interface WorkflowRunHandle<Input, Output> {
+declare function workflowRunHandle<Input, Output, TEventsDefinition extends EventsDefinition>(client: Client, id: WorkflowRunId, eventsDefinition?: TEventsDefinition, logger?: Logger): Promise<WorkflowRunHandle<Input, Output, TEventsDefinition>>;
+declare function workflowRunHandle<Input, Output, TEventsDefinition extends EventsDefinition>(client: Client, run: WorkflowRun<Input, Output>, eventsDefinition?: TEventsDefinition, logger?: Logger): Promise<WorkflowRunHandle<Input, Output, TEventsDefinition>>;
+interface WorkflowRunHandle<Input, Output, TEventsDefinition extends EventsDefinition = EventsDefinition> {
     run: Readonly<WorkflowRun<Input, Output>>;
+    events: EventSenders<TEventsDefinition>;
     refresh: () => Promise<void>;
     wait<S extends WorkflowRunStatus>(condition: {
         type: "status";
@@ -54,8 +58,8 @@ interface WorkflowRunHandle<Input, Output> {
     pause: () => Promise<void>;
     resume: () => Promise<void>;
     [INTERNAL]: {
-        transitionState: (state: WorkflowRunState<Output>) => Promise<void>;
-        transitionTaskState: (taskPath: TaskPath, taskState: TaskState<unknown>) => Promise<void>;
+        transitionState: (state: WorkflowRunStateRequest) => Promise<void>;
+        transitionTaskState: (taskPath: TaskPath, taskState: TaskStateRequest) => Promise<void>;
         assertExecutionAllowed: () => void;
     };
 }
@@ -65,43 +69,101 @@ interface WorkflowRunWaitOptions {
     abortSignal?: AbortSignal;
 }
 
-interface WorkflowRunContext<Input, Output> {
+/**
+ * Defines an event type that can be sent to and waited for by workflows.
+ *
+ * Events are type-first with optional runtime schema validation.
+ *
+ * @template Data - Type of event data (must be JSON serializable)
+ * @param params - Optional event configuration
+ * @param opts.schema - Optional schema for runtime validation
+ * @returns EventDefinition for use in workflows
+ *
+ * @example
+ * ```typescript
+ * // Type-only event (no runtime validation)
+ * const approved = event<{ by: string }>();
+ *
+ * // Event with runtime validation
+ * const rejected = event<{ by: string; reason: string }>({
+ *   schema: z.object({ by: z.string(), reason: z.string() })
+ * });
+ * ```
+ */
+declare function event<Data>(params?: EventParams<Data>): EventDefinition<Data>;
+interface EventParams<Data> {
+    schema?: Schema<Data>;
+}
+interface Schema<Data> {
+    parse: (data: unknown) => Data;
+}
+interface EventDefinition<Data> {
+    _type: Data;
+    schema?: Schema<Data>;
+}
+type EventsDefinition = Record<string, EventDefinition<unknown>>;
+type EventData<TEventDefinition> = TEventDefinition extends EventDefinition<infer Data> ? Data : never;
+type EventWaiters<TEventsDefinition extends EventsDefinition> = {
+    [K in keyof TEventsDefinition]: EventWaiter<EventData<TEventsDefinition[K]>>;
+};
+interface EventWaiter<Data> {
+    wait(options?: EventWaitOptions<undefined>): Promise<EventWaitState<Data, false>>;
+    wait(options: EventWaitOptions<DurationObject>): Promise<EventWaitState<Data, true>>;
+}
+type EventSenders<TEventsDefinition extends EventsDefinition> = {
+    [K in keyof TEventsDefinition]: EventSender<EventData<TEventsDefinition[K]>>;
+};
+interface EventSender<Data> {
+    send: (data: Data, options?: EventSendOptions) => Promise<void>;
+}
+declare function createEventWaiters<TEventsDefinition extends EventsDefinition>(handle: WorkflowRunHandle<unknown, unknown, TEventsDefinition>, eventsDefinition: TEventsDefinition, logger: Logger): EventWaiters<TEventsDefinition>;
+declare function createEventSenders<TEventsDefinition extends EventsDefinition>(api: ApiClient, workflowRunId: string, eventsDefinition: TEventsDefinition, logger: Logger, onSend: (run: WorkflowRun<unknown, unknown>) => void): EventSenders<TEventsDefinition>;
+
+interface WorkflowRunContext<Input, Output, TEventDefinition extends EventsDefinition> {
     id: WorkflowRunId;
     workflowId: WorkflowId;
     workflowVersionId: WorkflowVersionId;
     options: WorkflowOptions;
     logger: Logger;
     sleep: (params: SleepParams) => Promise<SleepResult>;
+    events: EventWaiters<TEventDefinition>;
     [INTERNAL]: {
-        handle: WorkflowRunHandle<Input, Output>;
+        handle: WorkflowRunHandle<Input, Output, TEventDefinition>;
+        options: {
+            spinThresholdMs: number;
+        };
     };
 }
 
-interface WorkflowVersionParams<Input, Output, AppContext> {
-    handler: (input: Input, run: Readonly<WorkflowRunContext<Input, Output>>, context: AppContext) => Promise<Output>;
+interface WorkflowVersionParams<Input, Output, AppContext, TEventsDefinition extends EventsDefinition> {
+    events?: TEventsDefinition;
     opts?: WorkflowOptions;
+    handler: (input: Input, run: Readonly<WorkflowRunContext<Input, Output, TEventsDefinition>>, context: AppContext) => Promise<Output>;
 }
-interface WorkflowBuilder<Input, Output, AppContext> {
-    opt<Path extends PathFromObject<WorkflowOptions>>(path: Path, value: TypeOfValueAtPath<WorkflowOptions, Path>): WorkflowBuilder<Input, Output, AppContext>;
-    start: WorkflowVersion<Input, Output, AppContext>["start"];
+interface WorkflowBuilder<Input, Output, AppContext, TEventsDefinition extends EventsDefinition> {
+    opt<Path extends PathFromObject<WorkflowOptions>>(path: Path, value: TypeOfValueAtPath<WorkflowOptions, Path>): WorkflowBuilder<Input, Output, AppContext, TEventsDefinition>;
+    start: WorkflowVersion<Input, Output, AppContext, TEventsDefinition>["start"];
 }
-interface WorkflowVersion<Input, Output, AppContext> {
+interface WorkflowVersion<Input, Output, AppContext, TEventsDefinition extends EventsDefinition = EventsDefinition> {
     id: WorkflowId;
     versionId: WorkflowVersionId;
-    with(): WorkflowBuilder<Input, Output, AppContext>;
-    start: (client: Client<AppContext>, ...args: Input extends null ? [] : [Input]) => Promise<WorkflowRunHandle<Input, Output>>;
+    with(): WorkflowBuilder<Input, Output, AppContext, TEventsDefinition>;
+    start: (client: Client<AppContext>, ...args: Input extends null ? [] : [Input]) => Promise<WorkflowRunHandle<Input, Output, TEventsDefinition>>;
+    getHandle: (client: Client<AppContext>, runId: WorkflowRunId) => Promise<WorkflowRunHandle<Input, Output, TEventsDefinition>>;
     [INTERNAL]: {
-        handler: (input: Input, run: WorkflowRunContext<Input, Output>, context: AppContext) => Promise<void>;
+        eventsDefinition: TEventsDefinition;
+        handler: (input: Input, run: WorkflowRunContext<Input, Output, TEventsDefinition>, context: AppContext) => Promise<void>;
     };
 }
-declare class WorkflowVersionImpl<Input, Output, AppContext> implements WorkflowVersion<Input, Output, AppContext> {
+declare class WorkflowVersionImpl<Input, Output, AppContext, TEventsDefinition extends EventsDefinition> implements WorkflowVersion<Input, Output, AppContext, TEventsDefinition> {
     readonly id: WorkflowId;
     readonly versionId: WorkflowVersionId;
     private readonly params;
-    readonly [INTERNAL]: WorkflowVersion<Input, Output, AppContext>[typeof INTERNAL];
-    constructor(id: WorkflowId, versionId: WorkflowVersionId, params: WorkflowVersionParams<Input, Output, AppContext>);
-    with(): WorkflowBuilder<Input, Output, AppContext>;
-    start(client: Client<AppContext>, ...args: Input extends null ? [] : [Input]): Promise<WorkflowRunHandle<Input, Output>>;
+    readonly [INTERNAL]: WorkflowVersion<Input, Output, AppContext, TEventsDefinition>[typeof INTERNAL];
+    constructor(id: WorkflowId, versionId: WorkflowVersionId, params: WorkflowVersionParams<Input, Output, AppContext, TEventsDefinition>);
+    with(): WorkflowBuilder<Input, Output, AppContext, TEventsDefinition>;
+    start(client: Client<AppContext>, ...args: Input extends null ? [] : [Input]): Promise<WorkflowRunHandle<Input, Output, TEventsDefinition>>;
+    getHandle(client: Client<AppContext>, runId: WorkflowRunId): Promise<WorkflowRunHandle<Input, Output, TEventsDefinition>>;
     private handler;
     private tryExecuteWorkflow;
     private assertRetryAllowed;
@@ -124,7 +186,7 @@ interface WorkflowRegistry {
 interface SleeperOptions {
     spinThresholdMs: number;
 }
-declare function createWorkflowRunSleeper(workflowRunHandle: WorkflowRunHandle<unknown, unknown>, logger: Logger, options: SleeperOptions): (params: SleepParams) => Promise<SleepResult>;
+declare function createSleeper(handle: WorkflowRunHandle<unknown, unknown>, logger: Logger, options: SleeperOptions): (params: SleepParams) => Promise<SleepResult>;
 
 /**
  * Defines a durable workflow with versioning and multiple task execution.
@@ -179,11 +241,11 @@ interface WorkflowParams {
 }
 interface Workflow {
     id: WorkflowId;
-    v: <Input extends SerializableInput = null, Output = void, AppContext = null>(versionId: string, params: WorkflowVersionParams<Input, Output, AppContext>) => WorkflowVersion<Input, Output, AppContext>;
+    v: <Input extends SerializableInput = null, Output = void, AppContext = null, TEventsDefinition extends EventsDefinition = Record<string, never>>(versionId: string, params: WorkflowVersionParams<Input, Output, AppContext, TEventsDefinition>) => WorkflowVersion<Input, Output, AppContext, TEventsDefinition>;
     [INTERNAL]: {
         getAllVersions: () => WorkflowVersion<unknown, unknown, unknown>[];
         getVersion: (versionId: WorkflowVersionId) => WorkflowVersion<unknown, unknown, unknown> | undefined;
     };
 }
 
-export { type Workflow, type WorkflowParams, type WorkflowRegistry, type WorkflowRunContext, type WorkflowRunHandle, type WorkflowRunWaitOptions, type WorkflowVersion, WorkflowVersionImpl, type WorkflowVersionParams, createWorkflowRunSleeper, workflow, workflowRegistry, workflowRunHandle };
+export { type EventDefinition, type EventSender, type EventSenders, type EventWaiter, type EventWaiters, type Workflow, type WorkflowParams, type WorkflowRegistry, type WorkflowRunContext, type WorkflowRunHandle, type WorkflowRunWaitOptions, type WorkflowVersion, WorkflowVersionImpl, type WorkflowVersionParams, createEventSenders, createEventWaiters, createSleeper, event, workflow, workflowRegistry, workflowRunHandle };

package/dist/index.js

@@ -251,27 +251,136 @@ function getRetryParams(attempts, strategy) {
   }
 }
 
-// run/run-handle.ts
+// run/event.ts
 import { INTERNAL } from "@aikirun/types/symbols";
+import {
+  WorkflowRunFailedError,
+  WorkflowRunSuspendedError
+} from "@aikirun/types/workflow-run";
+function event(params) {
+  return {
+    _type: void 0,
+    schema: params?.schema
+  };
+}
+function createEventWaiters(handle, eventsDefinition, logger) {
+  const waiters = {};
+  for (const [eventId, eventDefinition] of Object.entries(eventsDefinition)) {
+    const waiter = createEventWaiter(
+      handle,
+      eventId,
+      eventDefinition.schema,
+      logger.child({ "aiki.eventId": eventId })
+    );
+    waiters[eventId] = waiter;
+  }
+  return waiters;
+}
+function createEventWaiter(handle, eventId, schema, logger) {
+  let nextEventIndex = 0;
+  async function wait(options) {
+    const events = handle.run.eventsQueue[eventId]?.events ?? [];
+    if (nextEventIndex < events.length) {
+      const event2 = events[nextEventIndex];
+      nextEventIndex++;
+      if (event2.status === "timeout") {
+        logger.debug("Timed out waiting for event");
+        return { timeout: true };
+      }
+      let data;
+      try {
+        data = schema ? schema.parse(event2.data) : event2.data;
+      } catch (error) {
+        logger.error("Invalid event data", { data: event2.data, error });
+        const serializableError = createSerializableError(error);
+        await handle[INTERNAL].transitionState({
+          status: "failed",
+          cause: "self",
+          error: serializableError
+        });
+        throw new WorkflowRunFailedError(handle.run.id, handle.run.attempts);
+      }
+      logger.debug("Event received");
+      return { timeout: false, data };
+    }
+    const timeoutInMs = options?.timeout && toMilliseconds(options.timeout);
+    logger.info("Waiting for event", {
+      ...timeoutInMs !== void 0 ? { "aiki.timeoutInMs": timeoutInMs } : {}
+    });
+    await handle[INTERNAL].transitionState({
+      status: "awaiting_event",
+      eventId,
+      timeoutInMs
+    });
+    throw new WorkflowRunSuspendedError(handle.run.id);
+  }
+  return { wait };
+}
+function createEventSenders(api, workflowRunId, eventsDefinition, logger, onSend) {
+  const senders = {};
+  for (const [eventId, eventDefinition] of Object.entries(eventsDefinition)) {
+    const sender = createEventSender(
+      api,
+      workflowRunId,
+      eventId,
+      eventDefinition.schema,
+      logger.child({ "aiki.eventId": eventId }),
+      onSend
+    );
+    senders[eventId] = sender;
+  }
+  return senders;
+}
+function createEventSender(api, workflowRunId, eventId, schema, logger, onSend) {
+  return {
+    async send(data, options) {
+      if (schema) {
+        schema.parse(data);
+      }
+      logger.debug("Sending event", {
+        ...options?.idempotencyKey ? { "aiki.idempotencyKey": options.idempotencyKey } : {}
+      });
+      const { run } = await api.workflowRun.sendEventV1({
+        id: workflowRunId,
+        eventId,
+        data,
+        options
+      });
+      onSend(run);
+    }
+  };
+}
+
+// run/handle.ts
+import { INTERNAL as INTERNAL2 } from "@aikirun/types/symbols";
 import {
   WorkflowRunNotExecutableError
 } from "@aikirun/types/workflow-run";
-async function workflowRunHandle(client, runOrId, logger) {
+async function workflowRunHandle(client, runOrId, eventsDefinition, logger) {
   const run = typeof runOrId !== "string" ? runOrId : (await client.api.workflowRun.getByIdV1({ id: runOrId })).run;
-  return new WorkflowRunHandleImpl(client.api, run, logger ?? client.logger.child({ "aiki.workflowRunId": run.id }));
+  return new WorkflowRunHandleImpl(
+    client.api,
+    run,
+    eventsDefinition ?? {},
+    logger ?? client.logger.child({ "aiki.workflowRunId": run.id })
+  );
 }
 var WorkflowRunHandleImpl = class {
-  constructor(api, _run, logger) {
+  constructor(api, _run, eventsDefinition, logger) {
     this.api = api;
     this._run = _run;
     this.logger = logger;
-    this[INTERNAL] = {
+    this.events = createEventSenders(this.api, this._run.id, eventsDefinition, this.logger, (run) => {
+      this._run = run;
+    });
+    this[INTERNAL2] = {
       transitionState: this.transitionState.bind(this),
       transitionTaskState: this.transitionTaskState.bind(this),
       assertExecutionAllowed: this.assertExecutionAllowed.bind(this)
     };
   }
-  [INTERNAL];
+  events;
+  [INTERNAL2];
   get run() {
     return this._run;
   }
@@ -279,6 +388,9 @@ var WorkflowRunHandleImpl = class {
     const { run: currentRun } = await this.api.workflowRun.getByIdV1({ id: this.run.id });
     this._run = currentRun;
   }
+  // TODO: instead polling the current state, use the transition history
+  // because it is entirely possible for a workflow to flash though a state
+  // and the handle will never know that the workflow hit that state
   async wait(condition, options) {
     if (options.abortSignal?.aborted) {
       throw new Error("Wait operation aborted");
@@ -334,10 +446,10 @@ var WorkflowRunHandleImpl = class {
     return this.transitionState({ status: "cancelled", reason });
   }
   async pause() {
-    return this.transitionState({ status: "paused", pausedAt: Date.now() });
+    return this.transitionState({ status: "paused" });
   }
   async resume() {
-    return this.transitionState({ status: "scheduled", scheduledAt: Date.now(), reason: "resume" });
+    return this.transitionState({ status: "scheduled", scheduledInMs: 0, reason: "resume" });
   }
   async transitionState(targetState) {
     if (targetState.status === "scheduled" && (targetState.reason === "new" || targetState.reason === "resume") || targetState.status === "paused" || targetState.status === "cancelled") {
@@ -375,11 +487,11 @@ var WorkflowRunHandleImpl = class {
 };
 
 // run/sleeper.ts
-import { INTERNAL as INTERNAL2 } from "@aikirun/types/symbols";
-import { WorkflowRunSuspendedError } from "@aikirun/types/workflow-run";
+import { INTERNAL as INTERNAL3 } from "@aikirun/types/symbols";
+import { WorkflowRunSuspendedError as WorkflowRunSuspendedError2 } from "@aikirun/types/workflow-run";
 var MAX_SLEEP_YEARS = 10;
 var MAX_SLEEP_MS = MAX_SLEEP_YEARS * 365 * 24 * 60 * 60 * 1e3;
-function createWorkflowRunSleeper(workflowRunHandle2, logger, options) {
+function createSleeper(handle, logger, options) {
   return async (params) => {
     const { id: sleepId, ...durationFields } = params;
     const durationMs = toMilliseconds(durationFields);
@@ -387,7 +499,7 @@ function createWorkflowRunSleeper(workflowRunHandle2, logger, options) {
       throw new Error(`Sleep duration ${durationMs}ms exceeds maximum of ${MAX_SLEEP_YEARS} years`);
     }
     const sleepPath = `${sleepId}/${durationMs}`;
-    const sleepState = workflowRunHandle2.run.sleepsState[sleepPath] ?? { status: "none" };
+    const sleepState = handle.run.sleepsState[sleepPath] ?? { status: "none" };
     if (sleepState.status === "completed") {
       logger.debug("Sleep completed", {
         "aiki.sleepId": sleepId,
@@ -407,7 +519,7 @@ function createWorkflowRunSleeper(workflowRunHandle2, logger, options) {
         "aiki.sleepId": sleepId,
         "aiki.durationMs": durationMs
       });
-      throw new WorkflowRunSuspendedError(workflowRunHandle2.run.id);
+      throw new WorkflowRunSuspendedError2(handle.run.id);
     }
     sleepState;
     if (durationMs <= options.spinThresholdMs) {
@@ -418,35 +530,36 @@ function createWorkflowRunSleeper(workflowRunHandle2, logger, options) {
       await delay(durationMs);
       return { cancelled: false };
     }
-    await workflowRunHandle2[INTERNAL2].transitionState({ status: "sleeping", sleepPath, durationMs });
+    await handle[INTERNAL3].transitionState({ status: "sleeping", sleepPath, durationMs });
     logger.info("Workflow going to sleep", {
       "aiki.sleepId": sleepId,
       "aiki.durationMs": durationMs
     });
-    throw new WorkflowRunSuspendedError(workflowRunHandle2.run.id);
+    throw new WorkflowRunSuspendedError2(handle.run.id);
   };
 }
 
 // workflow.ts
-import { INTERNAL as INTERNAL4 } from "@aikirun/types/symbols";
+import { INTERNAL as INTERNAL5 } from "@aikirun/types/symbols";
 
 // workflow-version.ts
-import { INTERNAL as INTERNAL3 } from "@aikirun/types/symbols";
+import { INTERNAL as INTERNAL4 } from "@aikirun/types/symbols";
 import { TaskFailedError } from "@aikirun/types/task";
 import {
-  WorkflowRunFailedError,
-  WorkflowRunSuspendedError as WorkflowRunSuspendedError2
+  WorkflowRunFailedError as WorkflowRunFailedError2,
+  WorkflowRunSuspendedError as WorkflowRunSuspendedError3
 } from "@aikirun/types/workflow-run";
 var WorkflowVersionImpl = class _WorkflowVersionImpl {
   constructor(id, versionId, params) {
     this.id = id;
     this.versionId = versionId;
     this.params = params;
-    this[INTERNAL3] = {
+    this[INTERNAL4] = {
+      eventsDefinition: this.params.events ?? {},
       handler: this.handler.bind(this)
     };
   }
-  [INTERNAL3];
+  [INTERNAL4];
   with() {
     const optsOverrider = objectOverrider(this.params.opts ?? {});
     const createBuilder = (optsBuilder) => ({
@@ -465,21 +578,24 @@ var WorkflowVersionImpl = class _WorkflowVersionImpl {
       input: isNonEmptyArray(args) ? args[0] : null,
       options: this.params.opts
     });
-    return workflowRunHandle(client, run);
+    return workflowRunHandle(client, run, this[INTERNAL4].eventsDefinition);
+  }
+  async getHandle(client, runId) {
+    return workflowRunHandle(client, runId, this[INTERNAL4].eventsDefinition);
   }
   async handler(input, run, context) {
     const { logger } = run;
-    const { handle } = run[INTERNAL3];
-    handle[INTERNAL3].assertExecutionAllowed();
+    const { handle } = run[INTERNAL4];
+    handle[INTERNAL4].assertExecutionAllowed();
     const retryStrategy = this.params.opts?.retry ?? { type: "never" };
     const state = handle.run.state;
     if (state.status === "queued" && state.reason === "retry") {
-      this.assertRetryAllowed(handle.run.id, handle.run.attempts, retryStrategy, logger);
+      await this.assertRetryAllowed(handle, retryStrategy, logger);
     }
     logger.info("Starting workflow");
-    await handle[INTERNAL3].transitionState({ status: "running" });
+    await handle[INTERNAL4].transitionState({ status: "running" });
     const output = await this.tryExecuteWorkflow(input, run, context, retryStrategy);
-    await handle[INTERNAL3].transitionState({ status: "completed", output });
+    await handle[INTERNAL4].transitionState({ status: "completed", output });
     logger.info("Workflow complete");
   }
   async tryExecuteWorkflow(input, run, context, retryStrategy) {
@@ -487,14 +603,15 @@ var WorkflowVersionImpl = class _WorkflowVersionImpl {
       try {
         return await this.params.handler(input, run, context);
       } catch (error) {
-        if (error instanceof WorkflowRunSuspendedError2) {
+        if (error instanceof WorkflowRunSuspendedError3) {
           throw error;
         }
-        const attempts = run[INTERNAL3].handle.run.attempts;
+        const { handle } = run[INTERNAL4];
+        const attempts = handle.run.attempts;
         const retryParams = getRetryParams(attempts, retryStrategy);
         if (!retryParams.retriesLeft) {
           const failedState = this.createFailedState(error);
-          await run[INTERNAL3].handle[INTERNAL3].transitionState(failedState);
+          await handle[INTERNAL4].transitionState(failedState);
           const logMeta2 = {};
           for (const [key, value] of Object.entries(failedState)) {
             logMeta2[`aiki.${key}`] = value;
@@ -503,32 +620,36 @@ var WorkflowVersionImpl = class _WorkflowVersionImpl {
             "aiki.attempts": attempts,
             ...logMeta2
           });
-          throw new WorkflowRunFailedError(run.id, attempts, failedState.reason, failedState.cause);
+          throw new WorkflowRunFailedError2(run.id, attempts);
         }
-        const nextAttemptAt = Date.now() + retryParams.delayMs;
-        const awaitingRetryState = this.createAwaitingRetryState(error, nextAttemptAt);
-        await run[INTERNAL3].handle[INTERNAL3].transitionState(awaitingRetryState);
+        const awaitingRetryState = this.createAwaitingRetryState(error, retryParams.delayMs);
+        await handle[INTERNAL4].transitionState(awaitingRetryState);
         const logMeta = {};
         for (const [key, value] of Object.entries(awaitingRetryState)) {
           logMeta[`aiki.${key}`] = value;
         }
         run.logger.info("Workflow failed. Awaiting retry", {
           "aiki.attempts": attempts,
-          "aiki.nextAttemptAt": nextAttemptAt,
           "aiki.delayMs": retryParams.delayMs,
           ...logMeta
         });
-        throw new WorkflowRunSuspendedError2(run.id);
+        throw new WorkflowRunSuspendedError3(run.id);
       }
     }
   }
-  assertRetryAllowed(id, attempts, retryStrategy, logger) {
+  async assertRetryAllowed(handle, retryStrategy, logger) {
+    const { id, attempts } = handle.run;
     const retryParams = getRetryParams(attempts, retryStrategy);
     if (!retryParams.retriesLeft) {
-      logger.error("Workflow retry not allowed", {
-        "aiki.attempts": attempts
+      logger.error("Workflow retry not allowed", { "aiki.attempts": attempts });
+      const error = new WorkflowRunFailedError2(id, attempts);
+      const serializableError = createSerializableError(error);
+      await handle[INTERNAL4].transitionState({
+        status: "failed",
+        cause: "self",
+        error: serializableError
       });
-      throw new WorkflowRunFailedError(id, attempts, "Workflow retry not allowed");
+      throw error;
     }
   }
   createFailedState(error) {
@@ -536,25 +657,22 @@ var WorkflowVersionImpl = class _WorkflowVersionImpl {
       return {
         status: "failed",
         cause: "task",
-        taskPath: error.taskPath,
-        reason: error.reason
+        taskPath: error.taskPath
       };
     }
     const serializableError = createSerializableError(error);
     return {
       status: "failed",
       cause: "self",
-      reason: serializableError.message,
       error: serializableError
     };
   }
-  createAwaitingRetryState(error, nextAttemptAt) {
+  createAwaitingRetryState(error, nextAttemptInMs) {
     if (error instanceof TaskFailedError) {
       return {
         status: "awaiting_retry",
         cause: "task",
-        reason: error.reason,
-        nextAttemptAt,
+        nextAttemptInMs,
         taskPath: error.taskPath
       };
     }
@@ -562,8 +680,7 @@ var WorkflowVersionImpl = class _WorkflowVersionImpl {
     return {
       status: "awaiting_retry",
       cause: "self",
-      reason: serializableError.message,
-      nextAttemptAt,
+      nextAttemptInMs,
       error: serializableError
     };
   }
@@ -575,11 +692,11 @@ function workflow(params) {
 }
 var WorkflowImpl = class {
   id;
-  [INTERNAL4];
+  [INTERNAL5];
   workflowVersions = /* @__PURE__ */ new Map();
   constructor(params) {
     this.id = params.id;
-    this[INTERNAL4] = {
+    this[INTERNAL5] = {
       getAllVersions: this.getAllVersions.bind(this),
       getVersion: this.getVersion.bind(this)
     };
@@ -604,7 +721,10 @@ var WorkflowImpl = class {
 };
 export {
   WorkflowVersionImpl,
-  createWorkflowRunSleeper,
+  createEventSenders,
+  createEventWaiters,
+  createSleeper,
+  event,
   workflow,
   workflowRegistry,
   workflowRunHandle

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aikirun/workflow",
-	"version": "0.5.3",
+	"version": "0.6.0",
 	"description": "Workflow SDK for Aiki - define durable workflows with tasks, sleeps, waits, and event handling",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -18,7 +18,7 @@
 		"build": "tsup"
 	},
 	"dependencies": {
-		"@aikirun/types": "0.5.3"
+		"@aikirun/types": "0.6.0"
 	},
 	"publishConfig": {
 		"access": "public"