@hatchet-dev/typescript-sdk 1.13.1 → 1.15.0

package/{v1 → src/v1}/client/worker/context.js

@@ -12,17 +12,65 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DurableContext = exports.Context = void 0;
+exports.DurableContext = exports.Context = exports.ContextWorker = void 0;
+/**
+ * The Hatchet Context class provides helper methods and useful data to tasks at runtime. It is passed as the second argument to all tasks and durable tasks.
+ *
+ * There are two types of context classes you'll encounter:
+ *
+ * - Context - The standard context for regular tasks with methods for logging, task output retrieval, cancellation, and more.
+ * - DurableContext - An extended context for durable tasks that includes additional methods for durable execution.
+ * @module Context
+ */
 /* eslint-disable no-underscore-dangle */
 /* eslint-disable max-classes-per-file */
-const declaration_1 = require("../../declaration");
-const hatchet_error_1 = __importDefault(require("../../../util/errors/hatchet-error"));
-const parse_1 = require("../../../util/parse");
-const conditions_1 = require("../../conditions");
-const transformer_1 = require("../../conditions/transformer");
-const condition_1 = require("../../../protoc/v1/shared/condition");
-const step_1 = require("../../../step");
-const apply_namespace_1 = require("../../../util/apply-namespace");
+const declaration_1 = require("../../../../v1/declaration");
+const hatchet_error_1 = __importDefault(require("../../../../util/errors/hatchet-error"));
+const parse_1 = require("../../../../util/parse");
+const conditions_1 = require("../../../../v1/conditions");
+const transformer_1 = require("../../../../v1/conditions/transformer");
+const condition_1 = require("../../../../protoc/v1/shared/condition");
+const apply_namespace_1 = require("../../../../util/apply-namespace");
+const abort_error_1 = require("../../../../util/abort-error");
+/**
+ * ContextWorker is a wrapper around the V1Worker class that provides a more user-friendly interface for the worker from the context of a run.
+ */
+class ContextWorker {
+    constructor(worker) {
+        this.worker = worker;
+    }
+    /**
+     * Gets the ID of the worker.
+     * @returns The ID of the worker.
+     */
+    id() {
+        return this.worker.workerId;
+    }
+    /**
+     * Checks if the worker has a registered workflow.
+     * @param workflowName - The name of the workflow to check.
+     * @returns True if the workflow is registered, otherwise false.
+     */
+    hasWorkflow(workflowName) {
+        return !!this.worker.workflow_registry.find((workflow) => 'id' in workflow ? workflow.id === workflowName : workflow.name === workflowName);
+    }
+    /**
+     * Gets the current state of the worker labels.
+     * @returns The labels of the worker.
+     */
+    labels() {
+        return this.worker.labels;
+    }
+    /**
+     * Upserts the a set of labels on the worker.
+     * @param labels - The labels to upsert.
+     * @returns A promise that resolves when the labels have been upserted.
+     */
+    upsertLabels(labels) {
+        return this.worker.upsertLabels(labels);
+    }
+}
+exports.ContextWorker = ContextWorker;
 class Context {
     constructor(action, v1, worker) {
         // @deprecated use ctx.abortController instead
@@ -35,7 +83,7 @@ class Context {
             this.data = data;
             this.action = action;
             this.v1 = v1;
-            this.worker = new step_1.ContextWorker(worker);
+            this.worker = new ContextWorker(worker);
             this._logger = v1.config.logger(`Context Logger`, v1.config.log_level);
             // if this is a getGroupKeyRunId, the data is the workflow input
             if (action.getGroupKeyRunId !== '') {
@@ -56,6 +104,22 @@ class Context {
     get cancelled() {
         return this.controller.signal.aborted;
     }
+    throwIfCancelled() {
+        if (this.abortController.signal.aborted) {
+            throw (0, abort_error_1.createAbortError)('Operation cancelled by AbortSignal');
+        }
+    }
+    /**
+     * Helper for broad `catch` blocks so cancellation isn't accidentally swallowed.
+     *
+     * Example:
+     * ```ts
+     * try { ... } catch (e) { ctx.rethrowIfCancelled(e); ... }
+     * ```
+     */
+    rethrowIfCancelled(err) {
+        (0, abort_error_1.rethrowIfAborted)(err);
+    }
     cancel() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.v1.runs.cancel({
@@ -91,6 +155,7 @@ class Context {
      * @returns A record mapping task names to error messages.
      * @throws A warning if no errors are found (this method should be used in on-failure tasks).
      * @deprecated use ctx.errors() instead
+     * @hidden
      */
     stepRunErrors() {
         return this.errors();
@@ -184,6 +249,7 @@ class Context {
      * Gets the ID of the current task run.
      * @returns The task run ID.
      * @deprecated use taskRunExternalId() instead
+     * @hidden
      */
     taskRunId() {
         return this.taskRunExternalId();
@@ -200,6 +266,7 @@ class Context {
      * @param message - The message to log.
      * @param level - The log level (optional).
      * @deprecated use ctx.logger.infoger.info, ctx.logger.infoger.debug, ctx.logger.infoger.warn, ctx.logger.infoger.error, ctx.logger.infoger.trace instead
+     * @hidden
      */
     log(message, level, extra) {
         const { taskRunExternalId } = this.action;
@@ -263,7 +330,7 @@ class Context {
                 this._logger.warn('cannot refresh timeout from context without stepRunId');
                 return;
             }
-            yield this.v1._v0.dispatcher.refreshTimeout(incrementBy, taskRunExternalId);
+            yield this.v1.dispatcher.refreshTimeout(incrementBy, taskRunExternalId);
         });
     }
     /**
@@ -273,7 +340,7 @@ class Context {
      */
     releaseSlot() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.v1._v0.dispatcher.client.releaseSlot({
+            yield this.v1.dispatcher.client.releaseSlot({
                 taskRunExternalId: this.action.taskRunExternalId,
             });
         });
@@ -292,16 +359,17 @@ class Context {
                 return;
             }
             const index = this._incrementStreamIndex();
-            yield this.v1._v0.event.putStream(taskRunExternalId, data, index);
+            yield this.v1.events.putStream(taskRunExternalId, data, index);
         });
     }
     spawnOptions(workflow, options) {
+        this.throwIfCancelled();
         let workflowName;
         if (typeof workflow === 'string') {
             workflowName = workflow;
         }
         else {
-            workflowName = workflow.id;
+            workflowName = workflow.name;
         }
         const opts = options || {};
         const { sticky } = opts;
@@ -309,7 +377,7 @@ class Context {
             throw new hatchet_error_1.default(`Cannot run with sticky: workflow ${workflowName} is not registered on the worker`);
         }
         const { workflowRunId, taskRunExternalId } = this.action;
-        const finalOpts = Object.assign(Object.assign({}, options), { parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex: this.spawnIndex, childKey: options === null || options === void 0 ? void 0 : options.key, desiredWorkerId: sticky ? this.worker.id() : undefined, _standaloneTaskName: workflow instanceof declaration_1.TaskWorkflowDeclaration ? workflow._standalone_task_name : undefined });
+        const finalOpts = Object.assign(Object.assign({}, opts), { parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex: this.spawnIndex, childKey: options === null || options === void 0 ? void 0 : options.key, desiredWorkerId: sticky ? this.worker.id() : undefined, _standaloneTaskName: workflow instanceof declaration_1.TaskWorkflowDeclaration ? workflow._standalone_task_name : undefined });
         this.spawnIndex += 1;
         return { workflowName, opts: finalOpts };
     }
@@ -318,6 +386,7 @@ class Context {
         return this.v1.admin.runWorkflow(workflowName, input, opts);
     }
     spawnBulk(children) {
+        this.throwIfCancelled();
         const workflows = children.map((child) => {
             const { workflowName, opts } = this.spawnOptions(child.workflow, child.options);
             return { workflowName, input: child.input, options: opts };
@@ -331,7 +400,12 @@ class Context {
      */
     bulkRunNoWaitChildren(children) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.spawnBulk(children);
+            const refs = yield this.spawnBulk(children);
+            refs.forEach((ref) => {
+                // eslint-disable-next-line no-param-reassign
+                ref.defaultSignal = this.abortController.signal;
+            });
+            return refs;
         });
     }
     /**
@@ -356,6 +430,9 @@ class Context {
     runChild(workflow, input, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const run = yield this.spawn(workflow, input, options);
+            // Ensure waiting for the child result aborts when this task is cancelled.
+            // eslint-disable-next-line no-param-reassign
+            run.defaultSignal = this.abortController.signal;
             return run.output;
         });
     }
@@ -370,6 +447,7 @@ class Context {
     runNoWaitChild(workflow, input, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const ref = yield this.spawn(workflow, input, options);
+            ref.defaultSignal = this.abortController.signal;
             return ref;
         });
     }
@@ -425,6 +503,7 @@ class Context {
      * @returns The output of the task.
      * @throws An error if the task output is not found.
      * @deprecated use ctx.parentOutput instead
+     * @hidden
      */
     stepOutput(step) {
         if (!this.data.parents) {
@@ -439,6 +518,7 @@ class Context {
      * Gets the input data for the current workflow.
      * @returns The input data for the workflow.
      * @deprecated use task input parameter instead
+     * @hidden
      */
     workflowInput() {
         return this.input;
@@ -447,6 +527,7 @@ class Context {
      * Gets the name of the current task.
      * @returns The name of the task.
      * @deprecated use ctx.taskName instead
+     * @hidden
      */
     stepName() {
         return this.taskName();
@@ -457,9 +538,11 @@ class Context {
      * @param workflows - An array of objects containing the workflow name, input data, and options for each workflow.
      * @returns A list of references to the spawned workflow runs.
      * @deprecated Use bulkRunNoWaitChildren or bulkRunChildren instead.
+     * @hidden
      */
     spawnWorkflows(workflows) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.throwIfCancelled();
             const { workflowRunId, taskRunExternalId } = this.action;
             const workflowRuns = workflows.map(({ workflow, input, options }) => {
                 let workflowName;
@@ -467,18 +550,22 @@ class Context {
                     workflowName = workflow;
                 }
                 else {
-                    workflowName = workflow.id;
+                    workflowName = workflow.name;
                 }
-                const name = (0, apply_namespace_1.applyNamespace)(workflowName, this.v1.config.namespace);
+                const name = (0, apply_namespace_1.applyNamespace)(workflowName, this.v1.config.namespace).toLowerCase();
                 const opts = options || {};
                 const { sticky } = opts;
                 if (sticky && !this.worker.hasWorkflow(name)) {
                     throw new hatchet_error_1.default(`Cannot run with sticky: workflow ${name} is not registered on the worker`);
                 }
+                // `signal` must never be sent over the wire.
+                const optsWithoutSignal = Object.assign({}, opts);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                delete optsWithoutSignal.signal;
                 const resp = {
                     workflowName: name,
                     input,
-                    options: Object.assign(Object.assign({}, opts), { parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }),
+                    options: Object.assign(Object.assign({}, optsWithoutSignal), { parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }),
                 };
                 this.spawnIndex += 1;
                 return resp;
@@ -488,7 +575,7 @@ class Context {
                 let resp = [];
                 for (let i = 0; i < workflowRuns.length; i += batchSize) {
                     const batch = workflowRuns.slice(i, i + batchSize);
-                    const batchResp = yield this.v1._v0.admin.runWorkflows(batch);
+                    const batchResp = yield this.v1.admin.runWorkflows(batch);
                     resp = resp.concat(batchResp);
                 }
                 const res = [];
@@ -515,25 +602,27 @@ class Context {
      * @param options - Additional options for spawning the workflow.
      * @returns A reference to the spawned workflow run.
      * @deprecated Use runChild or runNoWaitChild instead.
+     * @hidden
      */
     spawnWorkflow(workflow, input, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.throwIfCancelled();
             const { workflowRunId, taskRunExternalId } = this.action;
             let workflowName = '';
             if (typeof workflow === 'string') {
                 workflowName = workflow;
             }
             else {
-                workflowName = workflow.id;
+                workflowName = workflow.name;
             }
-            const name = (0, apply_namespace_1.applyNamespace)(workflowName, this.v1.config.namespace);
+            const name = (0, apply_namespace_1.applyNamespace)(workflowName, this.v1.config.namespace).toLowerCase();
             const opts = options || {};
             const { sticky } = opts;
             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 = yield this.v1._v0.admin.runWorkflow(name, input, Object.assign({ parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }, opts));
+                const resp = yield this.v1.admin.runWorkflow(name, input, Object.assign({ parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }, opts));
                 this.spawnIndex += 1;
                 if (workflow instanceof declaration_1.TaskWorkflowDeclaration) {
                     resp._standaloneTaskName = workflow._standalone_task_name;
@@ -552,6 +641,10 @@ class Context {
     }
 }
 exports.Context = Context;
+/**
+ * DurableContext provides helper methods and useful data to durable tasks at runtime.
+ * It extends the Context class and includes additional methods for durable execution like sleepFor and waitFor.
+ */
 class DurableContext extends Context {
     constructor() {
         super(...arguments);
@@ -576,20 +669,20 @@ class DurableContext extends Context {
      */
     waitFor(conditions) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.throwIfCancelled();
             const pbConditions = (0, transformer_1.conditionsToPb)((0, conditions_1.Render)(condition_1.Action.CREATE, conditions));
             // eslint-disable-next-line no-plusplus
             const key = `waitFor-${this.waitKey++}`;
-            yield this.v1._v0.durableListener.registerDurableEvent({
+            yield this.v1.durableListener.registerDurableEvent({
                 taskId: this.action.taskRunExternalId,
                 signalKey: key,
                 sleepConditions: pbConditions.sleepConditions,
                 userEventConditions: pbConditions.userEventConditions,
             });
-            const listener = this.v1._v0.durableListener.subscribe({
+            const event = yield this.v1.durableListener.result({
                 taskId: this.action.taskRunExternalId,
                 signalKey: key,
-            });
-            const event = yield listener.get();
+            }, { signal: this.abortController.signal });
             // Convert event.data from Uint8Array to string if needed
             const eventData = event.data instanceof Uint8Array ? new TextDecoder().decode(event.data) : event.data;
             const res = JSON.parse(eventData);

package/{v1 → src/v1}/client/worker/deprecated/deprecation.d.ts

@@ -8,7 +8,7 @@
  *
  * Defaults: warnDays=90, errorDays=undefined (error phase disabled unless set).
  */
-import { Logger } from '../../../../util/logger';
+import { Logger } from '../../../../../util/logger';
 export declare class DeprecationError extends Error {
     feature: string;
     constructor(feature: string, message: string);

package/{v1 → src/v1}/client/worker/deprecated/legacy-registration.d.ts

@@ -3,8 +3,8 @@
  * 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';
+import { DispatcherClient, WorkerLabels } from '../../../../../clients/dispatcher/dispatcher-client';
+import { ActionListener } from '../../../../../clients/dispatcher/action-listener';
 export interface LegacyRegistrationOptions {
     workerName: string;
     services: string[];

package/{v1 → src/v1}/client/worker/deprecated/legacy-registration.js

@@ -15,8 +15,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 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");
+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`.
  */

package/{v1 → src/v1}/client/worker/deprecated/legacy-v1-worker.d.ts

@@ -2,12 +2,12 @@
  * 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 {
+import { ActionListener } from '../../../../../clients/dispatcher/action-listener';
+import { HatchetClient } from '../../../../../v1';
+import { InternalWorker } from '../worker-internal';
+export declare class LegacyV1Worker extends InternalWorker {
     private _legacySlotCount;
-    constructor(client: HatchetClient, options: ConstructorParameters<typeof V1Worker>[1], legacySlots: number);
+    constructor(client: HatchetClient, options: ConstructorParameters<typeof InternalWorker>[1], legacySlots: number);
     /**
      * Override registration to use the legacy `slots` proto field.
      */

package/{v1 → src/v1}/client/worker/deprecated/legacy-v1-worker.js

@@ -16,7 +16,7 @@ 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 {
+class LegacyV1Worker extends worker_internal_1.InternalWorker {
     constructor(client, options, legacySlots) {
         super(client, options);
         this._legacySlotCount = legacySlots;
@@ -26,7 +26,7 @@ class LegacyV1Worker extends worker_internal_1.V1Worker {
      */
     createListener() {
         return __awaiter(this, void 0, void 0, function* () {
-            return (0, legacy_registration_1.legacyGetActionListener)(this.client._v0.dispatcher, {
+            return (0, legacy_registration_1.legacyGetActionListener)(this.client.dispatcher, {
                 workerName: this.name,
                 services: ['default'],
                 actions: Object.keys(this.action_registry),

package/{v1 → src/v1}/client/worker/deprecated/legacy-worker.js

@@ -18,10 +18,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LegacyDualWorker = void 0;
 exports.isLegacyEngine = isLegacyEngine;
+/* eslint-disable no-underscore-dangle */
 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 legacy_transformer_1 = require("../../../../legacy/legacy-transformer");
 const DEFAULT_DEFAULT_SLOTS = 100;
 const DEFAULT_DURABLE_SLOTS = 1000;
 /** The date when slot_config support was released. */
@@ -40,10 +42,10 @@ const LEGACY_ENGINE_MESSAGE = 'Connected to an older Hatchet engine that does no
 function isLegacyEngine(v1) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            const version = yield v1._v0.dispatcher.getVersion();
+            const version = yield v1.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);
+                const logger = v1.config.logger('Worker', v1.config.log_level);
                 (0, deprecation_1.emitDeprecationNotice)('legacy-engine', LEGACY_ENGINE_MESSAGE, LEGACY_ENGINE_START, logger, {
                     errorDays: 180,
                 });
@@ -53,7 +55,7 @@ function isLegacyEngine(v1) {
         }
         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);
+                const logger = v1.config.logger('Worker', v1.config.log_level);
                 (0, deprecation_1.emitDeprecationNotice)('legacy-engine', LEGACY_ENGINE_MESSAGE, LEGACY_ENGINE_START, logger, {
                     errorDays: 180,
                 });
@@ -105,16 +107,16 @@ class LegacyDualWorker {
             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);
+                        yield durableWorker.registerWorkflow(wf);
+                        durableWorker.registerDurableActions(wf.definition);
                     }
                     else {
-                        yield nonDurable.registerWorkflowV1(wf);
+                        yield nonDurable.registerWorkflow(wf);
                     }
                 }
                 else {
                     // fallback to v0 client for backwards compatibility
-                    yield nonDurable.registerWorkflow(wf);
+                    yield nonDurable.registerWorkflow((0, legacy_transformer_1.transformLegacyWorkflow)(wf));
                 }
             }
             return legacyWorker;

package/{v1 → src/v1}/client/worker/health-server.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from '../../../util/logger';
+import { Logger } from '../../../../util/logger';
 export declare const workerStatus: {
     readonly INITIALIZED: "INITIALIZED";
     readonly STARTING: "STARTING";

package/{v1 → src/v1}/client/worker/slot-utils.d.ts

@@ -1,13 +1,13 @@
-import { Workflow as V0Workflow } from '../../../workflow';
 import { BaseWorkflowDeclaration } from '../../declaration';
+import type { LegacyWorkflow } from '../../../legacy/legacy-transformer';
 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[];
+    /** (optional) Array of workflows to register (supports both v1 and legacy workflow formats) */
+    workflows?: Array<BaseWorkflowDeclaration<any, any> | LegacyWorkflow>;
     /** @deprecated Use slots instead */
     maxRuns?: number;
 }

package/{v1 → src/v1}/client/worker/worker-internal.d.ts

@@ -1,12 +1,11 @@
-import { Action, ActionListener } from '../../../clients/dispatcher/action-listener';
-import { StepActionEvent, StepActionEventType, GroupKeyActionEvent, GroupKeyActionEventType } from '../../../protoc/dispatcher';
-import HatchetPromise from '../../../util/hatchet-promise/hatchet-promise';
-import { Workflow } from '../../../workflow';
-import { Logger } from '../../../util/logger';
-import { WebhookWorkerCreateRequest } from '../../../clients/rest/generated/data-contracts';
-import { BaseWorkflowDeclaration, WorkflowDefinition, HatchetClient } from '../..';
-import { WorkerLabels } from '../../../clients/dispatcher/dispatcher-client';
-import { StepRunFunction } from '../../../step';
+import { Action, ActionListener } from '../../../../clients/dispatcher/action-listener';
+import { StepActionEvent, StepActionEventType, GroupKeyActionEvent, GroupKeyActionEventType } from '../../../../protoc/dispatcher';
+import HatchetPromise from '../../../../util/hatchet-promise/hatchet-promise';
+import { CreateStepRateLimit } from '../../../../protoc/workflows';
+import { Logger } from '../../../../util/logger';
+import { BaseWorkflowDeclaration, WorkflowDefinition, HatchetClient } from '../../../../v1';
+import { CreateWorkflowTaskOpts } from '../../../../v1/task';
+import { WorkerLabels } from '../../../../clients/dispatcher/dispatcher-client';
 import { Context } from './context';
 import { SlotConfig } from '../../slot-types';
 export type ActionRegistry = Record<Action['actionId'], Function>;
@@ -19,14 +18,14 @@ export interface WorkerOpts {
     healthPort?: number;
     enableHealthServer?: boolean;
 }
-export declare class V1Worker {
+export declare class InternalWorker {
     client: HatchetClient;
     name: string;
     workerId: string | undefined;
     killing: boolean;
     handle_kill: boolean;
     action_registry: ActionRegistry;
-    workflow_registry: Array<WorkflowDefinition | Workflow>;
+    workflow_registry: Array<WorkflowDefinition>;
     listener: ActionListener | undefined;
     futures: Record<Action['taskRunExternalId'], HatchetPromise<any>>;
     contexts: Record<Action['taskRunExternalId'], Context<any, any>>;
@@ -53,18 +52,9 @@ export declare class V1Worker {
     private getRegisteredActions;
     private getFilteredLabels;
     private setStatus;
+    registerDurableActions(workflow: WorkflowDefinition): void;
     private registerActions;
-    getHandler(workflows: Workflow[]): void;
-    registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../../../clients/rest/generated/data-contracts").WebhookWorkerCreated, any, {}>>;
-    /**
-     * @deprecated use registerWorkflow instead
-     */
-    register_workflow(initWorkflow: Workflow): Promise<void>;
-    registerDurableActionsV1(workflow: WorkflowDefinition): void;
-    private registerActionsV1;
-    registerWorkflowV1(initWorkflow: BaseWorkflowDeclaration<any, any>, durable?: boolean): Promise<void>;
-    registerWorkflow(initWorkflow: Workflow): Promise<void>;
-    registerAction<T, K>(actionId: string, action: StepRunFunction<T, K>): void;
+    registerWorkflow(initWorkflow: BaseWorkflowDeclaration<any, any>, durable?: boolean): Promise<void>;
     handleStartStepRun(action: Action): Promise<void>;
     handleStartGroupKeyRun(action: Action): Promise<void>;
     getStepActionEvent(action: Action, eventType: StepActionEventType, shouldNotRetry: boolean, payload?: any, retryCount?: number): StepActionEvent;
@@ -81,3 +71,4 @@ export declare class V1Worker {
     handleAction(action: Action): Promise<void>;
     upsertLabels(labels: WorkerLabels): Promise<WorkerLabels>;
 }
+export declare function mapRateLimitPb(limits: CreateWorkflowTaskOpts<any, any>['rateLimits']): CreateStepRateLimit[];