@hatchet-dev/typescript-sdk 1.12.0 → 1.12.1

package/v1/client/worker/deprecated/deprecation.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Generic time-aware deprecation helper.
+ *
+ * Timeline (from a given start date, with configurable windows):
+ *   0 to warnDays:              WARNING logged once per feature
+ *   warnDays to errorDays:      ERROR logged once per feature
+ *   after errorDays:            throws an error 1-in-5 calls (20% chance)
+ *
+ * Defaults: warnDays=90, errorDays=undefined (error phase disabled unless set).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeprecationError = void 0;
+exports.parseSemver = parseSemver;
+exports.semverLessThan = semverLessThan;
+exports.emitDeprecationNotice = emitDeprecationNotice;
+const DEFAULT_WARN_DAYS = 90;
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+/** Tracks which features have already been logged (keyed by feature name). */
+const alreadyLogged = new Set();
+class DeprecationError extends Error {
+    constructor(feature, message) {
+        super(`${feature}: ${message}`);
+        this.name = 'DeprecationError';
+        this.feature = feature;
+    }
+}
+exports.DeprecationError = DeprecationError;
+/**
+ * Emit a time-aware deprecation notice.
+ *
+ * @param feature - A short identifier for deduplication (each feature logs once).
+ * @param message - The human-readable deprecation message.
+ * @param start   - The Date when the deprecation window began.
+ * @param logger  - A Logger instance for outputting warnings/errors.
+ * @param opts    - Optional configuration for time windows.
+ * @throws DeprecationError after the errorDays window (~20% chance).
+ */
+/**
+ * Parses a semver string like "v0.78.23" into [major, minor, patch].
+ * Returns [0, 0, 0] if parsing fails.
+ */
+function parseSemver(v) {
+    let s = v.startsWith('v') ? v.slice(1) : v;
+    const dashIdx = s.indexOf('-');
+    if (dashIdx !== -1)
+        s = s.slice(0, dashIdx);
+    const parts = s.split('.');
+    if (parts.length !== 3)
+        return [0, 0, 0];
+    return [parseInt(parts[0], 10) || 0, parseInt(parts[1], 10) || 0, parseInt(parts[2], 10) || 0];
+}
+/**
+ * Returns true if semver string a is strictly less than b.
+ */
+function semverLessThan(a, b) {
+    const [aMaj, aMin, aPat] = parseSemver(a);
+    const [bMaj, bMin, bPat] = parseSemver(b);
+    if (aMaj !== bMaj)
+        return aMaj < bMaj;
+    if (aMin !== bMin)
+        return aMin < bMin;
+    return aPat < bPat;
+}
+function emitDeprecationNotice(feature, message, start, logger, opts) {
+    var _a;
+    const warnMs = ((_a = opts === null || opts === void 0 ? void 0 : opts.warnDays) !== null && _a !== void 0 ? _a : DEFAULT_WARN_DAYS) * MS_PER_DAY;
+    const errorDays = opts === null || opts === void 0 ? void 0 : opts.errorDays;
+    const errorMs = errorDays != null ? errorDays * MS_PER_DAY : undefined;
+    const elapsed = Date.now() - start.getTime();
+    if (elapsed < warnMs) {
+        // Phase 1: warning
+        if (!alreadyLogged.has(feature)) {
+            logger.warn(message);
+            alreadyLogged.add(feature);
+        }
+    }
+    else if (errorMs === undefined || elapsed < errorMs) {
+        // Phase 2: error-level log (indefinite when errorDays is not set)
+        if (!alreadyLogged.has(feature)) {
+            logger.error(`${message} This fallback will be removed soon. Upgrade immediately.`);
+            alreadyLogged.add(feature);
+        }
+    }
+    else {
+        // Phase 3: throw 1-in-5 times
+        if (!alreadyLogged.has(feature)) {
+            logger.error(`${message} This fallback is no longer supported and will fail intermittently.`);
+            alreadyLogged.add(feature);
+        }
+        if (Math.random() < 0.2) {
+            throw new DeprecationError(feature, message);
+        }
+    }
+}

package/v1/client/worker/deprecated/index.d.ts

@@ -0,0 +1,4 @@
+export { isLegacyEngine, LegacyDualWorker } from './legacy-worker';
+export { LegacyV1Worker } from './legacy-v1-worker';
+export { legacyGetActionListener } from './legacy-registration';
+export { emitDeprecationNotice, DeprecationError, parseSemver, semverLessThan, } from './deprecation';

package/v1/client/worker/deprecated/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.semverLessThan = exports.parseSemver = exports.DeprecationError = exports.emitDeprecationNotice = exports.legacyGetActionListener = exports.LegacyV1Worker = exports.LegacyDualWorker = exports.isLegacyEngine = void 0;
+var legacy_worker_1 = require("./legacy-worker");
+Object.defineProperty(exports, "isLegacyEngine", { enumerable: true, get: function () { return legacy_worker_1.isLegacyEngine; } });
+Object.defineProperty(exports, "LegacyDualWorker", { enumerable: true, get: function () { return legacy_worker_1.LegacyDualWorker; } });
+var legacy_v1_worker_1 = require("./legacy-v1-worker");
+Object.defineProperty(exports, "LegacyV1Worker", { enumerable: true, get: function () { return legacy_v1_worker_1.LegacyV1Worker; } });
+var legacy_registration_1 = require("./legacy-registration");
+Object.defineProperty(exports, "legacyGetActionListener", { enumerable: true, get: function () { return legacy_registration_1.legacyGetActionListener; } });
+var deprecation_1 = require("./deprecation");
+Object.defineProperty(exports, "emitDeprecationNotice", { enumerable: true, get: function () { return deprecation_1.emitDeprecationNotice; } });
+Object.defineProperty(exports, "DeprecationError", { enumerable: true, get: function () { return deprecation_1.DeprecationError; } });
+Object.defineProperty(exports, "parseSemver", { enumerable: true, get: function () { return deprecation_1.parseSemver; } });
+Object.defineProperty(exports, "semverLessThan", { enumerable: true, get: function () { return deprecation_1.semverLessThan; } });

package/v1/client/worker/deprecated/legacy-registration.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Legacy worker registration using the deprecated `slots` proto field
+ * instead of `slotConfig`. For backward compatibility with engines
+ * that do not support multiple slot types.
+ */
+import { DispatcherClient, WorkerLabels } from '../../../../clients/dispatcher/dispatcher-client';
+import { ActionListener } from '../../../../clients/dispatcher/action-listener';
+export interface LegacyRegistrationOptions {
+    workerName: string;
+    services: string[];
+    actions: string[];
+    slots: number;
+    labels: WorkerLabels;
+}
+/**
+ * Registers a worker using the legacy `slots` proto field instead of `slotConfig`.
+ */
+export declare function legacyGetActionListener(dispatcher: DispatcherClient, options: LegacyRegistrationOptions): Promise<ActionListener>;

package/v1/client/worker/deprecated/legacy-registration.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Legacy worker registration using the deprecated `slots` proto field
+ * instead of `slotConfig`. For backward compatibility with engines
+ * that do not support multiple slot types.
+ */
+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.legacyGetActionListener = legacyGetActionListener;
+const dispatcher_client_1 = require("../../../../clients/dispatcher/dispatcher-client");
+const action_listener_1 = require("../../../../clients/dispatcher/action-listener");
+/**
+ * Registers a worker using the legacy `slots` proto field instead of `slotConfig`.
+ */
+function legacyGetActionListener(dispatcher, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const registration = yield dispatcher.client.register({
+            workerName: options.workerName,
+            services: options.services,
+            actions: options.actions,
+            slots: options.slots,
+            labels: options.labels ? (0, dispatcher_client_1.mapLabels)(options.labels) : undefined,
+            runtimeInfo: dispatcher.getRuntimeInfo(),
+        });
+        return new action_listener_1.ActionListener(dispatcher, registration.workerId);
+    });
+}

package/v1/client/worker/deprecated/legacy-v1-worker.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Legacy V1Worker subclass that registers with the old `slots` proto field
+ * instead of `slotConfig`. Used when connected to pre-slot-config engines.
+ */
+import { ActionListener } from '../../../../clients/dispatcher/action-listener';
+import { HatchetClient } from '../../..';
+import { V1Worker } from '../worker-internal';
+export declare class LegacyV1Worker extends V1Worker {
+    private _legacySlotCount;
+    constructor(client: HatchetClient, options: ConstructorParameters<typeof V1Worker>[1], legacySlots: number);
+    /**
+     * Override registration to use the legacy `slots` proto field.
+     */
+    protected createListener(): Promise<ActionListener>;
+}

package/v1/client/worker/deprecated/legacy-v1-worker.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Legacy V1Worker subclass that registers with the old `slots` proto field
+ * instead of `slotConfig`. Used when connected to pre-slot-config engines.
+ */
+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.LegacyV1Worker = void 0;
+const worker_internal_1 = require("../worker-internal");
+const legacy_registration_1 = require("./legacy-registration");
+class LegacyV1Worker extends worker_internal_1.V1Worker {
+    constructor(client, options, legacySlots) {
+        super(client, options);
+        this._legacySlotCount = legacySlots;
+    }
+    /**
+     * Override registration to use the legacy `slots` proto field.
+     */
+    createListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, legacy_registration_1.legacyGetActionListener)(this.client._v0.dispatcher, {
+                workerName: this.name,
+                services: ['default'],
+                actions: Object.keys(this.action_registry),
+                slots: this._legacySlotCount,
+                labels: this.labels,
+            });
+        });
+    }
+}
+exports.LegacyV1Worker = LegacyV1Worker;

package/v1/client/worker/deprecated/legacy-worker.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Legacy dual-worker implementation for pre-slot-config engines.
+ *
+ * When connected to an older Hatchet engine that does not support multiple slot types,
+ * this module provides the old worker start flow which creates separate durable and
+ * non-durable workers, each registered with the legacy `slots` proto field.
+ */
+import { HatchetClient } from '../../..';
+import { CreateWorkerOpts } from '../worker';
+import { LegacyV1Worker } from './legacy-v1-worker';
+/**
+ * Checks if the connected engine is legacy by comparing its semantic version
+ * against the minimum required version for slot_config support.
+ * Returns true if the engine is legacy, false otherwise.
+ * Emits a time-aware deprecation notice when a legacy engine is detected.
+ */
+export declare function isLegacyEngine(v1: HatchetClient): Promise<boolean>;
+/**
+ * LegacyDualWorker manages two V1Worker instances (nonDurable + durable)
+ * for engines that don't support slot_config.
+ * Uses the legacy `slots` proto field (maxRuns) instead of `slotConfig`.
+ */
+export declare class LegacyDualWorker {
+    private nonDurable;
+    private durable;
+    private name;
+    constructor(name: string, nonDurable: LegacyV1Worker, durable?: LegacyV1Worker);
+    /**
+     * Creates a legacy dual-worker setup from the given options.
+     * Workers are created with legacy registration (old `slots` proto field).
+     */
+    static create(v1: HatchetClient, name: string, options: CreateWorkerOpts): Promise<LegacyDualWorker>;
+    /**
+     * Starts both workers using Promise.all.
+     */
+    start(): Promise<void>;
+    /**
+     * Stops both workers.
+     */
+    stop(): Promise<void>;
+}

package/v1/client/worker/deprecated/legacy-worker.js

@@ -0,0 +1,148 @@
+"use strict";
+/**
+ * Legacy dual-worker implementation for pre-slot-config engines.
+ *
+ * When connected to an older Hatchet engine that does not support multiple slot types,
+ * this module provides the old worker start flow which creates separate durable and
+ * non-durable workers, each registered with the legacy `slots` proto field.
+ */
+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.LegacyDualWorker = void 0;
+exports.isLegacyEngine = isLegacyEngine;
+const nice_grpc_1 = require("nice-grpc");
+const declaration_1 = require("../../../declaration");
+const legacy_v1_worker_1 = require("./legacy-v1-worker");
+const deprecation_1 = require("./deprecation");
+const DEFAULT_DEFAULT_SLOTS = 100;
+const DEFAULT_DURABLE_SLOTS = 1000;
+/** The date when slot_config support was released. */
+const LEGACY_ENGINE_START = new Date('2026-02-12T00:00:00Z');
+/** Minimum engine version that supports multiple slot types. */
+const MIN_SLOT_CONFIG_VERSION = 'v0.78.23';
+const LEGACY_ENGINE_MESSAGE = 'Connected to an older Hatchet engine that does not support multiple slot types. ' +
+    'Falling back to legacy worker registration. ' +
+    'Please upgrade your Hatchet engine to the latest version.';
+/**
+ * Checks if the connected engine is legacy by comparing its semantic version
+ * against the minimum required version for slot_config support.
+ * Returns true if the engine is legacy, false otherwise.
+ * Emits a time-aware deprecation notice when a legacy engine is detected.
+ */
+function isLegacyEngine(v1) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const version = yield v1._v0.dispatcher.getVersion();
+            // If the version is empty or older than the minimum, treat as legacy
+            if (!version || (0, deprecation_1.semverLessThan)(version, MIN_SLOT_CONFIG_VERSION)) {
+                const logger = v1._v0.config.logger('Worker', v1._v0.config.log_level);
+                (0, deprecation_1.emitDeprecationNotice)('legacy-engine', LEGACY_ENGINE_MESSAGE, LEGACY_ENGINE_START, logger, {
+                    errorDays: 180,
+                });
+                return true;
+            }
+            return false;
+        }
+        catch (e) {
+            if ((e === null || e === void 0 ? void 0 : e.code) === nice_grpc_1.Status.UNIMPLEMENTED) {
+                const logger = v1._v0.config.logger('Worker', v1._v0.config.log_level);
+                (0, deprecation_1.emitDeprecationNotice)('legacy-engine', LEGACY_ENGINE_MESSAGE, LEGACY_ENGINE_START, logger, {
+                    errorDays: 180,
+                });
+                return true;
+            }
+            // For other errors, assume new engine and let registration fail naturally
+            return false;
+        }
+    });
+}
+/**
+ * LegacyDualWorker manages two V1Worker instances (nonDurable + durable)
+ * for engines that don't support slot_config.
+ * Uses the legacy `slots` proto field (maxRuns) instead of `slotConfig`.
+ */
+class LegacyDualWorker {
+    constructor(name, nonDurable, durable) {
+        this.name = name;
+        this.nonDurable = nonDurable;
+        this.durable = durable;
+    }
+    /**
+     * Creates a legacy dual-worker setup from the given options.
+     * Workers are created with legacy registration (old `slots` proto field).
+     */
+    static create(v1, name, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const defaultSlots = options.slots || options.maxRuns || DEFAULT_DEFAULT_SLOTS;
+            const durableSlots = options.durableSlots || DEFAULT_DURABLE_SLOTS;
+            // Create the non-durable worker with legacy registration
+            const nonDurable = new legacy_v1_worker_1.LegacyV1Worker(v1, { name, labels: options.labels, handleKill: options.handleKill }, defaultSlots);
+            // Check if any workflows have durable tasks
+            let hasDurableTasks = false;
+            for (const wf of options.workflows || []) {
+                if (wf instanceof declaration_1.BaseWorkflowDeclaration) {
+                    if (wf.definition._durableTasks.length > 0) {
+                        hasDurableTasks = true;
+                        break;
+                    }
+                }
+            }
+            let durableWorker;
+            if (hasDurableTasks) {
+                // Create the durable worker with legacy registration
+                durableWorker = new legacy_v1_worker_1.LegacyV1Worker(v1, { name: `${name}-durable`, labels: options.labels, handleKill: options.handleKill }, durableSlots);
+            }
+            const legacyWorker = new LegacyDualWorker(name, nonDurable, durableWorker);
+            // Register workflows on appropriate workers
+            for (const wf of options.workflows || []) {
+                if (wf instanceof declaration_1.BaseWorkflowDeclaration) {
+                    if (wf.definition._durableTasks.length > 0 && durableWorker) {
+                        yield durableWorker.registerWorkflowV1(wf);
+                        durableWorker.registerDurableActionsV1(wf.definition);
+                    }
+                    else {
+                        yield nonDurable.registerWorkflowV1(wf);
+                    }
+                }
+                else {
+                    // fallback to v0 client for backwards compatibility
+                    yield nonDurable.registerWorkflow(wf);
+                }
+            }
+            return legacyWorker;
+        });
+    }
+    /**
+     * Starts both workers using Promise.all.
+     */
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = [this.nonDurable.start()];
+            if (this.durable) {
+                promises.push(this.durable.start());
+            }
+            yield Promise.all(promises);
+        });
+    }
+    /**
+     * Stops both workers.
+     */
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = [this.nonDurable.stop()];
+            if (this.durable) {
+                promises.push(this.durable.stop());
+            }
+            yield Promise.all(promises);
+        });
+    }
+}
+exports.LegacyDualWorker = LegacyDualWorker;

package/v1/client/worker/slot-utils.d.ts

@@ -0,0 +1,21 @@
+import { Workflow as V0Workflow } from '../../../workflow';
+import { BaseWorkflowDeclaration } from '../../declaration';
+import { SlotConfig } from '../../slot-types';
+export interface WorkerSlotOptions {
+    /** (optional) Maximum number of concurrent runs on this worker, defaults to 100 */
+    slots?: number;
+    /** (optional) Maximum number of concurrent durable tasks, defaults to 1,000 */
+    durableSlots?: number;
+    /** (optional) Array of workflows to register */
+    workflows?: BaseWorkflowDeclaration<any, any>[] | V0Workflow[];
+    /** @deprecated Use slots instead */
+    maxRuns?: number;
+}
+export declare function resolveWorkerOptions<T extends WorkerSlotOptions>(options: T): T & {
+    slots?: number;
+    durableSlots?: number;
+    slotConfig: SlotConfig;
+};
+export declare const testingExports: {
+    resolveWorkerOptions: typeof resolveWorkerOptions;
+};

package/v1/client/worker/slot-utils.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testingExports = void 0;
+exports.resolveWorkerOptions = resolveWorkerOptions;
+const declaration_1 = require("../../declaration");
+const slot_types_1 = require("../../slot-types");
+const DEFAULT_DEFAULT_SLOTS = 100;
+const DEFAULT_DURABLE_SLOTS = 1000;
+function resolveWorkerOptions(options) {
+    const requiredSlotTypes = options.workflows
+        ? getRequiredSlotTypes(options.workflows)
+        : new Set();
+    const slotConfig = options.slots || options.durableSlots || options.maxRuns
+        ? Object.assign(Object.assign({}, (options.slots || options.maxRuns
+            ? { [slot_types_1.SlotType.Default]: options.slots || options.maxRuns || 0 }
+            : {})), (options.durableSlots ? { [slot_types_1.SlotType.Durable]: options.durableSlots } : {})) : {};
+    if (requiredSlotTypes.has(slot_types_1.SlotType.Default) && slotConfig[slot_types_1.SlotType.Default] == null) {
+        slotConfig[slot_types_1.SlotType.Default] = DEFAULT_DEFAULT_SLOTS;
+    }
+    if (requiredSlotTypes.has(slot_types_1.SlotType.Durable) && slotConfig[slot_types_1.SlotType.Durable] == null) {
+        slotConfig[slot_types_1.SlotType.Durable] = DEFAULT_DURABLE_SLOTS;
+    }
+    if (Object.keys(slotConfig).length === 0) {
+        slotConfig[slot_types_1.SlotType.Default] = DEFAULT_DEFAULT_SLOTS;
+    }
+    return Object.assign(Object.assign({}, options), { slots: options.slots ||
+            options.maxRuns ||
+            (slotConfig[slot_types_1.SlotType.Default] != null ? slotConfig[slot_types_1.SlotType.Default] : undefined), durableSlots: options.durableSlots ||
+            (slotConfig[slot_types_1.SlotType.Durable] != null ? slotConfig[slot_types_1.SlotType.Durable] : undefined), slotConfig });
+}
+// eslint-disable-next-line @typescript-eslint/naming-convention
+exports.testingExports = {
+    resolveWorkerOptions,
+};
+function getRequiredSlotTypes(workflows) {
+    const required = new Set();
+    const addFromRequests = (requests, fallbackType) => {
+        if (requests && Object.keys(requests).length > 0) {
+            if (requests[slot_types_1.SlotType.Default] !== undefined) {
+                required.add(slot_types_1.SlotType.Default);
+            }
+            if (requests[slot_types_1.SlotType.Durable] !== undefined) {
+                required.add(slot_types_1.SlotType.Durable);
+            }
+        }
+        else {
+            required.add(fallbackType);
+        }
+    };
+    for (const wf of workflows) {
+        if (wf instanceof declaration_1.BaseWorkflowDeclaration) {
+            // eslint-disable-next-line dot-notation
+            const tasks = wf.definition['_tasks'];
+            for (const task of tasks) {
+                addFromRequests(task.slotRequests, slot_types_1.SlotType.Default);
+            }
+            // eslint-disable-next-line dot-notation
+            const durableTasks = wf.definition['_durableTasks'];
+            if (durableTasks.length > 0) {
+                required.add(slot_types_1.SlotType.Durable);
+            }
+            if (wf.definition.onFailure) {
+                const opts = typeof wf.definition.onFailure === 'object' ? wf.definition.onFailure : undefined;
+                addFromRequests(opts === null || opts === void 0 ? void 0 : opts.slotRequests, slot_types_1.SlotType.Default);
+            }
+            if (wf.definition.onSuccess) {
+                const opts = typeof wf.definition.onSuccess === 'object' ? wf.definition.onSuccess : undefined;
+                addFromRequests(opts === null || opts === void 0 ? void 0 : opts.slotRequests, slot_types_1.SlotType.Default);
+            }
+        }
+    }
+    return required;
+}

package/v1/client/worker/worker-internal.d.ts

@@ -8,11 +8,13 @@ import { BaseWorkflowDeclaration, WorkflowDefinition, HatchetClient } from '../.
 import { WorkerLabels } from '../../../clients/dispatcher/dispatcher-client';
 import { StepRunFunction } from '../../../step';
 import { Context } from './context';
+import { SlotConfig } from '../../slot-types';
 export type ActionRegistry = Record<Action['actionId'], Function>;
 export interface WorkerOpts {
     name: string;
     handleKill?: boolean;
-    maxRuns?: number;
+    slots?: number;
+    durableSlots?: number;
     labels?: WorkerLabels;
     healthPort?: number;
     enableHealthServer?: boolean;
@@ -28,7 +30,9 @@ export declare class V1Worker {
     listener: ActionListener | undefined;
     futures: Record<Action['taskRunExternalId'], HatchetPromise<any>>;
     contexts: Record<Action['taskRunExternalId'], Context<any, any>>;
-    maxRuns?: number;
+    slots?: number;
+    durableSlots?: number;
+    slotConfig: SlotConfig;
     logger: Logger;
     registeredWorkflowPromises: Array<Promise<any>>;
     labels: WorkerLabels;
@@ -39,7 +43,9 @@ export declare class V1Worker {
     constructor(client: HatchetClient, options: {
         name: string;
         handleKill?: boolean;
-        maxRuns?: number;
+        slots?: number;
+        durableSlots?: number;
+        slotConfig?: SlotConfig;
         labels?: WorkerLabels;
     });
     private initializeHealthServer;
@@ -66,6 +72,11 @@ export declare class V1Worker {
     handleCancelStepRun(action: Action): Promise<void>;
     stop(): Promise<void>;
     exitGracefully(handleKill: boolean): Promise<void>;
+    /**
+     * Creates an action listener by registering the worker with the dispatcher.
+     * Override in subclasses to change registration behavior (e.g. legacy engines).
+     */
+    protected createListener(): Promise<ActionListener>;
     start(): Promise<void>;
     handleAction(action: Action): Promise<void>;
     upsertLabels(labels: WorkerLabels): Promise<WorkerLabels>;

package/v1/client/worker/worker-internal.js

@@ -46,7 +46,9 @@ class V1Worker {
         this.client = client;
         this.name = (0, apply_namespace_1.applyNamespace)(options.name, this.client.config.namespace);
         this.action_registry = {};
-        this.maxRuns = options.maxRuns;
+        this.slots = options.slots;
+        this.durableSlots = options.durableSlots;
+        this.slotConfig = options.slotConfig || {};
         this.labels = options.labels || {};
         this.enableHealthServer = (_b = (_a = client.config.healthcheck) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : false;
         this.healthPort = (_d = (_c = client.config.healthcheck) === null || _c === void 0 ? void 0 : _c.port) !== null && _d !== void 0 ? _d : 8001;
@@ -67,11 +69,10 @@ class V1Worker {
         this.healthServer = new health_server_1.HealthServer(this.healthPort, () => this.status, this.name, () => this.getAvailableSlots(), () => this.getRegisteredActions(), () => this.getFilteredLabels(), this.logger);
     }
     getAvailableSlots() {
-        if (!this.maxRuns) {
-            return 0;
-        }
+        // sum all the slots in the slot config
+        const totalSlots = Object.values(this.slotConfig).reduce((acc, curr) => acc + curr, 0);
         const currentRuns = Object.keys(this.futures).length;
-        return Math.max(0, this.maxRuns - currentRuns);
+        return Math.max(0, totalSlots - currentRuns);
     }
     getRegisteredActions() {
         return Object.keys(this.action_registry);
@@ -177,6 +178,8 @@ class V1Worker {
                         rateLimits: [],
                         workerLabels: {},
                         concurrency: [],
+                        isDurable: false,
+                        slotRequests: { default: 1 },
                     };
                 }
                 if (workflow.onFailure && typeof workflow.onFailure === 'object') {
@@ -194,6 +197,8 @@ class V1Worker {
                         concurrency: [],
                         backoffFactor: ((_f = onFailure.backoff) === null || _f === void 0 ? void 0 : _f.factor) || ((_h = (_g = workflow.taskDefaults) === null || _g === void 0 ? void 0 : _g.backoff) === null || _h === void 0 ? void 0 : _h.factor),
                         backoffMaxSeconds: ((_j = onFailure.backoff) === null || _j === void 0 ? void 0 : _j.maxSeconds) || ((_l = (_k = workflow.taskDefaults) === null || _k === void 0 ? void 0 : _k.backoff) === null || _l === void 0 ? void 0 : _l.maxSeconds),
+                        isDurable: false,
+                        slotRequests: { default: 1 },
                     };
                 }
                 let onSuccessTask;
@@ -252,6 +257,7 @@ class V1Worker {
                     const jsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(workflow.inputValidator);
                     inputJsonSchema = new TextEncoder().encode(JSON.stringify(jsonSchema));
                 }
+                const durableTaskSet = new Set(workflow._durableTasks);
                 const registeredWorkflow = this.client._v0.admin.putWorkflowV1({
                     name: workflow.name,
                     description: workflow.description || '',
@@ -282,6 +288,8 @@ class V1Worker {
                             backoffFactor: ((_h = task.backoff) === null || _h === void 0 ? void 0 : _h.factor) || ((_k = (_j = workflow.taskDefaults) === null || _j === void 0 ? void 0 : _j.backoff) === null || _k === void 0 ? void 0 : _k.factor),
                             backoffMaxSeconds: ((_l = task.backoff) === null || _l === void 0 ? void 0 : _l.maxSeconds) || ((_o = (_m = workflow.taskDefaults) === null || _m === void 0 ? void 0 : _m.backoff) === null || _o === void 0 ? void 0 : _o.maxSeconds),
                             conditions: (0, transformer_1.taskConditionsToPb)(task),
+                            isDurable: durableTaskSet.has(task),
+                            slotRequests: task.slotRequests || (durableTaskSet.has(task) ? { durable: 1 } : { default: 1 }),
                             concurrency: task.concurrency
                                 ? Array.isArray(task.concurrency)
                                     ? task.concurrency
@@ -671,6 +679,21 @@ class V1Worker {
             }
         });
     }
+    /**
+     * Creates an action listener by registering the worker with the dispatcher.
+     * Override in subclasses to change registration behavior (e.g. legacy engines).
+     */
+    createListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client._v0.dispatcher.getActionListener({
+                workerName: this.name,
+                services: ['default'],
+                actions: Object.keys(this.action_registry),
+                slotConfig: this.slotConfig,
+                labels: this.labels,
+            });
+        });
+    }
     start() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, e_1, _b, _c;
@@ -691,13 +714,7 @@ class V1Worker {
                 return;
             }
             try {
-                this.listener = yield this.client._v0.dispatcher.getActionListener({
-                    workerName: this.name,
-                    services: ['default'],
-                    actions: Object.keys(this.action_registry),
-                    maxRuns: this.maxRuns,
-                    labels: this.labels,
-                });
+                this.listener = yield this.createListener();
                 this.workerId = this.listener.workerId;
                 this.setStatus(health_server_1.workerStatus.HEALTHY);
                 const generator = this.listener.actions();