@hatchet-dev/typescript-sdk 1.21.2 → 1.22.0

package/v1/examples/agent/workflow.js

@@ -0,0 +1,48 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTemperatureWorkflow = exports.getTemperature = void 0;
+// > Declaring a Task
+const hatchet_client_1 = require("../hatchet-client");
+const v4_1 = require("zod/v4");
+// Note that for agent tools, Zod must be used to create the input and output types for workflows/tasks
+const TemperatureCoordinates = v4_1.z.object({
+    latitude: v4_1.z.number(),
+    longitude: v4_1.z.number(),
+});
+const TemperatureInput = v4_1.z.object({
+    locationName: v4_1.z.string(),
+    coords: TemperatureCoordinates,
+});
+const temperatureRequest = (input) => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield fetch(`https://api.open-meteo.com/v1/forecast?latitude=${input.coords.latitude}&longitude=${input.coords.longitude}&current=temperature_2m&temperature_unit=fahrenheit`);
+    const data = yield response.json();
+    return {
+        text: `Temperature: ${data.current.temperature_2m}°F`,
+    };
+});
+exports.getTemperature = hatchet_client_1.hatchet.task({
+    name: 'getTemperature',
+    retries: 3,
+    fn: temperatureRequest,
+    inputValidator: TemperatureInput,
+    description: 'Get the current temperature at a location',
+});
+exports.getTemperatureWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'getTemperatureWorkflow',
+    inputValidator: TemperatureInput,
+    description: 'Get the current temperature at a location',
+});
+exports.getTemperatureWorkflow.task({
+    name: 'getTemperature',
+    fn: temperatureRequest,
+});
+// !!

package/v1/examples/durable/workflow.d.ts

@@ -71,8 +71,12 @@ export declare const waitForTwoEventsSecondPushedFirst: import("../..").TaskWork
     scope: string;
 }, {
     elapsed: number;
-    event1: any;
-    event2: any;
+    event1: {
+        order: string;
+    };
+    event2: {
+        order: string;
+    };
 }, {}, {}, {}, {}>;
 export declare const memoNowCaching: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
     start_time: string;

package/v1/examples/durable/workflow.js

@@ -13,7 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.durableSpawnDag = exports.dagChildWorkflow = exports.memoNowCaching = exports.waitForTwoEventsSecondPushedFirst = exports.waitForOrEventLookback = exports.waitForEventLookback = exports.LOOKBACK_WINDOW = exports.durableReplayReset = exports.REPLAY_RESET_MEMOIZED_MAX_SECONDS = exports.REPLAY_RESET_SLEEP_SECONDS = exports.durableNonDeterminism = exports.durableWithExplicitSpawn = exports.durableSleepEventSpawn = exports.durableWithBulkSpawn = exports.durableWithSpawn = exports.spawnChildTask = exports.waitForSleepTwice = exports.durableWorkflow = exports.SLEEP_TIME = exports.SLEEP_TIME_SECONDS = exports.EVENT_KEY = void 0;
-const zod_1 = require("zod");
+const v4_1 = require("zod/v4");
 const conditions_1 = require("../../conditions");
 const non_determinism_error_1 = require("../../../util/errors/non-determinism-error");
 const sleep_1 = __importDefault(require("../../../util/sleep"));
@@ -226,9 +226,12 @@ exports.durableReplayReset = hatchet_client_1.hatchet.durableTask({
     }),
 });
 exports.LOOKBACK_WINDOW = '1m';
-const lookbackEventPayloadSchema = zod_1.z.object({
-    order: zod_1.z.string(),
-    user_id: zod_1.z.number(),
+const lookbackEventPayloadSchema = v4_1.z.object({
+    order: v4_1.z.string(),
+    user_id: v4_1.z.number(),
+});
+const twoEventsPayloadSchema = v4_1.z.object({
+    order: v4_1.z.string(),
 });
 exports.waitForEventLookback = hatchet_client_1.hatchet.durableTask({
     name: 'wait-for-event-lookback',
@@ -262,8 +265,8 @@ exports.waitForTwoEventsSecondPushedFirst = hatchet_client_1.hatchet.durableTask
     executionTimeout: '10m',
     fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         const start = Date.now();
-        const event1 = yield ctx.waitForEvent('key1', undefined, undefined, input.scope, exports.LOOKBACK_WINDOW);
-        const event2 = yield ctx.waitForEvent('key2', undefined, undefined, input.scope, exports.LOOKBACK_WINDOW);
+        const event1 = yield ctx.waitForEvent('key1', undefined, twoEventsPayloadSchema, input.scope, exports.LOOKBACK_WINDOW);
+        const event2 = yield ctx.waitForEvent('key2', undefined, twoEventsPayloadSchema, input.scope, exports.LOOKBACK_WINDOW);
         return {
             elapsed: (Date.now() - start) / 1000,
             event1,

package/v1/examples/durable_eviction/workflow.js

@@ -18,11 +18,13 @@ const hatchet_client_1 = require("../hatchet-client");
 exports.EVICTION_TTL_SECONDS = 5;
 exports.LONG_SLEEP_SECONDS = 15;
 exports.EVENT_KEY = 'durable-eviction:event';
+// > Eviction Policy
 const EVICTION_POLICY = {
     ttl: `${exports.EVICTION_TTL_SECONDS}s`,
     allowCapacityEviction: true,
     priority: 0,
 };
+// !!
 exports.childTask = hatchet_client_1.hatchet.task({
     name: 'eviction-child-task',
     fn: () => __awaiter(void 0, void 0, void 0, function* () {
@@ -30,6 +32,7 @@ exports.childTask = hatchet_client_1.hatchet.task({
         return { child_status: 'completed' };
     }),
 });
+// > Evictable Sleep
 exports.evictableSleep = hatchet_client_1.hatchet.durableTask({
     name: 'evictable-sleep',
     executionTimeout: '5m',
@@ -39,6 +42,7 @@ exports.evictableSleep = hatchet_client_1.hatchet.durableTask({
         return { status: 'completed' };
     }),
 });
+// !!
 // NOTE: DO NOT REGISTER ON E2E TEST WORKER
 exports.evictableSleepForGracefulTermination = hatchet_client_1.hatchet.durableTask({
     name: 'evictable-sleep-for-graceful-termination',
@@ -114,6 +118,7 @@ exports.capacityEvictableSleep = hatchet_client_1.hatchet.durableTask({
         return { status: 'completed' };
     }),
 });
+// > Non Evictable Sleep
 exports.nonEvictableSleep = hatchet_client_1.hatchet.durableTask({
     name: 'non-evictable-sleep',
     executionTimeout: '5m',
@@ -127,3 +132,4 @@ exports.nonEvictableSleep = hatchet_client_1.hatchet.durableTask({
         return { status: 'completed' };
     }),
 });
+// !!

package/v1/examples/e2e-worker.js

@@ -40,6 +40,8 @@ const workflow_18 = require("./streaming/workflow");
 const workflow_19 = require("./timeout/workflow");
 const workflow_20 = require("./webhooks/workflow");
 const workflow_21 = require("./child_index/workflow");
+const workflow_22 = require("./support_agent/workflow");
+const workflow_23 = require("./welcome_email/workflow");
 const workflows = [
     workflow_1.bulkChild,
     workflow_1.bulkParentWorkflow,
@@ -94,6 +96,11 @@ const workflows = [
     workflow_21.childIndexParent,
     workflow_21.scenarioTask,
     workflow_21.orchestratorTask,
+    workflow_22.supportAgent,
+    workflow_22.triageTicket,
+    workflow_22.generateReply,
+    workflow_22.escalateTicket,
+    workflow_23.welcomeEmail,
 ];
 function main() {
     return __awaiter(this, void 0, void 0, function* () {

package/v1/examples/simple/run.js

@@ -13,6 +13,7 @@ exports.extra = extra;
 const hatchet_client_1 = require("../hatchet-client");
 const workflow_1 = require("./workflow");
 const workflow_with_child_1 = require("./workflow-with-child");
+const zod_1 = require("./zod");
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         // > Running a Task
@@ -23,6 +24,10 @@ function main() {
                 test: 'test',
             },
         });
+        const res3 = yield zod_1.simpleWithZod.run({
+            Message: 'HeLlO WoRlD',
+        });
+        console.log(res3.TransformedMessage);
         // 👀 Access the results of the Task
         console.log(res.TransformedMessage);
         // !!

package/v1/examples/simple/zod.d.ts

@@ -1,11 +1,7 @@
-import * as z from 'zod';
+import * as z from 'zod/v4';
 declare const SimpleInputSchema: z.ZodObject<{
     Message: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    Message: string;
-}, {
-    Message: string;
-}>;
+}, z.core.$strip>;
 export type SimpleInputWithZod = z.infer<typeof SimpleInputSchema>;
 export declare const simpleWithZod: import("../..").TaskWorkflowDeclaration<{
     Message: string;

package/v1/examples/simple/zod.js

@@ -44,7 +44,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.simpleWithZod = void 0;
 // > Declaring a Task
-const z = __importStar(require("zod"));
+const z = __importStar(require("zod/v4"));
 const hatchet_client_1 = require("../hatchet-client");
 const SimpleInputSchema = z.object({
     Message: z.string(),

package/v1/examples/support_agent/run.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/support_agent/run.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const hatchet_client_1 = require("../hatchet-client");
+const workflow_1 = require("./workflow");
+// > Trigger the workflow
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const input = {
+            ticketId: 'ticket-42',
+            customerEmail: 'alice@example.com',
+            subject: 'Login broken',
+            body: "I can't log in since this morning.",
+        };
+        // Start the support agent workflow
+        const ref = yield workflow_1.supportAgent.runNoWait(input);
+        const runId = yield ref.getWorkflowRunId();
+        console.log(`Started workflow run: ${runId}`);
+        // Push a customer reply event (scoped to this ticket)
+        console.log('Pushing customer reply event...');
+        yield hatchet_client_1.hatchet.events.push(workflow_1.REPLY_EVENT_KEY, { message: 'I cleared my cookies and it works now. Thanks!' }, { scope: input.ticketId });
+        // Wait for the workflow to complete
+        const result = yield ref.output;
+        console.log('Workflow completed:', result);
+    });
+}
+// !!
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => {
+        process.exit(0);
+    });
+}

package/v1/examples/support_agent/workflow.d.ts

@@ -0,0 +1,43 @@
+export declare const REPLY_EVENT_KEY = "support:customer-reply";
+export declare const TIMEOUT_SECONDS = 5;
+export type SupportTicketInput = {
+    ticketId: string;
+    customerEmail: string;
+    subject: string;
+    body: string;
+};
+export type TriageOutput = {
+    category: string;
+    priority: string;
+};
+export type ReplyOutput = {
+    message: string;
+};
+export type EscalationOutput = {
+    reason: string;
+    assignedTo: string;
+};
+export declare const triageTicket: import("../..").TaskWorkflowDeclaration<SupportTicketInput, {
+    category: string;
+    priority: string;
+}, {}, {}, {}, {}>;
+export declare const generateReply: import("../..").TaskWorkflowDeclaration<SupportTicketInput, {
+    message: any;
+}, {}, {}, {}, {}>;
+export declare const escalateTicket: import("../..").TaskWorkflowDeclaration<SupportTicketInput, {
+    reason: string;
+    assignedTo: string;
+}, {}, {}, {}, {}>;
+export declare const supportAgent: import("../..").TaskWorkflowDeclaration<SupportTicketInput, {
+    ticketId: string;
+    status: "escalated";
+    triageCategory: string;
+    triagePriority: string;
+    initialReply: any;
+} | {
+    ticketId: string;
+    status: "resolved";
+    triageCategory: string;
+    triagePriority: string;
+    initialReply: any;
+}, {}, {}, {}, {}>;

package/v1/examples/support_agent/workflow.js

@@ -0,0 +1,140 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportAgent = exports.escalateTicket = exports.generateReply = exports.triageTicket = exports.TIMEOUT_SECONDS = exports.REPLY_EVENT_KEY = void 0;
+const conditions_1 = require("../../conditions");
+const duration_1 = require("../../client/duration");
+const hatchet_client_1 = require("../hatchet-client");
+exports.REPLY_EVENT_KEY = 'support:customer-reply';
+const REPLY_LABEL = 'reply';
+const TIMEOUT_LABEL = 'timeout';
+exports.TIMEOUT_SECONDS = 5;
+const LOOKBACK_WINDOW = '5m';
+// !!
+// > Triage task
+// Classify the ticket into a category and priority.
+exports.triageTicket = hatchet_client_1.hatchet.task({
+    name: 'triage-ticket',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        const text = `${input.subject} ${input.body}`.toLowerCase();
+        let category;
+        if (['bill', 'charge', 'payment', 'invoice'].some((w) => text.includes(w))) {
+            category = 'billing';
+        }
+        else if (['login', 'password', 'auth', 'access'].some((w) => text.includes(w))) {
+            category = 'account';
+        }
+        else {
+            category = 'technical';
+        }
+        let priority;
+        if (['urgent', 'critical', 'down', 'outage'].some((w) => text.includes(w))) {
+            priority = 'high';
+        }
+        else if (['twice', 'broken', 'error'].some((w) => text.includes(w))) {
+            priority = 'medium';
+        }
+        else {
+            priority = 'low';
+        }
+        return { category, priority };
+    }),
+});
+// !!
+// > Generate reply task
+// Generate an initial support reply using Claude.
+exports.generateReply = hatchet_client_1.hatchet.task({
+    name: 'generate-reply',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+            return {
+                message: `Thank you for contacting support about: ${input.subject}. We are looking into this and will get back to you shortly.`,
+            };
+        }
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const anthropic = require('@anthropic-ai/sdk');
+        const Anthropic = anthropic.default || anthropic;
+        const client = new Anthropic({ apiKey });
+        const response = yield client.messages.create({
+            model: 'claude-sonnet-4-20250514',
+            max_tokens: 300,
+            messages: [
+                {
+                    role: 'user',
+                    content: `You are a friendly support agent. Write a brief, helpful initial ` +
+                        `reply to this support ticket.\n\n` +
+                        `Subject: ${input.subject}\n` +
+                        `Message: ${input.body}\n\n` +
+                        `Keep the reply under 3 sentences.`,
+                },
+            ],
+        });
+        const [block] = response.content;
+        const text = (block === null || block === void 0 ? void 0 : block.type) === 'text' ? block.text : '';
+        return { message: text };
+    }),
+});
+// !!
+// > Escalate task
+// Escalate an unresolved ticket to the human support team.
+exports.escalateTicket = hatchet_client_1.hatchet.task({
+    name: 'escalate-ticket',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        return {
+            reason: `No customer reply within ${exports.TIMEOUT_SECONDS}s timeout`,
+            assignedTo: 'support-team@example.com',
+        };
+    }),
+});
+// !!
+// > Support agent workflow
+exports.supportAgent = hatchet_client_1.hatchet.durableTask({
+    name: 'support-agent',
+    executionTimeout: '10m',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        // Step 1: Triage the ticket
+        const triage = yield exports.triageTicket.run(input);
+        // Step 2: Generate an initial reply
+        const reply = yield exports.generateReply.run(input);
+        // Step 3: Wait for a customer reply or timeout
+        const now = yield ctx.now();
+        const considerEventsSince = new Date(now.getTime() - (0, duration_1.durationToMs)(LOOKBACK_WINDOW)).toISOString();
+        const waitResult = yield ctx.waitFor((0, conditions_1.Or)(new conditions_1.SleepCondition(`${exports.TIMEOUT_SECONDS}s`, TIMEOUT_LABEL), new conditions_1.UserEventCondition(exports.REPLY_EVENT_KEY, '', REPLY_LABEL, undefined, input.ticketId, considerEventsSince)));
+        // Determine which condition fired. ctx.waitFor returns
+        // { CREATE: { <label>: ... } } where <label> is the readableDataKey
+        // we assigned above ('timeout' or 'reply').
+        const create = (_a = waitResult['CREATE']) !== null && _a !== void 0 ? _a : waitResult;
+        const resolvedLabel = (_b = Object.keys(create)[0]) !== null && _b !== void 0 ? _b : '';
+        const customerReplied = resolvedLabel === REPLY_LABEL;
+        if (!customerReplied) {
+            // Step 4a: Timeout -> escalate
+            yield exports.escalateTicket.run(input);
+            return {
+                ticketId: input.ticketId,
+                status: 'escalated',
+                triageCategory: triage.category,
+                triagePriority: triage.priority,
+                initialReply: reply.message,
+            };
+        }
+        // Step 4b: Customer replied -> resolve
+        return {
+            ticketId: input.ticketId,
+            status: 'resolved',
+            triageCategory: triage.category,
+            triagePriority: triage.priority,
+            initialReply: reply.message,
+        };
+    }),
+});
+// !!

package/v1/examples/welcome_email/run.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/welcome_email/run.js

@@ -0,0 +1,40 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// > Trigger the workflow
+const hatchet_client_1 = require("../hatchet-client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const input = {
+            email: 'alice@example.com',
+            user_id: 'user-123',
+        };
+        // Start the welcome-email workflow
+        const ref = yield workflow_1.welcomeEmail.runNoWait(input);
+        const runId = yield ref.getWorkflowRunId();
+        console.log(`Started workflow run: ${runId}`);
+        // Push onboarding-completed event (scoped to this user)
+        console.log('Pushing onboarding-completed event...');
+        yield hatchet_client_1.hatchet.events.push(workflow_1.ONBOARDING_EVENT_KEY, { status: 'done' }, { scope: input.user_id });
+        // Wait for the workflow to complete
+        const result = yield ref.output;
+        console.log('Workflow completed:', result);
+    });
+}
+// !!
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => {
+        process.exit(0);
+    });
+}

package/v1/examples/welcome_email/workflow.d.ts

@@ -0,0 +1,11 @@
+export declare const ONBOARDING_EVENT_KEY = "user:onboarding-completed";
+export type SignupInput = {
+    email: string;
+    user_id: string;
+};
+export type WelcomeEmailResult = {
+    userId: string;
+    welcomeSent: boolean;
+    followUpSent: boolean;
+};
+export declare const welcomeEmail: import("../..").TaskWorkflowDeclaration<SignupInput, WelcomeEmailResult, {}, {}, {}, {}>;

package/v1/examples/welcome_email/workflow.js

@@ -0,0 +1,52 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.welcomeEmail = exports.ONBOARDING_EVENT_KEY = void 0;
+const conditions_1 = require("../../conditions");
+const duration_1 = require("../../client/duration");
+const hatchet_client_1 = require("../hatchet-client");
+exports.ONBOARDING_EVENT_KEY = 'user:onboarding-completed';
+const TIMEOUT_SECONDS = 5;
+const LOOKBACK_WINDOW = '5m';
+// !!
+// > Welcome email task
+exports.welcomeEmail = hatchet_client_1.hatchet.durableTask({
+    name: 'welcome-email',
+    onEvents: ['user:signup'],
+    executionTimeout: '5m',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        // Step 1: Send the welcome email
+        console.log(`Sending welcome email to ${input.email}: finish your first onboarding step`);
+        // Step 2: Wait for the user to complete onboarding, or time out
+        // (use a longer duration for a more realistic workflow)
+        const now = yield ctx.now();
+        const considerEventsSince = new Date(now.getTime() - (0, duration_1.durationToMs)(LOOKBACK_WINDOW)).toISOString();
+        const waitResult = yield ctx.waitFor((0, conditions_1.Or)({ sleepFor: `${TIMEOUT_SECONDS}s` }, 
+        // Scope the event condition to this user so that another user's
+        // onboarding-completed event does not resolve this wait.
+        { eventKey: exports.ONBOARDING_EVENT_KEY, scope: input.user_id, considerEventsSince }));
+        // The or-group result is { CREATE: { <condition_key>: ... } }.
+        // Check whether the onboarding event was the one that resolved.
+        const create = (_a = waitResult['CREATE']) !== null && _a !== void 0 ? _a : waitResult;
+        const resolvedKey = (_b = Object.keys(create)[0]) !== null && _b !== void 0 ? _b : '';
+        const onboardingCompleted = resolvedKey === exports.ONBOARDING_EVENT_KEY;
+        if (onboardingCompleted) {
+            // Step 3a: User completed onboarding -> skip follow-up
+            console.log(`User ${input.user_id} completed onboarding, skipping follow-up`);
+            return { userId: input.user_id, welcomeSent: true, followUpSent: false };
+        }
+        // Step 3b: Timeout -> send follow-up email
+        console.log(`Sending follow-up email to ${input.email}: need help finishing onboarding?`);
+        return { userId: input.user_id, welcomeSent: true, followUpSent: true };
+    }),
+});
+// !!

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.21.2";
+export declare const HATCHET_VERSION = "1.22.0";

package/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HATCHET_VERSION = void 0;
-exports.HATCHET_VERSION = '1.21.2';
+exports.HATCHET_VERSION = '1.22.0';