ai-workflows 2.1.3 → 2.3.0

package/dist/durable-execution.d.ts

@@ -0,0 +1,482 @@
+/**
+ * DurableExecutionAdapter - Port for durable workflow execution backends.
+ *
+ * Defines a small, backend-agnostic interface that callers (notably
+ * `ai-database`'s cascade orchestration in ADR-0003) can program against
+ * without knowing which durable execution backend is wired underneath.
+ *
+ * ## Why this port exists
+ *
+ * `ai-workflows`'s {@link createWorkflowRuntime} owns the `$` runtime
+ * contract — handlers, dispatch, cascade-context, database-context. It runs
+ * in-process and lives only as long as the host process. For long-running
+ * cascades, scheduled jobs, and orchestration spanning hours-to-days, an
+ * external durable execution backend is required.
+ *
+ * Two production candidates (per ADR-0004):
+ *
+ *   - **Cloudflare Workflows** (default backend; Workers-only). Hibernation
+ *     while waiting; no per-step billing; 25K steps default; 365-day max
+ *     sleep. State must flow through step returns — in-memory variables do
+ *     not survive hibernation.
+ *
+ *   - **Vercel Workflow Development Kit (WDK)** (alternate backend; Vercel
+ *     or self-hosted). Apache-2.0; pluggable "Worlds"; per-step billing;
+ *     event-sourced replay; unlimited sleep.
+ *
+ * Plus an in-process stub (this file's {@link createInMemoryDurableExecution})
+ * for tests and local development that does not need durability across
+ * process restarts. Phase 1 (bead `aip-fgq5`) will land a richer in-process
+ * adapter that bridges this port to the existing
+ * {@link createWorkflowRuntime}.
+ *
+ * The port is modeled after WDK's "Worlds" abstraction — the prior art for
+ * exactly this pattern: a small, backend-portable surface for `step`,
+ * `sleep`, `waitForEvent`, and scheduling, with each adapter translating to
+ * its native primitive (CF's hibernation, WDK's event-sourced replay,
+ * in-process's plain async).
+ *
+ * ## Programming model: Rules of Workflows
+ *
+ * These rules are universal to durable execution and are not specific to
+ * any one backend. They originate in CF's "Rules of Workflows" guidance and
+ * apply equally to WDK's deterministic replay model.
+ *
+ *   1. **Steps must be idempotent.** A step body may be re-executed across
+ *      a hibernation/restart boundary or after a transient failure. Wrap
+ *      external side-effects (writes, payments, emails) so a duplicate
+ *      invocation is observably equivalent to a single invocation.
+ *
+ *   2. **Step names must be deterministic.** Adapters use the step name as
+ *      a stable identity for memoization and event-sourced replay. Do not
+ *      include random ids, timestamps, or run-specific values in the name.
+ *
+ *   3. **State flows through step returns.** Variables defined inside a
+ *      workflow body but outside a step are not guaranteed to survive a
+ *      hibernation boundary. Read inputs at the top of a step; return only
+ *      what you need; pass results forward through subsequent steps.
+ *
+ *   4. **Workflow bodies must be deterministic.** Two replays of the same
+ *      input must take the same control-flow path. Push non-determinism
+ *      (clocks, randomness, network reads) into steps so the adapter can
+ *      memoize the result.
+ *
+ *   5. **Sleeps and waits are first-class.** Use
+ *      {@link DurableExecutionAdapter.sleep},
+ *      {@link DurableExecutionAdapter.sleepUntil}, and
+ *      {@link DurableExecutionAdapter.waitForEvent} rather than `setTimeout`
+ *      or polling — only the adapter knows how to suspend and resume the
+ *      workflow correctly.
+ *
+ * ## Error semantics
+ *
+ * - {@link DurableStepError} (and its subclasses) are thrown by step
+ *   execution failures. The {@link DurableStepError.retryable} flag tells
+ *   the caller whether the adapter considered the failure transient. Real
+ *   adapters surface their backend's retry decisions through this flag.
+ *
+ * - {@link WaitForEventTimeoutError} is thrown by
+ *   {@link DurableExecutionAdapter.waitForEvent} when a timeout elapses
+ *   without the named event arriving. Callers should catch this explicitly
+ *   to model "happens within N" branches.
+ *
+ * - All other thrown errors propagate as-is. Callers must classify
+ *   non-retryable business errors themselves; adapters do not introspect
+ *   user errors.
+ *
+ * ## Subpath export
+ *
+ * This module ships at the `ai-workflows/durable-execution` subpath so the
+ * cascade orchestrator (in `ai-database`) can depend on the port without
+ * pulling in the full `ai-workflows` runtime — keeping the static dependency
+ * graph one-way (`ai-database` → `ai-workflows/durable-execution`).
+ *
+ * @example In-memory test usage
+ * ```ts
+ * import { createInMemoryDurableExecution } from 'ai-workflows/durable-execution'
+ *
+ * const dx = createInMemoryDurableExecution()
+ * const result = await dx.run('charge-customer', async (ctx) => {
+ *   const charged = await ctx.step('charge-card', async () => {
+ *     return chargeStripe(ctx.input)
+ *   })
+ *   await ctx.sleep('1 second')
+ *   return { id: charged.id }
+ * }, { customerId: 'c-1', amount: 1000 })
+ * ```
+ *
+ * @example Wiring a real adapter (future Phase 1; bead aip-fgq5/aip-i456)
+ * ```ts
+ * import type { DurableExecutionAdapter } from 'ai-workflows/durable-execution'
+ *
+ * function makeCascadeRunner(dx: DurableExecutionAdapter) {
+ *   return (input: CascadeInput) => dx.run('cascade', async (ctx) => {
+ *     const plan = await ctx.step('plan', () => generatePlan(ctx.input))
+ *     return ctx.step('write', () => writeAll(plan))
+ *   }, input)
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+import type { WorkflowRuntime } from './runtime.js';
+/**
+ * Context passed to a {@link WorkflowFn}. Provides the same step / sleep /
+ * wait primitives as the top-level {@link DurableExecutionAdapter}, plus the
+ * input the workflow was invoked with.
+ *
+ * The context is bound to one workflow run; calls on it are routed to the
+ * adapter that started the run.
+ */
+export interface WorkflowContext<TInput = unknown> {
+    /** The input value the workflow was invoked with. */
+    readonly input: TInput;
+    /** Stable instance id assigned by the adapter at run start. */
+    readonly instanceId: string;
+    /** Logical workflow name supplied at {@link DurableExecutionAdapter.run}. */
+    readonly name: string;
+    /**
+     * Execute a named, durable step. See
+     * {@link DurableExecutionAdapter.step} for semantics.
+     */
+    step<T>(name: string, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Execute a named, durable step with explicit configuration. See
+     * {@link DurableExecutionAdapter.step}.
+     */
+    step<T>(name: string, config: StepConfig, fn: () => Promise<T>): Promise<T>;
+    /** Suspend the workflow for {@link DurableExecutionAdapter.sleep}. */
+    sleep(duration: string | number): Promise<void>;
+    /** Suspend until {@link DurableExecutionAdapter.sleepUntil}. */
+    sleepUntil(date: Date): Promise<void>;
+    /** Wait for a named event. See {@link DurableExecutionAdapter.waitForEvent}. */
+    waitForEvent<T = unknown>(name: string, timeout?: number | string): Promise<T>;
+}
+/**
+ * A user-authored workflow body.
+ *
+ * The body must be deterministic across replays — see the "Rules of
+ * Workflows" in the module-level docs. The function is invoked once per
+ * run-or-replay; the adapter memoizes step results by step name so repeated
+ * executions converge on the same outcome.
+ */
+export type WorkflowFn<TResult = unknown, TInput = unknown> = (ctx: WorkflowContext<TInput>) => Promise<TResult>;
+/**
+ * Per-step configuration. Adapters that do not support a given option treat
+ * it as advisory. CF Workflows and WDK both support timeout and retries;
+ * the in-memory stub honours retries and ignores timeout (since steps are
+ * synchronous from the adapter's perspective).
+ */
+export interface StepConfig {
+    /** Maximum total attempts including the first. Default: adapter-specific (typically 1). */
+    retries?: {
+        /** Total attempts (>= 1). */
+        limit: number;
+        /** Delay between attempts. String forms: '1 second', '500ms'. */
+        delay?: string | number;
+        /** Backoff curve. Default: 'constant'. */
+        backoff?: 'constant' | 'linear' | 'exponential';
+    };
+    /** Per-attempt timeout. String or ms. */
+    timeout?: string | number;
+}
+/**
+ * Returned by {@link DurableExecutionAdapter.schedule}. Calling
+ * {@link Subscription.unsubscribe} cancels the schedule; idempotent.
+ */
+export interface Subscription {
+    /** Stable id for the schedule (adapter-defined format). */
+    readonly id: string;
+    /** Cancel the schedule. Safe to call more than once. */
+    unsubscribe(): void;
+}
+/**
+ * Thrown when a step's body fails after all retries (or immediately, when
+ * retries are not configured).
+ *
+ * The {@link DurableStepError.retryable} flag reflects the adapter's
+ * judgement about the underlying failure: `true` means the adapter believed
+ * the failure was transient (network, rate-limit, server error) and would
+ * have retried again given more attempts; `false` means the adapter
+ * classified it as terminal (programmer error, invalid input). Callers can
+ * use this to decide whether to escalate or fall through to a different
+ * code path.
+ */
+export declare class DurableStepError extends Error {
+    /** Step name that failed. */
+    readonly stepName: string;
+    /** Number of attempts the adapter actually made (>= 1). */
+    readonly attempts: number;
+    /** Whether the adapter considered the cause transient. */
+    readonly retryable: boolean;
+    /** The error that ultimately caused the failure. */
+    readonly cause: unknown;
+    constructor(message: string, options: {
+        stepName: string;
+        attempts: number;
+        retryable: boolean;
+        cause: unknown;
+    });
+}
+/**
+ * Thrown when {@link DurableExecutionAdapter.waitForEvent} elapses without
+ * the named event arriving.
+ */
+export declare class WaitForEventTimeoutError extends Error {
+    readonly eventName: string;
+    readonly timeout: number | string;
+    constructor(eventName: string, timeout: number | string);
+}
+/**
+ * Concrete adapter kind. Used only as a discriminant for callers that want
+ * to log or branch on the active backend; should never be relied on for
+ * correctness.
+ */
+export type DurableExecutionKind = 'in-process' | 'cloudflare' | 'vercel-wdk';
+/**
+ * The port. A small, backend-agnostic interface over `run`, `step`, `sleep`,
+ * `waitForEvent`, and `schedule`.
+ *
+ * Real adapters live alongside this file but ship behind feature flags or
+ * separate subpath modules so importing the port itself does not pull in
+ * any backend dependencies.
+ */
+export interface DurableExecutionAdapter {
+    /** Discriminant tag for the active backend. */
+    readonly kind: DurableExecutionKind;
+    /**
+     * Run a workflow body to completion. The adapter assigns the run a
+     * stable `instanceId`, persists it (where applicable), and invokes `fn`
+     * with a {@link WorkflowContext}.
+     *
+     * Resolves with the workflow's return value. Rejects with whatever the
+     * body or its steps reject with — callers must handle both
+     * {@link DurableStepError} and arbitrary user errors.
+     *
+     * @param name Logical name of the workflow (used for telemetry and, in
+     * some backends, for routing). Should be stable across deployments.
+     * @param fn The deterministic workflow body. See module docs for rules.
+     * @param input Arbitrary input value passed through to `ctx.input`. Must
+     * be JSON-serializable for adapters that persist state (CF, WDK).
+     */
+    run<TResult = unknown, TInput = unknown>(name: string, fn: WorkflowFn<TResult, TInput>, input: TInput): Promise<TResult>;
+    /**
+     * Execute a named, idempotent step.
+     *
+     * Step names must be stable across replays — the adapter uses the name
+     * as the memoization key. On replay, a step that has already succeeded
+     * returns its memoized result without re-invoking `fn`. On a transient
+     * failure, the adapter retries per {@link StepConfig.retries} (or its
+     * default policy).
+     *
+     * Outside of `run()` (e.g. when the adapter is called directly without a
+     * surrounding workflow body) implementations may either: (a) treat
+     * `step` as a thin wrapper that calls `fn` once with no replay, or (b)
+     * throw. The in-memory stub picks (a) because it is convenient for tests.
+     *
+     * Step bodies must be idempotent — see the Rules of Workflows.
+     */
+    step<T>(name: string, fn: () => Promise<T>): Promise<T>;
+    step<T>(name: string, config: StepConfig, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Suspend execution for a duration. The adapter's backend may hibernate
+     * the workflow during the sleep window; in-memory the stub merely awaits.
+     *
+     * @param duration Number of milliseconds, or a human string accepted by
+     * the backend (e.g. `'1 second'`, `'5 minutes'`, `'1 day'`). Adapters
+     * that do not understand a string form must throw.
+     */
+    sleep(duration: string | number): Promise<void>;
+    /** Suspend execution until the given absolute timestamp. */
+    sleepUntil(date: Date): Promise<void>;
+    /**
+     * Wait for an externally-signalled event by name.
+     *
+     * @param name Event name. Convention: `Noun.event` (matching
+     * `ai-workflows`'s dispatch shape) but adapters do not enforce this.
+     * @param timeout Optional max wait. Number = milliseconds. String = a
+     * backend-recognised duration. When `undefined` the adapter waits
+     * forever (or until its hard backend limit, e.g. 365 days for CF).
+     *
+     * Rejects with {@link WaitForEventTimeoutError} if the timeout elapses.
+     */
+    waitForEvent<T = unknown>(name: string, timeout?: number | string): Promise<T>;
+    /**
+     * Register a workflow body to run on a cron schedule.
+     *
+     * The schedule itself is durable — the adapter is responsible for firing
+     * at the given cron expression even across process restarts. The
+     * returned {@link Subscription} cancels the schedule when unsubscribed.
+     *
+     * Fired runs receive an empty input (`undefined`). To pass per-run data,
+     * read it from external state inside the workflow body.
+     */
+    schedule<TResult = unknown>(name: string, cron: string, fn: WorkflowFn<TResult, undefined>): Subscription;
+}
+/**
+ * Options for {@link createInMemoryDurableExecution}.
+ */
+export interface InMemoryDurableExecutionOptions {
+    /**
+     * Override the clock. Used by tests to control sleep without waiting in
+     * real time. When provided, `sleep`/`sleepUntil` resolve as soon as the
+     * clock returns a value `>= deadline`.
+     */
+    now?: () => number;
+    /**
+     * Override the sleep primitive. Defaults to a real `setTimeout`. Tests
+     * that want to fast-forward time can replace this with a no-op.
+     */
+    delay?: (ms: number) => Promise<void>;
+}
+/**
+ * Construct an in-memory {@link DurableExecutionAdapter} suitable for tests
+ * and validating the port shape. **Not durable** — state lives only in
+ * closure for the lifetime of the process.
+ *
+ * Behaviour:
+ *
+ * - `run`: invokes the body once with a fresh context. No replay.
+ * - `step`: memoizes the result by step name within a single `run`
+ *   invocation; outside a `run` it executes once and returns. Honours
+ *   retries (constant/linear/exponential backoff).
+ * - `sleep` / `sleepUntil`: awaits real time by default, overridable via
+ *   {@link InMemoryDurableExecutionOptions.delay}.
+ * - `waitForEvent`: pairs with {@link InMemoryDurableExecution.emit} on the
+ *   returned object. If `timeout` elapses first, rejects with
+ *   {@link WaitForEventTimeoutError}.
+ * - `schedule`: installs a `setInterval` that fires the workflow body each
+ *   `cron` tick. The cron expression itself is **not** parsed in the stub —
+ *   it is treated as opaque metadata. Tests that want time-driven schedules
+ *   should drive emissions manually via the returned helpers.
+ *
+ * The stub satisfies the full {@link DurableExecutionAdapter} surface so
+ * tests can validate the port shape without writing a real adapter.
+ */
+export interface InMemoryDurableExecution extends DurableExecutionAdapter {
+    /**
+     * Manually deliver an event to the next pending {@link waitForEvent}
+     * call with the matching name. Returns `true` if a waiter was resolved,
+     * `false` otherwise.
+     */
+    emit<T = unknown>(name: string, value: T): boolean;
+}
+/**
+ * @see InMemoryDurableExecution
+ */
+export declare function createInMemoryDurableExecution(options?: InMemoryDurableExecutionOptions): InMemoryDurableExecution;
+/**
+ * Options for {@link createInProcessDurableExecution}.
+ *
+ * When a `runtime` is supplied the adapter records each durable run/step into
+ * the runtime's cascade context, history, and (when configured) database. When
+ * no runtime is supplied the adapter behaves identically to
+ * {@link createInMemoryDurableExecution} but uses production logging instead of
+ * silently swallowing schedule errors — making it suitable for local dev and
+ * single-process callers that want durable-execution semantics without
+ * crash-recovery.
+ *
+ * `now` and `delay` are forwarded to the underlying machinery for tests that
+ * need to fast-forward time. Real callers should leave them at the defaults.
+ */
+export interface InProcessDurableExecutionOptions extends InMemoryDurableExecutionOptions {
+    /**
+     * Optional {@link WorkflowRuntime} to integrate with. When supplied:
+     *
+     *   - Each durable `run` pushes an `event`-typed history entry on start and
+     *     completion through `runtime.state.history`.
+     *   - Each durable `step` records a {@link CascadeStep} on
+     *     `runtime.cascade` via {@link recordStep}; the step is marked
+     *     completed/failed when the body resolves/rejects.
+     *   - When `runtime.$.db` is present, each durable step creates an action
+     *     via `db.createAction({ actor: 'workflow', object: name, action: 'step' })`
+     *     before invoking the body, and completes (or records failure) on resolution.
+     *   - The workflow context handed to the body exposes the runtime's `$` as
+     *     {@link InProcessWorkflowContext.runtime} so handlers can dispatch
+     *     events through the same registry the rest of the app uses.
+     *
+     * Pass `null`/omitted to opt out — the adapter still satisfies the port and
+     * runs durably in-process, just without the runtime integration.
+     */
+    runtime?: WorkflowRuntime;
+}
+/**
+ * Workflow context handed to bodies invoked through
+ * {@link createInProcessDurableExecution}. Identical to {@link WorkflowContext}
+ * but with an optional `runtime` reference exposing the wrapping
+ * {@link WorkflowRuntime} (when one was supplied at construction time).
+ *
+ * `runtime` is `undefined` when the adapter was constructed without a runtime.
+ */
+export interface InProcessWorkflowContext<TInput = unknown> extends WorkflowContext<TInput> {
+    /** The `WorkflowRuntime` wrapped by the adapter, if any. */
+    readonly runtime?: WorkflowRuntime;
+}
+/**
+ * The adapter returned by {@link createInProcessDurableExecution}.
+ *
+ * Extends {@link DurableExecutionAdapter} with `emit` (for paired
+ * `waitForEvent` testing) and exposes the wrapped runtime when one was
+ * supplied. The `runtime` reference is the same object passed in at
+ * construction; callers can use it to register handlers, inspect history, or
+ * read cascade traces emitted during durable runs.
+ */
+export interface InProcessDurableExecution extends DurableExecutionAdapter {
+    /**
+     * Manually deliver an event to the next pending {@link waitForEvent} call
+     * with the matching name. Mirrors {@link InMemoryDurableExecution.emit}.
+     */
+    emit<T = unknown>(name: string, value: T): boolean;
+    /** The runtime wrapped by the adapter, if one was supplied. */
+    readonly runtime?: WorkflowRuntime;
+}
+/**
+ * Construct the production in-process {@link DurableExecutionAdapter}.
+ *
+ * Differs from {@link createInMemoryDurableExecution} in three ways:
+ *
+ *   1. **Runtime integration.** When a {@link WorkflowRuntime} is supplied,
+ *      each run/step is reflected in the runtime's cascade context, history,
+ *      and (when `runtime.$.db` is wired) database adapter — making durable
+ *      runs observable through the same surfaces as event-driven dispatch.
+ *
+ *   2. **Production-shape logging.** Schedule failures and step failures with
+ *      a configured runtime are routed through the package logger
+ *      ({@link getLogger}). The in-memory stub silently swallows these because
+ *      tests do not want noise in the console.
+ *
+ *   3. **Workflow context exposes the runtime.** Bodies receive an
+ *      {@link InProcessWorkflowContext} with `ctx.runtime` set, so durable
+ *      workflows can dispatch events through the same `$.on`/`$.send`
+ *      registry the rest of the app uses.
+ *
+ * The adapter is *not* durable across process restarts — that is the
+ * Cloudflare Workflows adapter's job (separate bead `aip-i456`). It exists
+ * for test environments, local development, and single-process callers that
+ * want the port semantics without a real backend.
+ *
+ * @example No runtime — equivalent to the in-memory stub but production-shape
+ * ```ts
+ * const dx = createInProcessDurableExecution()
+ * await dx.run('hello', async (ctx) => ctx.input.name, { name: 'world' })
+ * ```
+ *
+ * @example With runtime — durable runs participate in the `$` ecosystem
+ * ```ts
+ * const runtime = createWorkflowRuntime({ db: myDb })
+ * const dx = createInProcessDurableExecution({ runtime })
+ *
+ * await dx.run('cascade', async (ctx) => {
+ *   const plan = await ctx.step('plan', async () => generatePlan(ctx.input))
+ *   // The runtime's $.send delivers to handlers registered on the same runtime.
+ *   ctx.runtime!.$.send('Plan.generated', plan)
+ *   return plan
+ * }, { customerId: 'c-1' })
+ *
+ * // Cascade trace, history, and db actions all reflect the run.
+ * console.log(runtime.cascade.steps.length) // >= 1 (the 'plan' step)
+ * ```
+ */
+export declare function createInProcessDurableExecution(options?: InProcessDurableExecutionOptions): InProcessDurableExecution;
+export { createCloudflareWorkflowsDurableExecution, createWorkflowEntrypoint, type CloudflareWorkflowsDurableExecution, type CloudflareWorkflowsDurableExecutionOptions, type CloudflareWorkflowsLimits, type WorkflowEnvelope, type WorkflowEntrypointConstructor, type WorkflowEntrypointLike, type WorkflowEventLike, type WorkflowInstanceLike, type WorkflowsBindingLike, type WorkflowStepConfigLike, type WorkflowStepLike, } from './durable-execution-cloudflare.js';
+//# sourceMappingURL=durable-execution.d.ts.map

package/dist/durable-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-execution.d.ts","sourceRoot":"","sources":["../src/durable-execution.ts"],"names":[],"mappings":"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"}