ai-workflows 2.1.3 → 2.4.0

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

@@ -0,0 +1,427 @@
+/**
+ * Cloudflare Workflows adapter for {@link DurableExecutionAdapter}.
+ *
+ * Bridges the backend-agnostic port defined in `./durable-execution.ts` to
+ * Cloudflare's class-based {@link https://developers.cloudflare.com/workflows/ Workflows runtime}.
+ * CF Workflows is the production default per
+ * {@link ../../docs/adr/0004-durable-execution-cf-workflows-default.md ADR-0004}:
+ * the recently expanded limits (25K steps default-configurable, 50K concurrent
+ * instances, 365-day max sleep, 1 GB persisted state) plus zero per-step
+ * billing make it the cost-optimal backend for cascade-heavy workloads.
+ *
+ * ## How the bridge works
+ *
+ * CF Workflows uses a class-based dispatch model — users author a
+ * {@link WorkflowEntrypointLike} subclass with `async run(event, step)`, and
+ * the runtime instantiates it for each invocation. Our port's
+ * `run(name, fn, input)` is callback-shaped. The adapter resolves the
+ * impedance mismatch with two complementary surfaces:
+ *
+ *   1. **Workflow-function registry.** Callers register named workflow bodies
+ *      against the adapter via {@link CloudflareWorkflowsDurableExecution.register}
+ *      (or implicitly the first time {@link CloudflareWorkflowsDurableExecution.run}
+ *      is called with that name). The registry is a plain {@link Map}
+ *      maintained on the adapter instance.
+ *
+ *   2. **`createWorkflowEntrypoint(adapter)`.** Returns a
+ *      {@link WorkflowEntrypointLike} subclass whose `run(event, step)`
+ *      reads the workflow name from `event.payload.__wfName`, looks the body
+ *      up in the registry, and invokes it with a {@link WorkflowContext} that
+ *      delegates each port primitive to the CF `step` argument. Users export
+ *      this class from their worker module and wire it through `wrangler.jsonc`:
+ *
+ *      ```jsonc
+ *      "workflows": [{
+ *        "name": "cascade",
+ *        "binding": "WORKFLOW",
+ *        "class_name": "MyWorkflowEntrypoint"
+ *      }]
+ *      ```
+ *
+ * The adapter's `run()` triggers a workflow by calling `binding.create({
+ * params: { __wfName, __wfInput } })` against the supplied
+ * {@link WorkflowsBindingLike}. By default it polls
+ * `instance.status()` until completion and returns the workflow output;
+ * callers that need fire-and-forget can opt out via
+ * {@link CloudflareWorkflowsDurableExecutionOptions.waitForCompletion}.
+ *
+ * ## Step / sleep / waitForEvent translation
+ *
+ *   - `ctx.step(name, fn)`           → `step.do(name, fn)`
+ *   - `ctx.step(name, cfg, fn)`      → `step.do(name, cfg, fn)`
+ *   - `ctx.sleep(duration)`          → `step.sleep(autoStepName, duration)`
+ *   - `ctx.sleepUntil(date)`         → `step.sleepUntil(autoStepName, date)`
+ *   - `ctx.waitForEvent(name, t?)`   → `step.waitForEvent(autoStepName, { type: name, timeout: t })`
+ *
+ * CF requires every primitive to receive a stable name; our port's `sleep` /
+ * `sleepUntil` / `waitForEvent` don't. The bridge synthesises a deterministic
+ * name from a per-context counter (`__sleep__1`, `__waitForEvent__Order.placed__1`)
+ * incremented in body order. Bodies that take the same control-flow path on
+ * replay therefore see identical names — the determinism rule applies.
+ *
+ * Callers who want full control over step naming for sleeps/waits should use
+ * {@link DurableExecutionAdapter.step} (or `ctx.step`) wrapping the desired
+ * primitive: e.g. `await ctx.step('payment-window', () => sleepUntil(deadline))`.
+ *
+ * ## Schedules
+ *
+ * CF Workflows do not support imperative cron registration through the binding;
+ * scheduled triggers are declared in `wrangler.jsonc` under `[triggers] crons`
+ * and routed to a Worker `scheduled()` handler. The adapter's
+ * {@link DurableExecutionAdapter.schedule} therefore registers the workflow
+ * body against the adapter and returns a {@link Subscription} whose `id` is
+ * the workflow name; the user's worker `scheduled()` handler must call
+ * {@link CloudflareWorkflowsDurableExecution.runSchedule} (or the adapter's
+ * `run()`) when the cron fires. {@link CloudflareWorkflowsDurableExecution.defineSchedule}
+ * is an alias for `schedule()` that emphasises the wrangler-coordinated nature
+ * of CF scheduling.
+ *
+ * ## Rules of Workflows (CF-imposed; universal)
+ *
+ *   1. **Steps must be idempotent.** CF re-executes step bodies on replay
+ *      after a hibernation boundary or transient failure. Wrap external
+ *      side-effects so a duplicate invocation is observably equivalent to a
+ *      single one.
+ *
+ *   2. **Step names must be deterministic.** CF uses the step name as the
+ *      memoization key. Random ids, timestamps, or run-specific values in
+ *      step names break replay.
+ *
+ *   3. **State must flow through step returns.** Variables defined in the
+ *      workflow body but outside a step DO NOT survive hibernation. Read
+ *      inputs at the top of a step and return only what subsequent steps
+ *      need.
+ *
+ *   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 CF can memoize the
+ *      result.
+ *
+ *   5. **Use `step.sleep` / `step.sleepUntil` / `step.waitForEvent`.** Never
+ *      `setTimeout` or polling — only the runtime knows how to suspend and
+ *      resume the workflow.
+ *
+ * ## Limits
+ *
+ * Declared via {@link CloudflareWorkflowsDurableExecution.limits}:
+ *
+ *   - **Steps per workflow:** 25,000 (default-configurable per Mar 2026
+ *     change; see ADR-0004).
+ *   - **Concurrent instances:** 50,000 per account (Apr 2026 change).
+ *   - **Maximum sleep:** 365 days.
+ *   - **Per-step / per-event payload:** 1 MiB (CF Workers RPC limit).
+ *
+ * @see {@link ../../docs/adr/0004-durable-execution-cf-workflows-default.md ADR-0004}
+ * @see {@link https://developers.cloudflare.com/workflows/build/workflows-api/ Workflows API}
+ * @see {@link https://developers.cloudflare.com/workflows/build/rules-of-workflows/ Rules of Workflows}
+ *
+ * @example Wiring an adapter
+ * ```ts
+ * // worker.ts
+ * import {
+ *   createCloudflareWorkflowsDurableExecution,
+ *   createWorkflowEntrypoint,
+ * } from 'ai-workflows/durable-execution'
+ *
+ * type Env = { WORKFLOW: import('cloudflare:workers').Workflow }
+ *
+ * const dx = createCloudflareWorkflowsDurableExecution({
+ *   binding: () => env.WORKFLOW,  // resolved per-request
+ * })
+ *
+ * dx.register('cascade', async (ctx) => {
+ *   const plan = await ctx.step('plan', () => generatePlan(ctx.input))
+ *   await ctx.sleep('1 minute')
+ *   return ctx.step('write', () => writeAll(plan))
+ * })
+ *
+ * // The class wrangler binds; CF instantiates it on each run.
+ * export const MyWorkflow = createWorkflowEntrypoint(dx)
+ *
+ * export default {
+ *   async fetch(req: Request, env: Env) {
+ *     // Trigger from anywhere — adapter.run() goes through the binding.
+ *     const result = await dx.run('cascade', undefined as never, { customerId: 'c-1' })
+ *     return Response.json(result)
+ *   },
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+import { type DurableExecutionAdapter, type Subscription, type WorkflowFn } from './durable-execution.js';
+/**
+ * Minimal `WorkflowStep` shape — only the methods this adapter uses.
+ *
+ * Defined structurally so the adapter compiles in Node test environments and
+ * accepts a pure-JS fake without depending on `cloudflare:workers` at runtime.
+ * In production, callers pass the real `step` argument provided by CF to
+ * their {@link WorkflowEntrypointLike.run} method.
+ */
+export interface WorkflowStepLike {
+    do<T>(name: string, callback: () => Promise<T>): Promise<T>;
+    do<T>(name: string, config: WorkflowStepConfigLike, callback: () => Promise<T>): Promise<T>;
+    sleep(name: string, duration: string | number): Promise<void>;
+    sleepUntil(name: string, timestamp: Date | number): Promise<void>;
+    waitForEvent<T = unknown>(name: string, options: {
+        type: string;
+        timeout?: string | number;
+    }): Promise<{
+        payload: T;
+        type: string;
+        timestamp: Date;
+    } | T>;
+}
+/**
+ * Minimal `WorkflowStepConfig` shape passed to `step.do(name, config, fn)`.
+ * Mirrors CF's `WorkflowStepConfig`. Compatible with our port's
+ * {@link StepConfig}.
+ */
+export interface WorkflowStepConfigLike {
+    retries?: {
+        limit: number;
+        delay: string | number;
+        backoff?: 'constant' | 'linear' | 'exponential';
+    };
+    timeout?: string | number;
+}
+/**
+ * Minimal `WorkflowEvent<T>` shape — only the fields this adapter touches.
+ * `payload` carries the `{ __wfName, __wfInput }` envelope produced by
+ * {@link CloudflareWorkflowsDurableExecution.run}.
+ */
+export interface WorkflowEventLike<T = unknown> {
+    readonly payload: Readonly<T>;
+    readonly timestamp?: Date;
+    readonly instanceId?: string;
+}
+/**
+ * Minimal `WorkflowInstance` shape — only the methods this adapter uses.
+ *
+ * Declared structurally to match CF's `WorkflowInstance` while remaining
+ * testable without `cloudflare:workers`.
+ */
+export interface WorkflowInstanceLike {
+    readonly id: string;
+    status(): Promise<{
+        status: 'queued' | 'running' | 'paused' | 'errored' | 'terminated' | 'complete' | 'waiting' | 'waitingForPause' | 'unknown';
+        error?: {
+            name: string;
+            message: string;
+        };
+        output?: unknown;
+    }>;
+    sendEvent?(args: {
+        type: string;
+        payload: unknown;
+    }): Promise<void>;
+}
+/**
+ * Minimal `Workflow` binding shape — only the methods this adapter uses.
+ *
+ * Mirrors `Workflow<PARAMS>` from `cloudflare:workers`. The adapter accepts
+ * either the binding directly or a thunk that returns it (for environments
+ * where the binding is only resolvable per-request, e.g. inside `fetch`).
+ */
+export interface WorkflowsBindingLike<PARAMS = unknown> {
+    create(options?: {
+        id?: string;
+        params?: PARAMS;
+    }): Promise<WorkflowInstanceLike>;
+    get(id: string): Promise<WorkflowInstanceLike>;
+}
+/**
+ * Base class shape `createWorkflowEntrypoint` extends. Aliased here so users
+ * (and tests) can refer to the structural type without importing
+ * `cloudflare:workers`. Real callers receive an actual `WorkflowEntrypoint`
+ * subclass; tests can stub it.
+ */
+export interface WorkflowEntrypointLike<Env = unknown, T = unknown> {
+    run(event: Readonly<WorkflowEventLike<T>>, step: WorkflowStepLike): Promise<unknown>;
+}
+/**
+ * Options for {@link createCloudflareWorkflowsDurableExecution}.
+ */
+export interface CloudflareWorkflowsDurableExecutionOptions {
+    /**
+     * The CF Workflows binding from a Workers environment, or a thunk that
+     * resolves the binding per-call. Use the thunk form when the binding is
+     * only available inside a request handler (e.g. `() => env.WORKFLOW`).
+     */
+    binding: WorkflowsBindingLike | (() => WorkflowsBindingLike);
+    /**
+     * When `true` (default), {@link DurableExecutionAdapter.run} polls the
+     * created instance's status until it reaches `complete` or `errored` and
+     * returns the workflow output (or throws on `errored`/`terminated`).
+     *
+     * When `false`, `run()` returns the {@link WorkflowInstanceLike} cast to
+     * `unknown` so the caller can manage the lifecycle themselves. Useful for
+     * fire-and-forget triggers or when polling is undesirable.
+     *
+     * Default: `true`.
+     */
+    waitForCompletion?: boolean;
+    /**
+     * Polling interval (ms) when `waitForCompletion` is `true`. Default: 250.
+     */
+    pollIntervalMs?: number;
+    /**
+     * Maximum total wait time (ms) when `waitForCompletion` is `true`. After
+     * this elapses the adapter throws a {@link DurableStepError} with
+     * `retryable: false`. Default: 24 hours (86_400_000 ms). Set higher for
+     * long-sleeping workflows or use `waitForCompletion: false`.
+     */
+    pollTimeoutMs?: number;
+    /**
+     * Override `setTimeout` for tests. Defaults to the global `setTimeout`.
+     * Used by the polling loop and the (no-op) schedule registry.
+     */
+    delay?: (ms: number) => Promise<void>;
+}
+/**
+ * Limits the adapter knows about (per ADR-0004 / current CF docs).
+ */
+export interface CloudflareWorkflowsLimits {
+    /** Maximum steps per workflow (default-configurable as of Mar 2026). */
+    readonly maxSteps: 25_000;
+    /** Maximum concurrent workflow instances per account. */
+    readonly maxConcurrentInstances: 50_000;
+    /** Maximum single sleep / sleepUntil duration. */
+    readonly maxSleepDays: 365;
+    /** Per-step / per-event payload size (CF Workers RPC limit). */
+    readonly maxPayloadBytes: 1_048_576;
+}
+/**
+ * Internal envelope passed as the `params` to `binding.create()`. The
+ * generated {@link WorkflowEntrypointLike} reads these fields from
+ * `event.payload` to dispatch into the registered workflow body.
+ *
+ * Names are double-underscored to avoid collision with user-supplied input
+ * keys when input is itself an object literal — though we always wrap input
+ * inside `__wfInput` so this is belt-and-suspenders.
+ */
+export interface WorkflowEnvelope<TInput = unknown> {
+    readonly __wfName: string;
+    readonly __wfInput: TInput;
+}
+/**
+ * The adapter returned by {@link createCloudflareWorkflowsDurableExecution}.
+ *
+ * Extends {@link DurableExecutionAdapter} with:
+ *
+ *   - {@link CloudflareWorkflowsDurableExecution.register} — explicitly
+ *     register a workflow body before triggering it.
+ *   - {@link CloudflareWorkflowsDurableExecution.defineSchedule} — alias for
+ *     `schedule()` whose name emphasises the wrangler-coordinated nature.
+ *   - {@link CloudflareWorkflowsDurableExecution.runSchedule} — invoke a
+ *     scheduled workflow from a Worker `scheduled()` handler when its cron
+ *     fires.
+ *   - {@link CloudflareWorkflowsDurableExecution.entrypointHandler} — bound
+ *     handler used by the {@link WorkflowEntrypointLike} class to dispatch
+ *     incoming events back into the registered body.
+ *   - {@link CloudflareWorkflowsDurableExecution.limits} — declared CF
+ *     Workflows limits (consumers can introspect to bound their own steps).
+ */
+export interface CloudflareWorkflowsDurableExecution extends DurableExecutionAdapter {
+    readonly kind: 'cloudflare';
+    readonly limits: CloudflareWorkflowsLimits;
+    /**
+     * Register a workflow body under `name`. Subsequent `run(name, ...)` and
+     * scheduled invocations dispatch to it. Calling `register` with an
+     * existing name replaces the previous body.
+     */
+    register<TResult = unknown, TInput = unknown>(name: string, fn: WorkflowFn<TResult, TInput>): void;
+    /**
+     * Alias for {@link DurableExecutionAdapter.schedule}. CF Workflows have no
+     * imperative cron API; the user's wrangler config defines the schedule
+     * (`[triggers] crons = [...]`) and routes to a `scheduled()` handler that
+     * calls {@link runSchedule} when the cron fires.
+     *
+     * Returns a {@link Subscription} whose `id` equals `name`.
+     */
+    defineSchedule<TResult = unknown>(name: string, cron: string, fn: WorkflowFn<TResult, undefined>): Subscription;
+    /**
+     * Invoke a previously registered scheduled workflow. Intended to be called
+     * from a Worker `scheduled()` handler when the cron fires. Returns the
+     * triggered instance handle (or its output if `waitForCompletion`).
+     */
+    runSchedule(name: string): Promise<unknown>;
+    /**
+     * The dispatch handler used by the generated
+     * {@link WorkflowEntrypointLike} class. Exposed so callers can build their
+     * own entrypoint subclass (e.g. to layer custom env-handling) and forward
+     * `(event, step)` here.
+     */
+    entrypointHandler(event: WorkflowEventLike, step: WorkflowStepLike): Promise<unknown>;
+}
+/**
+ * Construct a Cloudflare Workflows {@link DurableExecutionAdapter}.
+ *
+ * The adapter satisfies the full port contract by translating each call into
+ * its CF equivalent (see module docs). Step bodies execute inside CF's
+ * runtime and inherit CF's idempotency, replay, and hibernation semantics.
+ *
+ * **The adapter does not run workflow bodies in-process.** Calling `run()`
+ * triggers a CF Workflow via the supplied binding; the body runs on CF's
+ * infrastructure and the adapter polls (or returns the instance handle).
+ * For tests that need to exercise the body directly without a CF runtime,
+ * use {@link createInProcessDurableExecution} or
+ * {@link createInMemoryDurableExecution} instead.
+ *
+ * @example
+ * ```ts
+ * import { createCloudflareWorkflowsDurableExecution, createWorkflowEntrypoint } from 'ai-workflows/durable-execution'
+ *
+ * type Env = { WORKFLOW: Workflow }
+ *
+ * const dx = createCloudflareWorkflowsDurableExecution({ binding: () => env.WORKFLOW })
+ * dx.register('hello', async (ctx) => `hi, ${ctx.input}`)
+ *
+ * export const HelloWorkflow = createWorkflowEntrypoint(dx)
+ * ```
+ */
+export declare function createCloudflareWorkflowsDurableExecution(options: CloudflareWorkflowsDurableExecutionOptions): CloudflareWorkflowsDurableExecution;
+/**
+ * Constructor-shape returned by {@link createWorkflowEntrypoint} when called
+ * without the optional `Base` class. Callable with `new` like a normal
+ * `WorkflowEntrypoint` subclass — CF instantiates it once per workflow run.
+ *
+ * The first constructor argument is `ctx` (an `ExecutionContext`) and the
+ * second is `env`; declared `unknown` here so this module compiles without
+ * `cloudflare:workers` types in the build environment.
+ */
+export type WorkflowEntrypointConstructor = new (ctx: unknown, env: unknown) => {
+    run(event: WorkflowEventLike, step: WorkflowStepLike): Promise<unknown>;
+};
+/**
+ * Generate a {@link WorkflowEntrypointLike} subclass bound to `adapter`.
+ *
+ * Users export the returned class from their worker module and reference it
+ * in `wrangler.jsonc` under `workflows[].class_name`. CF instantiates the
+ * class for each workflow run, calls its `run(event, step)`, and the adapter
+ * dispatches into the registered body.
+ *
+ * **Why a factory instead of a fixed export?** CF binds workflows by class
+ * name at deploy time — each binding needs its own class identity. The
+ * factory pattern lets users have multiple adapters/classes in one module
+ * (e.g. one per binding) without colliding.
+ *
+ * If `Base` is omitted, this module declares an internal abstract class with
+ * the signature CF expects. In production, callers SHOULD pass the real
+ * `WorkflowEntrypoint` from `cloudflare:workers` so CF's runtime magic (env
+ * injection, `[Rpc.__WORKFLOW_ENTRYPOINT_BRAND]`, etc.) is preserved:
+ *
+ * ```ts
+ * import { WorkflowEntrypoint } from 'cloudflare:workers'
+ * import { createCloudflareWorkflowsDurableExecution, createWorkflowEntrypoint } from 'ai-workflows/durable-execution'
+ *
+ * const dx = createCloudflareWorkflowsDurableExecution({ binding: () => env.WORKFLOW })
+ * export const MyWorkflow = createWorkflowEntrypoint(dx, WorkflowEntrypoint)
+ * ```
+ *
+ * In tests / Node environments where `cloudflare:workers` isn't available,
+ * call without `Base` and the adapter's dispatch logic is exercised against
+ * the structural fake.
+ */
+export declare function createWorkflowEntrypoint<Env = unknown, T = unknown>(adapter: CloudflareWorkflowsDurableExecution, Base?: WorkflowEntrypointConstructor): WorkflowEntrypointConstructor;
+//# sourceMappingURL=durable-execution-cloudflare.d.ts.map

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

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