@workflow/core 4.0.1-beta.26 → 4.0.1-beta.28

package/dist/runtime/helpers.d.ts

@@ -0,0 +1,25 @@
+import type { Event, World } from '@workflow/world';
+/**
+ * Loads all workflow run events by iterating through all pages of paginated results.
+ * This ensures that *all* events are loaded into memory before running the workflow.
+ * Events must be in chronological order (ascending) for proper workflow replay.
+ */
+export declare function getAllWorkflowRunEvents(runId: string): Promise<Event[]>;
+/**
+ * Wraps a request/response handler and adds a health check "mode"
+ * based on the presence of a `__health` query parameter.
+ */
+export declare function withHealthCheck(handler: (req: Request) => Promise<Response>): (req: Request) => Promise<Response>;
+/**
+ * Queues a message to the specified queue with tracing.
+ */
+export declare function queueMessage(world: World, ...args: Parameters<typeof world.queue>): Promise<void>;
+/**
+ * Calculates the queue overhead time in milliseconds for a given message.
+ */
+export declare function getQueueOverhead(message: {
+    requestedAt?: Date;
+}): {
+    [k: string]: number;
+} | undefined;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/runtime/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/runtime/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAKpD;;;;GAIG;AACH,wBAAsB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAwB7E;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,GAC3C,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAYrC;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,KAAK,EACZ,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,KAAK,CAAC,KAAK,CAAC,iBAcxC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IAAE,WAAW,CAAC,EAAE,IAAI,CAAA;CAAE;;cAS/D"}

package/dist/runtime/helpers.js

@@ -0,0 +1,71 @@
+import * as Attribute from '../telemetry/semantic-conventions.js';
+import { getSpanKind, trace } from '../telemetry.js';
+import { getWorld } from './world.js';
+/**
+ * Loads all workflow run events by iterating through all pages of paginated results.
+ * This ensures that *all* events are loaded into memory before running the workflow.
+ * Events must be in chronological order (ascending) for proper workflow replay.
+ */
+export async function getAllWorkflowRunEvents(runId) {
+    const allEvents = [];
+    let cursor = null;
+    let hasMore = true;
+    const world = getWorld();
+    while (hasMore) {
+        // TODO: we're currently loading all the data with resolveRef behaviour. We need to update this
+        // to lazyload the data from the world instead so that we can optimize and make the event log loading
+        // much faster and memory efficient
+        const response = await world.events.list({
+            runId,
+            pagination: {
+                sortOrder: 'asc', // Required: events must be in chronological order for replay
+                cursor: cursor ?? undefined,
+            },
+        });
+        allEvents.push(...response.data);
+        hasMore = response.hasMore;
+        cursor = response.cursor;
+    }
+    return allEvents;
+}
+/**
+ * Wraps a request/response handler and adds a health check "mode"
+ * based on the presence of a `__health` query parameter.
+ */
+export function withHealthCheck(handler) {
+    return async (req) => {
+        const url = new URL(req.url);
+        const isHealthCheck = url.searchParams.has('__health');
+        if (isHealthCheck) {
+            return new Response(`Workflow DevKit "${url.pathname}" endpoint is healthy`, { status: 200, headers: { 'Content-Type': 'text/plain' } });
+        }
+        return await handler(req);
+    };
+}
+/**
+ * Queues a message to the specified queue with tracing.
+ */
+export async function queueMessage(world, ...args) {
+    const queueName = args[0];
+    await trace('queueMessage', {
+        attributes: Attribute.QueueName(queueName),
+        kind: await getSpanKind('PRODUCER'),
+    }, async (span) => {
+        const { messageId } = await world.queue(...args);
+        span?.setAttributes(Attribute.QueueMessageId(messageId));
+    });
+}
+/**
+ * Calculates the queue overhead time in milliseconds for a given message.
+ */
+export function getQueueOverhead(message) {
+    if (!message.requestedAt)
+        return;
+    try {
+        return Attribute.QueueOverheadMs(Date.now() - message.requestedAt.getTime());
+    }
+    catch {
+        return;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime/step-handler.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A single route that handles any step execution request and routes to the
+ * appropriate step function. We may eventually want to create different bundles
+ * for each step, this is temporary.
+ */
+export declare const stepEntrypoint: (req: Request) => Promise<Response>;
+//# sourceMappingURL=step-handler.d.ts.map

package/dist/runtime/step-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-handler.d.ts","sourceRoot":"","sources":["../../src/runtime/step-handler.ts"],"names":[],"mappings":"AAqaA;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CACjB,CAAC"}

package/dist/runtime/step-handler.js

@@ -0,0 +1,335 @@
+import { waitUntil } from '@vercel/functions';
+import { FatalError, RetryableError, WorkflowAPIError, WorkflowRuntimeError, } from '@workflow/errors';
+import { getPort } from '@workflow/utils/get-port';
+import { StepInvokePayloadSchema } from '@workflow/world';
+import { runtimeLogger } from '../logger.js';
+import { getStepFunction } from '../private.js';
+import { dehydrateStepReturnValue, hydrateStepArguments, } from '../serialization.js';
+import { contextStorage } from '../step/context-storage.js';
+import * as Attribute from '../telemetry/semantic-conventions.js';
+import { getSpanKind, linkToCurrentContext, serializeTraceCarrier, trace, withTraceContext, } from '../telemetry.js';
+import { getErrorName, getErrorStack } from '../types.js';
+import { getQueueOverhead, queueMessage, withHealthCheck } from './helpers.js';
+import { getWorld, getWorldHandlers } from './world.js';
+const DEFAULT_STEP_MAX_RETRIES = 3;
+const stepHandler = getWorldHandlers().createQueueHandler('__wkf_step_', async (message_, metadata) => {
+    const { workflowName, workflowRunId, workflowStartedAt, stepId, traceCarrier: traceContext, requestedAt, } = StepInvokePayloadSchema.parse(message_);
+    const spanLinks = await linkToCurrentContext();
+    // Execute step within the propagated trace context
+    return await withTraceContext(traceContext, async () => {
+        // Extract the step name from the topic name
+        const stepName = metadata.queueName.slice('__wkf_step_'.length);
+        const world = getWorld();
+        // Get the port early to avoid async operations during step execution
+        const port = await getPort();
+        return trace(`STEP ${stepName}`, { kind: await getSpanKind('CONSUMER'), links: spanLinks }, async (span) => {
+            span?.setAttributes({
+                ...Attribute.StepName(stepName),
+                ...Attribute.StepAttempt(metadata.attempt),
+                ...Attribute.QueueName(metadata.queueName),
+                ...Attribute.QueueMessageId(metadata.messageId),
+                ...getQueueOverhead({ requestedAt }),
+            });
+            const stepFn = getStepFunction(stepName);
+            if (!stepFn) {
+                throw new Error(`Step "${stepName}" not found`);
+            }
+            if (typeof stepFn !== 'function') {
+                throw new Error(`Step "${stepName}" is not a function (got ${typeof stepFn})`);
+            }
+            const maxRetries = stepFn.maxRetries ?? DEFAULT_STEP_MAX_RETRIES;
+            span?.setAttributes({
+                ...Attribute.WorkflowName(workflowName),
+                ...Attribute.WorkflowRunId(workflowRunId),
+                ...Attribute.StepId(stepId),
+                ...Attribute.StepMaxRetries(maxRetries),
+                ...Attribute.StepTracePropagated(!!traceContext),
+            });
+            let step = await world.steps.get(workflowRunId, stepId);
+            runtimeLogger.debug('Step execution details', {
+                stepName,
+                stepId: step.stepId,
+                status: step.status,
+                attempt: step.attempt,
+            });
+            span?.setAttributes({
+                ...Attribute.StepStatus(step.status),
+            });
+            // Check if the step has a `retryAfter` timestamp that hasn't been reached yet
+            const now = Date.now();
+            if (step.retryAfter && step.retryAfter.getTime() > now) {
+                const timeoutSeconds = Math.ceil((step.retryAfter.getTime() - now) / 1000);
+                span?.setAttributes({
+                    ...Attribute.StepRetryTimeoutSeconds(timeoutSeconds),
+                });
+                runtimeLogger.debug('Step retryAfter timestamp not yet reached', {
+                    stepName,
+                    stepId: step.stepId,
+                    retryAfter: step.retryAfter,
+                    timeoutSeconds,
+                });
+                return { timeoutSeconds };
+            }
+            let result;
+            const attempt = step.attempt + 1;
+            // Check max retries FIRST before any state changes.
+            // This handles edge cases where the step handler is invoked after max retries have been exceeded
+            // (e.g., when the step repeatedly times out or fails before reaching the catch handler at line 822).
+            // Without this check, the step would retry forever.
+            if (attempt > maxRetries) {
+                const errorMessage = `Step "${stepName}" exceeded max retries (${attempt} attempts)`;
+                console.error(`[Workflows] "${workflowRunId}" - ${errorMessage}`);
+                // Update step status first (idempotent), then create event
+                await world.steps.update(workflowRunId, stepId, {
+                    status: 'failed',
+                    error: {
+                        message: errorMessage,
+                        stack: undefined,
+                    },
+                });
+                await world.events.create(workflowRunId, {
+                    eventType: 'step_failed',
+                    correlationId: stepId,
+                    eventData: {
+                        error: errorMessage,
+                        fatal: true,
+                    },
+                });
+                span?.setAttributes({
+                    ...Attribute.StepStatus('failed'),
+                    ...Attribute.StepRetryExhausted(true),
+                });
+                // Re-invoke the workflow to handle the failed step
+                await queueMessage(world, `__wkf_workflow_${workflowName}`, {
+                    runId: workflowRunId,
+                    traceCarrier: await serializeTraceCarrier(),
+                    requestedAt: new Date(),
+                });
+                return;
+            }
+            try {
+                if (!['pending', 'running'].includes(step.status)) {
+                    // We should only be running the step if it's either
+                    // a) pending - initial state, or state set on re-try
+                    // b) running - if a step fails mid-execution, like a function timeout
+                    // otherwise, the step has been invoked erroneously
+                    console.error(`[Workflows] "${workflowRunId}" - Step invoked erroneously, expected status "pending" or "running", got "${step.status}" instead, skipping execution`);
+                    span?.setAttributes({
+                        ...Attribute.StepSkipped(true),
+                        ...Attribute.StepSkipReason(step.status),
+                    });
+                    // There's a chance that a step terminates correctly, but the underlying process
+                    // fails or gets killed before the stepEntrypoint has a chance to re-enqueue the run.
+                    // The queue lease expires and stepEntrypoint again, which leads us here, so
+                    // we optimistically re-enqueue the workflow if the step is in a terminal state,
+                    // under the assumption that this edge case happened.
+                    // Until we move to atomic entity/event updates (World V2), there _could_ be an edge case
+                    // where the we execute this code based on the `step` entity status, but the runtime
+                    // failed to create the `step_completed` event (due to failing between step and event update),
+                    // in which case, this might lead to an infinite loop.
+                    // https://vercel.slack.com/archives/C09125LC4AX/p1765313809066679
+                    const isTerminalStep = [
+                        'completed',
+                        'failed',
+                        'cancelled',
+                    ].includes(step.status);
+                    if (isTerminalStep) {
+                        await queueMessage(world, `__wkf_workflow_${workflowName}`, {
+                            runId: workflowRunId,
+                            traceCarrier: await serializeTraceCarrier(),
+                            requestedAt: new Date(),
+                        });
+                    }
+                    return;
+                }
+                await world.events.create(workflowRunId, {
+                    eventType: 'step_started', // TODO: Replace with 'step_retrying'
+                    correlationId: stepId,
+                });
+                step = await world.steps.update(workflowRunId, stepId, {
+                    attempt,
+                    status: 'running',
+                });
+                if (!step.startedAt) {
+                    throw new WorkflowRuntimeError(`Step "${stepId}" has no "startedAt" timestamp`);
+                }
+                // Hydrate the step input arguments and closure variables
+                const ops = [];
+                const hydratedInput = hydrateStepArguments(step.input, ops, workflowRunId);
+                const args = hydratedInput.args;
+                span?.setAttributes({
+                    ...Attribute.StepArgumentsCount(args.length),
+                });
+                result = await contextStorage.run({
+                    stepMetadata: {
+                        stepId,
+                        stepStartedAt: new Date(+step.startedAt),
+                        attempt,
+                    },
+                    workflowMetadata: {
+                        workflowRunId,
+                        workflowStartedAt: new Date(+workflowStartedAt),
+                        // TODO: there should be a getUrl method on the world interface itself. This
+                        // solution only works for vercel + local worlds.
+                        url: process.env.VERCEL_URL
+                            ? `https://${process.env.VERCEL_URL}`
+                            : `http://localhost:${port ?? 3000}`,
+                    },
+                    ops,
+                    closureVars: hydratedInput.closureVars,
+                }, () => stepFn.apply(null, args));
+                // NOTE: None of the code from this point is guaranteed to run
+                // Since the step might fail or cause a function timeout and the process might be SIGKILL'd
+                // The workflow runtime must be resilient to the below code not executing on a failed step
+                result = dehydrateStepReturnValue(result, ops, workflowRunId);
+                waitUntil(Promise.all(ops).catch((err) => {
+                    // Ignore expected client disconnect errors (e.g., browser refresh during streaming)
+                    const isAbortError = err?.name === 'AbortError' || err?.name === 'ResponseAborted';
+                    if (!isAbortError)
+                        throw err;
+                }));
+                // Mark the step as completed first. This order is important. If a concurrent
+                // execution marked the step as complete, this request should throw, and
+                // this prevent the step_completed event in the event log
+                // TODO: this should really be atomic and handled by the world
+                await world.steps.update(workflowRunId, stepId, {
+                    status: 'completed',
+                    output: result,
+                });
+                // Then, append the event log with the step result
+                await world.events.create(workflowRunId, {
+                    eventType: 'step_completed',
+                    correlationId: stepId,
+                    eventData: {
+                        result: result,
+                    },
+                });
+                span?.setAttributes({
+                    ...Attribute.StepStatus('completed'),
+                    ...Attribute.StepResultType(typeof result),
+                });
+            }
+            catch (err) {
+                span?.setAttributes({
+                    ...Attribute.StepErrorName(getErrorName(err)),
+                    ...Attribute.StepErrorMessage(String(err)),
+                });
+                if (WorkflowAPIError.is(err)) {
+                    if (err.status === 410) {
+                        // Workflow has already completed, so no-op
+                        console.warn(`Workflow run "${workflowRunId}" has already completed, skipping step "${stepId}": ${err.message}`);
+                        return;
+                    }
+                }
+                if (FatalError.is(err)) {
+                    const errorStack = getErrorStack(err);
+                    const stackLines = errorStack.split('\n').slice(0, 4);
+                    console.error(`[Workflows] "${workflowRunId}" - Encountered \`FatalError\` while executing step "${stepName}":\n  > ${stackLines.join('\n    > ')}\n\nBubbling up error to parent workflow`);
+                    // Fatal error - store the error in the event log and re-invoke the workflow
+                    await world.events.create(workflowRunId, {
+                        eventType: 'step_failed',
+                        correlationId: stepId,
+                        eventData: {
+                            error: String(err),
+                            stack: errorStack,
+                            fatal: true,
+                        },
+                    });
+                    await world.steps.update(workflowRunId, stepId, {
+                        status: 'failed',
+                        error: {
+                            message: err.message || String(err),
+                            stack: errorStack,
+                            // TODO: include error codes when we define them
+                        },
+                    });
+                    span?.setAttributes({
+                        ...Attribute.StepStatus('failed'),
+                        ...Attribute.StepFatalError(true),
+                    });
+                }
+                else {
+                    const maxRetries = stepFn.maxRetries ?? DEFAULT_STEP_MAX_RETRIES;
+                    span?.setAttributes({
+                        ...Attribute.StepAttempt(attempt),
+                        ...Attribute.StepMaxRetries(maxRetries),
+                    });
+                    if (attempt > maxRetries) {
+                        // Max retries reached
+                        const errorStack = getErrorStack(err);
+                        const stackLines = errorStack.split('\n').slice(0, 4);
+                        console.error(`[Workflows] "${workflowRunId}" - Encountered \`Error\` while executing step "${stepName}" (attempt ${attempt}):\n  > ${stackLines.join('\n    > ')}\n\n  Max retries reached\n  Bubbling error to parent workflow`);
+                        const errorMessage = `Step "${stepName}" failed after max retries: ${String(err)}`;
+                        await world.events.create(workflowRunId, {
+                            eventType: 'step_failed',
+                            correlationId: stepId,
+                            eventData: {
+                                error: errorMessage,
+                                stack: errorStack,
+                                fatal: true,
+                            },
+                        });
+                        await world.steps.update(workflowRunId, stepId, {
+                            status: 'failed',
+                            error: {
+                                message: errorMessage,
+                                stack: errorStack,
+                            },
+                        });
+                        span?.setAttributes({
+                            ...Attribute.StepStatus('failed'),
+                            ...Attribute.StepRetryExhausted(true),
+                        });
+                    }
+                    else {
+                        // Not at max retries yet - log as a retryable error
+                        if (RetryableError.is(err)) {
+                            console.warn(`[Workflows] "${workflowRunId}" - Encountered \`RetryableError\` while executing step "${stepName}" (attempt ${attempt}):\n  > ${String(err.message)}\n\n  This step has failed but will be retried`);
+                        }
+                        else {
+                            const stackLines = getErrorStack(err).split('\n').slice(0, 4);
+                            console.error(`[Workflows] "${workflowRunId}" - Encountered \`Error\` while executing step "${stepName}" (attempt ${attempt}):\n  > ${stackLines.join('\n    > ')}\n\n  This step has failed but will be retried`);
+                        }
+                        await world.events.create(workflowRunId, {
+                            eventType: 'step_failed',
+                            correlationId: stepId,
+                            eventData: {
+                                error: String(err),
+                                stack: getErrorStack(err),
+                            },
+                        });
+                        await world.steps.update(workflowRunId, stepId, {
+                            status: 'pending', // TODO: Should be "retrying" once we have that status
+                            ...(RetryableError.is(err) && {
+                                retryAfter: err.retryAfter,
+                            }),
+                        });
+                        const timeoutSeconds = Math.max(1, RetryableError.is(err)
+                            ? Math.ceil((+err.retryAfter.getTime() - Date.now()) / 1000)
+                            : 1);
+                        span?.setAttributes({
+                            ...Attribute.StepRetryTimeoutSeconds(timeoutSeconds),
+                            ...Attribute.StepRetryWillRetry(true),
+                        });
+                        // It's a retryable error - so have the queue keep the message visible
+                        // so that it gets retried.
+                        return { timeoutSeconds };
+                    }
+                }
+            }
+            await queueMessage(world, `__wkf_workflow_${workflowName}`, {
+                runId: workflowRunId,
+                traceCarrier: await serializeTraceCarrier(),
+                requestedAt: new Date(),
+            });
+        });
+    });
+});
+/**
+ * A single route that handles any step execution request and routes to the
+ * appropriate step function. We may eventually want to create different bundles
+ * for each step, this is temporary.
+ */
+export const stepEntrypoint = 
+/* @__PURE__ */ withHealthCheck(stepHandler);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-handler.js","sourceRoot":"","sources":["../../src/runtime/step-handler.ts"],"names":[],"mappings":"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"}

package/dist/runtime/suspension-handler.d.ts

@@ -0,0 +1,20 @@
+import type { World } from '@workflow/world';
+import type { WorkflowSuspension } from '../global.js';
+import type { Span } from '@opentelemetry/api';
+export interface SuspensionHandlerParams {
+    suspension: WorkflowSuspension;
+    world: World;
+    runId: string;
+    workflowName: string;
+    workflowStartedAt: number;
+    span?: Span;
+}
+export interface SuspensionHandlerResult {
+    timeoutSeconds?: number;
+}
+/**
+ * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).
+ * Hooks are processed first to prevent race conditions, then steps and waits in parallel.
+ */
+export declare function handleSuspension({ suspension, world, runId, workflowName, workflowStartedAt, span, }: SuspensionHandlerParams): Promise<SuspensionHandlerResult>;
+//# sourceMappingURL=suspension-handler.d.ts.map

package/dist/runtime/suspension-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suspension-handler.d.ts","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,KAAK,EAIV,kBAAkB,EACnB,MAAM,cAAc,CAAC;AAKtB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAG/C,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,kBAAkB,CAAC;IAC/B,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,IAAI,CAAC,EAAE,IAAI,CAAC;CACb;AAED,MAAM,WAAW,uBAAuB;IACtC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AA2KD;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,UAAU,EACV,KAAK,EACL,KAAK,EACL,YAAY,EACZ,iBAAiB,EACjB,IAAI,GACL,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAwE5D"}