@hatchet-dev/typescript-sdk 0.10.1 → 0.12.0

package/step.d.ts

@@ -1,9 +1,13 @@
 import * as z from 'zod';
+import { Workflow } from './workflow';
 import { Action } from './clients/dispatcher/action-listener';
 import { LogLevel } from './clients/event/event-client';
 import { Logger } from './util/logger';
 import { HatchetClient } from './clients/hatchet-client';
 import WorkflowRunRef from './util/workflow-run-ref';
+import { Worker } from './clients/worker';
+import { WorkerLabels } from './clients/dispatcher/dispatcher-client';
+import { WorkerLabelComparator } from './protoc/workflows';
 export declare const CreateRateLimitSchema: z.ZodObject<{
     key: z.ZodString;
     units: z.ZodNumber;
@@ -14,6 +18,22 @@ export declare const CreateRateLimitSchema: z.ZodObject<{
     key: string;
     units: number;
 }>;
+export declare const DesiredWorkerLabelSchema: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodObject<{
+    value: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    weight: z.ZodOptional<z.ZodNumber>;
+    comparator: z.ZodOptional<z.ZodNativeEnum<typeof WorkerLabelComparator>>;
+}, "strip", z.ZodTypeAny, {
+    value: string | number;
+    required?: boolean | undefined;
+    comparator?: WorkerLabelComparator | undefined;
+    weight?: number | undefined;
+}, {
+    value: string | number;
+    required?: boolean | undefined;
+    comparator?: WorkerLabelComparator | undefined;
+    weight?: number | undefined;
+}>]>>;
 export declare const CreateStepSchema: z.ZodObject<{
     name: z.ZodString;
     parents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -29,6 +49,22 @@ export declare const CreateStepSchema: z.ZodObject<{
         key: string;
         units: number;
     }>, "many">>;
+    worker_labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodLazy<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodObject<{
+        value: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        weight: z.ZodOptional<z.ZodNumber>;
+        comparator: z.ZodOptional<z.ZodNativeEnum<typeof WorkerLabelComparator>>;
+    }, "strip", z.ZodTypeAny, {
+        value: string | number;
+        required?: boolean | undefined;
+        comparator?: WorkerLabelComparator | undefined;
+        weight?: number | undefined;
+    }, {
+        value: string | number;
+        required?: boolean | undefined;
+        comparator?: WorkerLabelComparator | undefined;
+        weight?: number | undefined;
+    }>]>>>>>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     timeout?: string | undefined;
@@ -38,6 +74,12 @@ export declare const CreateStepSchema: z.ZodObject<{
         key: string;
         units: number;
     }[] | undefined;
+    worker_labels?: Record<string, string | number | {
+        value: string | number;
+        required?: boolean | undefined;
+        comparator?: WorkerLabelComparator | undefined;
+        weight?: number | undefined;
+    } | undefined> | undefined;
 }, {
     name: string;
     timeout?: string | undefined;
@@ -47,6 +89,12 @@ export declare const CreateStepSchema: z.ZodObject<{
         key: string;
         units: number;
     }[] | undefined;
+    worker_labels?: Record<string, string | number | {
+        value: string | number;
+        required?: boolean | undefined;
+        comparator?: WorkerLabelComparator | undefined;
+        weight?: number | undefined;
+    } | undefined> | undefined;
 }>;
 export type JsonObject = {
     [Key in string]: JsonValue;
@@ -65,16 +113,25 @@ interface ContextData<T, K> {
     triggered_by: string;
     user_data: K;
 }
+export declare class ContextWorker {
+    private worker;
+    constructor(worker: Worker);
+    id(): string | undefined;
+    hasWorkflow(workflowName: string): boolean;
+    labels(): WorkerLabels;
+    upsertLabels(labels: WorkerLabels): Promise<WorkerLabels>;
+}
 export declare class Context<T, K = {}> {
     data: ContextData<T, K>;
     input: T;
     controller: AbortController;
     action: Action;
     client: HatchetClient;
+    worker: ContextWorker;
     overridesData: Record<string, any>;
     logger: Logger;
     spawnIndex: number;
-    constructor(action: Action, client: HatchetClient);
+    constructor(action: Action, client: HatchetClient, worker: Worker);
     stepOutput(step: string): NextStep;
     triggeredByEvent(): boolean;
     workflowInput(): T;
@@ -94,7 +151,27 @@ export declare class Context<T, K = {}> {
     refreshTimeout(incrementBy: string): Promise<void>;
     releaseSlot(): Promise<void>;
     putStream(data: string | Uint8Array): Promise<void>;
-    spawnWorkflow<Q = JsonValue, P = JsonValue>(workflowName: string, input: Q, key?: string): WorkflowRunRef<P>;
+    /**
+     * Spawns a new workflow.
+     *
+     * @param workflowName the name of the workflow to spawn
+     * @param input the input data for the workflow
+     * @param options additional options for spawning the workflow. If a string is provided, it is used as the key.
+     *                If an object is provided, it can include:
+     *                - key: a unique identifier for the workflow (deprecated, use options.key instead)
+     *                - sticky: a boolean indicating whether to use sticky execution
+     * @param <Q> the type of the input data
+     * @param <P> the type of the output data
+     * @return a reference to the spawned workflow run
+     */
+    spawnWorkflow<Q = JsonValue, P = JsonValue>(workflow: string | Workflow, input: Q, options?: string | {
+        key?: string;
+        sticky?: boolean;
+    }): WorkflowRunRef<P>;
+    additionalMetadata(): Record<string, string>;
+    childIndex(): number | undefined;
+    childKey(): string | undefined;
+    parentWorkflowRunId(): string | undefined;
 }
 export type StepRunFunction<T, K> = (ctx: Context<T, K>) => Promise<NextStep | void> | NextStep | void;
 export interface CreateStep<T, K> extends z.infer<typeof CreateStepSchema> {

package/step.js

@@ -35,26 +35,61 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Context = exports.CreateStepSchema = exports.CreateRateLimitSchema = void 0;
+exports.Context = exports.ContextWorker = exports.CreateStepSchema = exports.DesiredWorkerLabelSchema = exports.CreateRateLimitSchema = void 0;
 /* eslint-disable max-classes-per-file */
 const hatchet_error_1 = __importDefault(require("./util/errors/hatchet-error"));
 const z = __importStar(require("zod"));
 const workflow_1 = require("./workflow");
 const logger_1 = require("./util/logger");
 const parse_1 = require("./util/parse");
+const workflows_1 = require("./protoc/workflows");
 exports.CreateRateLimitSchema = z.object({
     key: z.string(),
     units: z.number().min(1),
 });
+exports.DesiredWorkerLabelSchema = z
+    .union([
+    z.string(),
+    z.number().int(),
+    z.object({
+        value: z.union([z.string(), z.number()]),
+        required: z.boolean().optional(),
+        weight: z.number().int().optional(),
+        // (optional) comparator for the label
+        // if not provided, the default is EQUAL
+        // desired COMPARATOR actual (i.e. desired > actual for GREATER_THAN)
+        comparator: z.nativeEnum(workflows_1.WorkerLabelComparator).optional(),
+    }),
+])
+    .optional();
 exports.CreateStepSchema = z.object({
     name: z.string(),
     parents: z.array(z.string()).optional(),
     timeout: workflow_1.HatchetTimeoutSchema.optional(),
     retries: z.number().optional(),
     rate_limits: z.array(exports.CreateRateLimitSchema).optional(),
+    worker_labels: z.record(z.lazy(() => exports.DesiredWorkerLabelSchema)).optional(),
 });
+class ContextWorker {
+    constructor(worker) {
+        this.worker = worker;
+    }
+    id() {
+        return this.worker.workerId;
+    }
+    hasWorkflow(workflowName) {
+        return !!this.worker.workflow_registry.find((workflow) => workflow.id === workflowName);
+    }
+    labels() {
+        return this.worker.labels;
+    }
+    upsertLabels(labels) {
+        return this.worker.upsertLabels(labels);
+    }
+}
+exports.ContextWorker = ContextWorker;
 class Context {
-    constructor(action, client) {
+    constructor(action, client, worker) {
         this.controller = new AbortController();
         this.overridesData = {};
         this.spawnIndex = 0;
@@ -63,6 +98,7 @@ class Context {
             this.data = data;
             this.action = action;
             this.client = client;
+            this.worker = new ContextWorker(worker);
             this.logger = new logger_1.Logger(`Context Logger`, client.config.log_level);
             // if this is a getGroupKeyRunId, the data is the workflow input
             if (action.getGroupKeyRunId !== '') {
@@ -164,15 +200,49 @@ class Context {
             yield this.client.event.putStream(stepRunId, data);
         });
     }
-    spawnWorkflow(workflowName, input, key) {
+    /**
+     * Spawns a new workflow.
+     *
+     * @param workflowName the name of the workflow to spawn
+     * @param input the input data for the workflow
+     * @param options additional options for spawning the workflow. If a string is provided, it is used as the key.
+     *                If an object is provided, it can include:
+     *                - key: a unique identifier for the workflow (deprecated, use options.key instead)
+     *                - sticky: a boolean indicating whether to use sticky execution
+     * @param <Q> the type of the input data
+     * @param <P> the type of the output data
+     * @return a reference to the spawned workflow run
+     */
+    spawnWorkflow(workflow, input, options) {
         const { workflowRunId, stepRunId } = this.action;
+        let workflowName = '';
+        if (typeof workflow === 'string') {
+            workflowName = workflow;
+        }
+        else {
+            workflowName = workflow.id;
+        }
         const name = this.client.config.namespace + workflowName;
+        let key = '';
+        let sticky = false;
+        if (typeof options === 'string') {
+            this.logger.warn('Using key param is deprecated and will be removed in a future release. Use options.key instead.');
+            key = options;
+        }
+        else {
+            key = options === null || options === void 0 ? void 0 : options.key;
+            sticky = options === null || options === void 0 ? void 0 : options.sticky;
+        }
+        if (sticky && !this.worker.hasWorkflow(name)) {
+            throw new hatchet_error_1.default(`cannot run with sticky: workflow ${name} is not registered on the worker`);
+        }
         try {
             const resp = this.client.admin.runWorkflow(name, input, {
                 parentId: workflowRunId,
                 parentStepRunId: stepRunId,
                 childKey: key,
                 childIndex: this.spawnIndex,
+                desiredWorkerId: sticky ? this.worker.id() : undefined,
             });
             this.spawnIndex += 1;
             return resp;
@@ -181,5 +251,22 @@ class Context {
             throw new hatchet_error_1.default(e.message);
         }
     }
+    additionalMetadata() {
+        if (!this.action.additionalMetadata) {
+            return {};
+        }
+        // parse the additional metadata
+        const res = (0, parse_1.parseJSON)(this.action.additionalMetadata);
+        return res;
+    }
+    childIndex() {
+        return this.action.childWorkflowIndex;
+    }
+    childKey() {
+        return this.action.childWorkflowKey;
+    }
+    parentWorkflowRunId() {
+        return this.action.parentWorkflowRunId;
+    }
 }
 exports.Context = Context;

package/util/workflow-run-ref.d.ts

@@ -2,6 +2,9 @@ import { ListenerClient, StepRunEvent } from '../clients/listener/listener-clien
 type EventualWorkflowRunId = string | Promise<string> | Promise<{
     workflowRunId: string;
 }>;
+export declare class DedupeViolationErr extends Error {
+    constructor(message: string);
+}
 export default class WorkflowRunRef<T> {
     workflowRunId: EventualWorkflowRunId;
     parentWorkflowRunId?: string;

package/util/workflow-run-ref.js

@@ -16,18 +16,35 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DedupeViolationErr = void 0;
+const nice_grpc_1 = require("nice-grpc");
 const dispatcher_1 = require("../protoc/dispatcher");
+class DedupeViolationErr extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DedupeViolationErr';
+    }
+}
+exports.DedupeViolationErr = DedupeViolationErr;
 function getWorkflowRunId(workflowRunId) {
     return __awaiter(this, void 0, void 0, function* () {
         if (typeof workflowRunId === 'string') {
             return workflowRunId;
         }
         if (workflowRunId instanceof Promise) {
-            const resolved = yield workflowRunId;
-            if (typeof resolved === 'string') {
-                return resolved;
+            try {
+                const resolved = yield workflowRunId;
+                if (typeof resolved === 'string') {
+                    return resolved;
+                }
+                return resolved.workflowRunId;
+            }
+            catch (e) {
+                if (e.code && e.code === nice_grpc_1.Status.ALREADY_EXISTS) {
+                    throw new DedupeViolationErr(e.details);
+                }
+                throw new Error('Invalid workflowRunId');
             }
-            return resolved.workflowRunId;
         }
         throw new Error('Invalid workflowRunId');
     });

package/workflow.d.ts

@@ -1,6 +1,6 @@
 import * as z from 'zod';
 import { CreateStep } from './step';
-import { ConcurrencyLimitStrategy as PbConcurrencyLimitStrategy } from './protoc/workflows';
+import { ConcurrencyLimitStrategy as PbConcurrencyLimitStrategy, StickyStrategy as PbStickyStrategy } from './protoc/workflows';
 declare const StepsSchema: z.ZodArray<z.ZodObject<{
     name: z.ZodString;
     parents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -16,6 +16,22 @@ declare const StepsSchema: z.ZodArray<z.ZodObject<{
         key: string;
         units: number;
     }>, "many">>;
+    worker_labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodLazy<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodObject<{
+        value: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        weight: z.ZodOptional<z.ZodNumber>;
+        comparator: z.ZodOptional<z.ZodNativeEnum<typeof import("./protoc/workflows").WorkerLabelComparator>>;
+    }, "strip", z.ZodTypeAny, {
+        value: string | number;
+        required?: boolean | undefined;
+        comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
+        weight?: number | undefined;
+    }, {
+        value: string | number;
+        required?: boolean | undefined;
+        comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
+        weight?: number | undefined;
+    }>]>>>>>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     timeout?: string | undefined;
@@ -25,6 +41,12 @@ declare const StepsSchema: z.ZodArray<z.ZodObject<{
         key: string;
         units: number;
     }[] | undefined;
+    worker_labels?: Record<string, string | number | {
+        value: string | number;
+        required?: boolean | undefined;
+        comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
+        weight?: number | undefined;
+    } | undefined> | undefined;
 }, {
     name: string;
     timeout?: string | undefined;
@@ -34,6 +56,12 @@ declare const StepsSchema: z.ZodArray<z.ZodObject<{
         key: string;
         units: number;
     }[] | undefined;
+    worker_labels?: Record<string, string | number | {
+        value: string | number;
+        required?: boolean | undefined;
+        comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
+        weight?: number | undefined;
+    } | undefined> | undefined;
 }>, "many">;
 export type Steps = z.infer<typeof StepsSchema>;
 export declare const ConcurrencyLimitStrategy: typeof PbConcurrencyLimitStrategy;
@@ -51,10 +79,15 @@ export declare const WorkflowConcurrency: z.ZodObject<{
     limitStrategy?: PbConcurrencyLimitStrategy | undefined;
 }>;
 export declare const HatchetTimeoutSchema: z.ZodString;
+export declare const StickyStrategy: typeof PbStickyStrategy;
 export declare const CreateWorkflowSchema: z.ZodObject<{
     id: z.ZodString;
     description: z.ZodString;
     version: z.ZodOptional<z.ZodString>;
+    /**
+     * sticky will attempt to run all steps for workflow on the same worker
+     */
+    sticky: z.ZodOptional<z.ZodNativeEnum<typeof PbStickyStrategy>>;
     scheduleTimeout: z.ZodOptional<z.ZodString>;
     /**
      * @deprecated Workflow timeout is deprecated. Use step timeouts instead.
@@ -94,6 +127,22 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             key: string;
             units: number;
         }>, "many">>;
+        worker_labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodLazy<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodObject<{
+            value: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            weight: z.ZodOptional<z.ZodNumber>;
+            comparator: z.ZodOptional<z.ZodNativeEnum<typeof import("./protoc/workflows").WorkerLabelComparator>>;
+        }, "strip", z.ZodTypeAny, {
+            value: string | number;
+            required?: boolean | undefined;
+            comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
+            weight?: number | undefined;
+        }, {
+            value: string | number;
+            required?: boolean | undefined;
+            comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
+            weight?: number | undefined;
+        }>]>>>>>;
     }, "strip", z.ZodTypeAny, {
         name: string;
         timeout?: string | undefined;
@@ -103,6 +152,12 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             key: string;
             units: number;
         }[] | undefined;
+        worker_labels?: Record<string, string | number | {
+            value: string | number;
+            required?: boolean | undefined;
+            comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
+            weight?: number | undefined;
+        } | undefined> | undefined;
     }, {
         name: string;
         timeout?: string | undefined;
@@ -112,6 +167,12 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             key: string;
             units: number;
         }[] | undefined;
+        worker_labels?: Record<string, string | number | {
+            value: string | number;
+            required?: boolean | undefined;
+            comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
+            weight?: number | undefined;
+        } | undefined> | undefined;
     }>, "many">;
     onFailure: z.ZodOptional<z.ZodObject<{
         name: z.ZodString;
@@ -128,6 +189,22 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             key: string;
             units: number;
         }>, "many">>;
+        worker_labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodLazy<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodObject<{
+            value: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            weight: z.ZodOptional<z.ZodNumber>;
+            comparator: z.ZodOptional<z.ZodNativeEnum<typeof import("./protoc/workflows").WorkerLabelComparator>>;
+        }, "strip", z.ZodTypeAny, {
+            value: string | number;
+            required?: boolean | undefined;
+            comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
+            weight?: number | undefined;
+        }, {
+            value: string | number;
+            required?: boolean | undefined;
+            comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
+            weight?: number | undefined;
+        }>]>>>>>;
     }, "strip", z.ZodTypeAny, {
         name: string;
         timeout?: string | undefined;
@@ -137,6 +214,12 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             key: string;
             units: number;
         }[] | undefined;
+        worker_labels?: Record<string, string | number | {
+            value: string | number;
+            required?: boolean | undefined;
+            comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
+            weight?: number | undefined;
+        } | undefined> | undefined;
     }, {
         name: string;
         timeout?: string | undefined;
@@ -146,6 +229,12 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             key: string;
             units: number;
         }[] | undefined;
+        worker_labels?: Record<string, string | number | {
+            value: string | number;
+            required?: boolean | undefined;
+            comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
+            weight?: number | undefined;
+        } | undefined> | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     description: string;
@@ -158,10 +247,17 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             key: string;
             units: number;
         }[] | undefined;
+        worker_labels?: Record<string, string | number | {
+            value: string | number;
+            required?: boolean | undefined;
+            comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
+            weight?: number | undefined;
+        } | undefined> | undefined;
     }[];
     id: string;
     version?: string | undefined;
     scheduleTimeout?: string | undefined;
+    sticky?: PbStickyStrategy | undefined;
     timeout?: string | undefined;
     on?: {
         cron: string;
@@ -179,6 +275,12 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             key: string;
             units: number;
         }[] | undefined;
+        worker_labels?: Record<string, string | number | {
+            value: string | number;
+            required?: boolean | undefined;
+            comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
+            weight?: number | undefined;
+        } | undefined> | undefined;
     } | undefined;
 }, {
     description: string;
@@ -191,10 +293,17 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             key: string;
             units: number;
         }[] | undefined;
+        worker_labels?: Record<string, string | number | {
+            value: string | number;
+            required?: boolean | undefined;
+            comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
+            weight?: number | undefined;
+        } | undefined> | undefined;
     }[];
     id: string;
     version?: string | undefined;
     scheduleTimeout?: string | undefined;
+    sticky?: PbStickyStrategy | undefined;
     timeout?: string | undefined;
     on?: {
         cron: string;
@@ -212,6 +321,12 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             key: string;
             units: number;
         }[] | undefined;
+        worker_labels?: Record<string, string | number | {
+            value: string | number;
+            required?: boolean | undefined;
+            comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
+            weight?: number | undefined;
+        } | undefined> | undefined;
     } | undefined;
 }>;
 export interface Workflow extends z.infer<typeof CreateWorkflowSchema> {

package/workflow.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateWorkflowSchema = exports.HatchetTimeoutSchema = exports.WorkflowConcurrency = exports.ConcurrencyLimitStrategy = void 0;
+exports.CreateWorkflowSchema = exports.StickyStrategy = exports.HatchetTimeoutSchema = exports.WorkflowConcurrency = exports.ConcurrencyLimitStrategy = void 0;
 const z = __importStar(require("zod"));
 const step_1 = require("./step");
 const workflows_1 = require("./protoc/workflows");
@@ -44,10 +44,15 @@ exports.WorkflowConcurrency = z.object({
     limitStrategy: z.nativeEnum(exports.ConcurrencyLimitStrategy).optional(),
 });
 exports.HatchetTimeoutSchema = z.string();
+exports.StickyStrategy = workflows_1.StickyStrategy;
 exports.CreateWorkflowSchema = z.object({
     id: z.string(),
     description: z.string(),
     version: z.string().optional(),
+    /**
+     * sticky will attempt to run all steps for workflow on the same worker
+     */
+    sticky: z.nativeEnum(exports.StickyStrategy).optional(),
     scheduleTimeout: z.string().optional(),
     /**
      * @deprecated Workflow timeout is deprecated. Use step timeouts instead.