@workflow/core 4.0.1-beta.4 → 4.0.1-beta.40

package/dist/runtime/start.js

@@ -1,57 +1,68 @@
 import { waitUntil } from '@vercel/functions';
 import { WorkflowRuntimeError } from '@workflow/errors';
+import { withResolvers } from '@workflow/utils';
 import { Run } from '../runtime.js';
 import { dehydrateWorkflowArguments } from '../serialization.js';
 import * as Attribute from '../telemetry/semantic-conventions.js';
 import { serializeTraceCarrier, trace } from '../telemetry.js';
+import { waitedUntil } from '../util.js';
 import { getWorld } from './world.js';
 export async function start(workflow, argsOrOptions, options) {
-    // @ts-expect-error this field is added by our client transform
-    const workflowName = workflow.workflowId;
-    if (!workflowName) {
-        throw new WorkflowRuntimeError(`'start' received an invalid workflow function. Ensure the Workflow Development Kit is configured correctly and the function includes a 'use workflow' directive.`, { slug: 'start-invalid-workflow-function' });
-    }
-    return trace(`WORKFLOW.start ${workflowName}`, async (span) => {
-        span?.setAttributes({
-            ...Attribute.WorkflowName(workflowName),
-            ...Attribute.WorkflowOperation('start'),
-        });
-        let args = [];
-        let opts = options ?? {};
-        if (Array.isArray(argsOrOptions)) {
-            args = argsOrOptions;
-        }
-        else if (typeof argsOrOptions === 'object') {
-            opts = argsOrOptions;
+    return await waitedUntil(() => {
+        // @ts-expect-error this field is added by our client transform
+        const workflowName = workflow?.workflowId;
+        if (!workflowName) {
+            throw new WorkflowRuntimeError(`'start' received an invalid workflow function. Ensure the Workflow Development Kit is configured correctly and the function includes a 'use workflow' directive.`, { slug: 'start-invalid-workflow-function' });
         }
-        span?.setAttributes({
-            ...Attribute.WorkflowArgumentsCount(args.length),
-        });
-        const world = getWorld();
-        const deploymentId = opts.deploymentId ?? (await world.getDeploymentId());
-        const ops = [];
-        const workflowArguments = dehydrateWorkflowArguments(args, ops);
-        // Serialize current trace context to propagate across queue boundary
-        const traceCarrier = await serializeTraceCarrier();
-        const runResponse = await world.runs.create({
-            deploymentId: deploymentId,
-            workflowName: workflowName,
-            input: workflowArguments,
-            executionContext: { traceCarrier },
-        });
-        waitUntil(Promise.all(ops));
-        span?.setAttributes({
-            ...Attribute.WorkflowRunId(runResponse.runId),
-            ...Attribute.WorkflowRunStatus(runResponse.status),
-            ...Attribute.DeploymentId(deploymentId),
-        });
-        await world.queue(`__wkf_workflow_${workflowName}`, {
-            runId: runResponse.runId,
-            traceCarrier,
-        }, {
-            deploymentId,
+        return trace(`WORKFLOW.start ${workflowName}`, async (span) => {
+            span?.setAttributes({
+                ...Attribute.WorkflowName(workflowName),
+                ...Attribute.WorkflowOperation('start'),
+            });
+            let args = [];
+            let opts = options ?? {};
+            if (Array.isArray(argsOrOptions)) {
+                args = argsOrOptions;
+            }
+            else if (typeof argsOrOptions === 'object') {
+                opts = argsOrOptions;
+            }
+            span?.setAttributes({
+                ...Attribute.WorkflowArgumentsCount(args.length),
+            });
+            const world = opts?.world ?? getWorld();
+            const deploymentId = opts.deploymentId ?? (await world.getDeploymentId());
+            const ops = [];
+            const { promise: runIdPromise, resolve: resolveRunId } = withResolvers();
+            const workflowArguments = dehydrateWorkflowArguments(args, ops, runIdPromise);
+            // Serialize current trace context to propagate across queue boundary
+            const traceCarrier = await serializeTraceCarrier();
+            const runResponse = await world.runs.create({
+                deploymentId: deploymentId,
+                workflowName: workflowName,
+                input: workflowArguments,
+                executionContext: { traceCarrier },
+            });
+            resolveRunId(runResponse.runId);
+            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;
+            }));
+            span?.setAttributes({
+                ...Attribute.WorkflowRunId(runResponse.runId),
+                ...Attribute.WorkflowRunStatus(runResponse.status),
+                ...Attribute.DeploymentId(deploymentId),
+            });
+            await world.queue(`__wkf_workflow_${workflowName}`, {
+                runId: runResponse.runId,
+                traceCarrier,
+            }, {
+                deploymentId,
+            });
+            return new Run(runResponse.runId);
         });
-        return new Run(runResponse.runId);
     });
 }
-//# sourceMappingURL=start.js.map
+//# 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":"AA8bA;;;;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,353 @@
+import { waitUntil } from '@vercel/functions';
+import { FatalError, RetryableError, WorkflowAPIError, WorkflowRuntimeError, } from '@workflow/errors';
+import { pluralize } from '@workflow/utils';
+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, handleHealthCheckMessage, parseHealthCheckPayload, 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) => {
+    // Check if this is a health check message
+    // NOTE: Health check messages are intentionally unauthenticated for monitoring purposes.
+    // They only write a simple status response to a stream and do not expose sensitive data.
+    // The stream name includes a unique correlationId that must be known by the caller.
+    const healthCheck = parseHealthCheckPayload(message_);
+    if (healthCheck) {
+        await handleHealthCheckMessage(healthCheck, 'step');
+        return;
+    }
+    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.
+            // Note: maxRetries is the number of RETRIES after the first attempt, so total attempts = maxRetries + 1
+            // Use > here (not >=) because this guards against re-invocation AFTER all attempts are used.
+            // The post-failure check uses >= to decide whether to retry after a failure.
+            if (attempt > maxRetries + 1) {
+                const retryCount = attempt - 1;
+                const errorMessage = `Step "${stepName}" exceeded max retries (${retryCount} ${pluralize('retry', 'retries', retryCount)})`;
+                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,
+                        stack: step.error?.stack,
+                        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, closure variables, and thisVal
+                const ops = [];
+                const hydratedInput = hydrateStepArguments(step.input, ops, workflowRunId);
+                const args = hydratedInput.args;
+                const thisVal = hydratedInput.thisVal ?? null;
+                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(thisVal, 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),
+                    });
+                    // Note: maxRetries is the number of RETRIES after the first attempt, so total attempts = maxRetries + 1
+                    if (attempt >= maxRetries + 1) {
+                        // Max retries reached
+                        const errorStack = getErrorStack(err);
+                        const stackLines = errorStack.split('\n').slice(0, 4);
+                        const retryCount = attempt - 1;
+                        console.error(`[Workflows] "${workflowRunId}" - Encountered \`Error\` while executing step "${stepName}" (attempt ${attempt}, ${retryCount} ${pluralize('retry', 'retries', retryCount)}):\n  > ${stackLines.join('\n    > ')}\n\n  Max retries reached\n  Bubbling error to parent workflow`);
+                        const errorMessage = `Step "${stepName}" failed after ${maxRetries} ${pluralize('retry', 'retries', maxRetries)}: ${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 { Span } from '@opentelemetry/api';
+import type { World } from '@workflow/world';
+import type { WorkflowSuspension } from '../global.js';
+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":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE/C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,KAAK,EAIV,kBAAkB,EACnB,MAAM,cAAc,CAAC;AAOtB,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;AAqLD;;;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"}