@hatchet-dev/typescript-sdk 1.10.8 → 1.12.0

package/v1/client/client.d.ts

@@ -20,6 +20,7 @@ import { ScheduleClient } from './features/schedules';
 import { CronClient } from './features/crons';
 import { CELClient } from './features/cel';
 import { TenantClient } from './features/tenant';
+import { WebhooksClient } from './features/webhooks';
 /**
  * HatchetV1 implements the main client interface for interacting with the Hatchet workflow engine.
  * It provides methods for creating and executing workflows, as well as managing workers.
@@ -193,6 +194,12 @@ export declare class HatchetClient implements IHatchetClient {
      * @returns A tenant client instance
      */
     get tenant(): TenantClient;
+    private _webhooks;
+    /**
+     * Get the webhooks client for creating and managing webhooks
+     * @returns A webhooks client instance
+     */
+    get webhooks(): WebhooksClient;
     private _ratelimits;
     /**
      * Get the rate limits client for creating and managing rate limits
@@ -245,6 +252,6 @@ export declare class HatchetClient implements IHatchetClient {
      * @param workflows - The workflows to register on the webhooks
      * @returns A promise that resolves when the webhook is registered
      */
-    webhooks(workflows: V0Workflow[]): import("../../clients/worker/handler").WebhookHandler;
+    v0webhooks(workflows: V0Workflow[]): import("../../clients/worker/handler").WebhookHandler;
     runRef<T extends Record<string, any> = any>(id: string): WorkflowRunRef<T>;
 }

package/v1/client/client.js

@@ -37,6 +37,7 @@ const schedules_1 = require("./features/schedules");
 const crons_1 = require("./features/crons");
 const cel_1 = require("./features/cel");
 const tenant_1 = require("./features/tenant");
+const webhooks_1 = require("./features/webhooks");
 /**
  * HatchetV1 implements the main client interface for interacting with the Hatchet workflow engine.
  * It provides methods for creating and executing workflows, as well as managing workers.
@@ -289,6 +290,16 @@ class HatchetClient {
         }
         return this._tenant;
     }
+    /**
+     * Get the webhooks client for creating and managing webhooks
+     * @returns A webhooks client instance
+     */
+    get webhooks() {
+        if (!this._webhooks) {
+            this._webhooks = new webhooks_1.WebhooksClient(this);
+        }
+        return this._webhooks;
+    }
     /**
      * Get the rate limits client for creating and managing rate limits
      * @returns A rate limits client instance
@@ -374,7 +385,7 @@ class HatchetClient {
      * @param workflows - The workflows to register on the webhooks
      * @returns A promise that resolves when the webhook is registered
      */
-    webhooks(workflows) {
+    v0webhooks(workflows) {
         return this._v0.webhooks(workflows);
     }
     runRef(id) {

package/v1/client/features/metrics.d.ts

@@ -1,6 +1,11 @@
-import { BaseWorkflowDeclaration } from '../..';
-import { Workflow } from '../../../workflow';
 import { HatchetClient } from '../client';
+export type TaskStatusMetrics = {
+    cancelled: number;
+    completed: number;
+    failed: number;
+    queued: number;
+    running: number;
+};
 /**
  * MetricsClient is used to get metrics for workflows
  */
@@ -8,7 +13,13 @@ export declare class MetricsClient {
     tenantId: string;
     api: HatchetClient['api'];
     constructor(client: HatchetClient);
-    getWorkflowMetrics(workflow: string | Workflow | BaseWorkflowDeclaration<any, any>, opts?: Parameters<typeof this.api.workflowGetMetrics>[1]): Promise<import("../../../clients/rest/generated/data-contracts").WorkflowMetrics>;
-    getQueueMetrics(opts?: Parameters<typeof this.api.tenantGetQueueMetrics>[1] & {}): Promise<import("../../../clients/rest/generated/data-contracts").TenantQueueMetrics>;
-    getTaskMetrics(opts?: Parameters<typeof this.api.tenantGetStepRunQueueMetrics>[1]): Promise<import("../../../clients/rest/generated/data-contracts").TenantStepRunQueueMetrics>;
+    /**
+     * Get task/run status metrics for a tenant.
+     *
+     * This backs the dashboard "runs list" status count badges.
+     *
+     * Endpoint: GET /api/v1/stable/tenants/{tenant}/task-metrics
+     */
+    getTaskStatusMetrics(query: Parameters<typeof this.api.v1TaskListStatusMetrics>[1], requestParams?: Parameters<typeof this.api.v1TaskListStatusMetrics>[2]): Promise<TaskStatusMetrics>;
+    getQueueMetrics(opts?: Parameters<typeof this.api.tenantGetStepRunQueueMetrics>[1]): Promise<import("../../../clients/rest/generated/data-contracts").TenantStepRunQueueMetrics>;
 }

package/v1/client/features/metrics.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetricsClient = void 0;
-const v1_1 = require("../..");
 /**
  * MetricsClient is used to get metrics for workflows
  */
@@ -19,24 +18,24 @@ class MetricsClient {
         this.tenantId = client.tenantId;
         this.api = client.api;
     }
-    getWorkflowMetrics(workflow, opts) {
+    /**
+     * Get task/run status metrics for a tenant.
+     *
+     * This backs the dashboard "runs list" status count badges.
+     *
+     * Endpoint: GET /api/v1/stable/tenants/{tenant}/task-metrics
+     */
+    getTaskStatusMetrics(query, requestParams) {
         return __awaiter(this, void 0, void 0, function* () {
-            const name = (0, v1_1.workflowNameString)(workflow);
-            const { data } = yield this.api.workflowGetMetrics(name, opts);
-            return data;
+            const { data } = yield this.api.v1TaskListStatusMetrics(this.tenantId, query, requestParams);
+            return data.reduce((acc, curr) => {
+                acc[curr.status.toLowerCase()] = curr.count;
+                return acc;
+            }, {});
         });
     }
     getQueueMetrics(opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            // TODO IMPORTANT workflow id is the uuid for the workflow... not its name
-            // const stringWorkflows = opts?.workflows?
-            const { data } = yield this.api.tenantGetQueueMetrics(this.tenantId, Object.assign({}, opts));
-            return data;
-        });
-    }
-    getTaskMetrics(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO what is this...
             const { data } = yield this.api.tenantGetStepRunQueueMetrics(this.tenantId, opts);
             return data;
         });

package/v1/client/features/runs.d.ts

@@ -40,12 +40,20 @@ export interface ListRunsOpts extends RunFilter {
     /** Whether to include DAGs or only to include tasks */
     onlyTasks: boolean;
     /**
-     * The parent task external id to filter by
+     * The parent task run external id to filter by
+     * @deprecated use parentTaskRunExternalId instead
      * @format uuid
      * @minLength 36
      * @maxLength 36
      */
     parentTaskExternalId?: string;
+    /**
+     * The parent task run external id to filter by
+     * @format uuid
+     * @minLength 36
+     * @maxLength 36
+     */
+    parentTaskRunExternalId?: string;
     /**
      * The triggering event external id to filter by
      * @format uuid

package/v1/client/features/runs.js

@@ -62,7 +62,9 @@ class RunsClient {
     }
     list(opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data } = yield this.api.v1WorkflowRunList(this.tenantId, Object.assign({}, (yield this.prepareListFilter(opts || {}))));
+            const normalizedOpts = (opts === null || opts === void 0 ? void 0 : opts.parentTaskExternalId) && !(opts === null || opts === void 0 ? void 0 : opts.parentTaskRunExternalId)
+                ? Object.assign(Object.assign({}, opts), { parentTaskRunExternalId: opts.parentTaskExternalId }) : opts;
+            const { data } = yield this.api.v1WorkflowRunList(this.tenantId, Object.assign({}, (yield this.prepareListFilter(normalizedOpts || {}))));
             return data;
         });
     }
@@ -114,7 +116,7 @@ class RunsClient {
                 workflow_ids: yield Promise.all(((_b = opts.workflowNames) === null || _b === void 0 ? void 0 : _b.map((name) => __awaiter(this, void 0, void 0, function* () { return (yield this.workflows.get(name)).metadata.id; }))) || []),
                 additional_metadata: am,
                 only_tasks: opts.onlyTasks || false,
-                parent_task_external_id: opts.parentTaskExternalId,
+                parent_task_external_id: opts.parentTaskRunExternalId,
                 triggering_event_external_id: opts.triggeringEventExternalId,
                 include_payloads: opts.includePayloads,
             };

package/v1/client/features/webhooks.d.ts

@@ -0,0 +1,28 @@
+import { V1CreateWebhookRequestBase, V1UpdateWebhookRequest, V1Webhook, V1WebhookList, V1WebhookSourceName, V1WebhookAPIKeyAuth, V1WebhookBasicAuth, V1WebhookHMACAuth } from '../../../clients/rest/generated/data-contracts';
+import { HatchetClient } from '../client';
+export type CreateWebhookOptions = V1CreateWebhookRequestBase & {
+    auth: V1WebhookBasicAuth | V1WebhookAPIKeyAuth | V1WebhookHMACAuth;
+};
+/**
+ * Client for managing incoming webhooks in Hatchet.
+ *
+ * Webhooks allow external systems to trigger Hatchet workflows by sending HTTP
+ * requests to dedicated endpoints. This enables real-time integration with
+ * third-party services like GitHub, Stripe, Slack, or any system that can send
+ * webhook events.
+ */
+export declare class WebhooksClient {
+    api: HatchetClient['api'];
+    tenantId: string;
+    constructor(client: HatchetClient);
+    list(options?: {
+        limit?: number;
+        offset?: number;
+        webhookNames?: string[];
+        sourceNames?: V1WebhookSourceName[];
+    }): Promise<V1WebhookList>;
+    get(webhookName: string): Promise<V1Webhook>;
+    create(request: CreateWebhookOptions): Promise<V1Webhook>;
+    update(webhookName: string, options?: Partial<V1UpdateWebhookRequest>): Promise<V1Webhook>;
+    delete(webhookName: string): Promise<V1Webhook>;
+}

package/v1/client/features/webhooks.js

@@ -0,0 +1,97 @@
+"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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhooksClient = void 0;
+const data_contracts_1 = require("../../../clients/rest/generated/data-contracts");
+function getAuthType(auth) {
+    if ('username' in auth && 'password' in auth)
+        return data_contracts_1.V1WebhookAuthType.BASIC;
+    if ('headerName' in auth && 'apiKey' in auth)
+        return data_contracts_1.V1WebhookAuthType.API_KEY;
+    if ('signingSecret' in auth &&
+        'signatureHeaderName' in auth &&
+        'algorithm' in auth &&
+        'encoding' in auth) {
+        return data_contracts_1.V1WebhookAuthType.HMAC;
+    }
+    throw new Error('Invalid webhook auth');
+}
+function toCreateWebhookRequest(options) {
+    const { auth } = options, base = __rest(options, ["auth"]);
+    const authType = getAuthType(auth);
+    return Object.assign(Object.assign({}, base), { authType, auth });
+}
+/**
+ * Client for managing incoming webhooks in Hatchet.
+ *
+ * Webhooks allow external systems to trigger Hatchet workflows by sending HTTP
+ * requests to dedicated endpoints. This enables real-time integration with
+ * third-party services like GitHub, Stripe, Slack, or any system that can send
+ * webhook events.
+ */
+class WebhooksClient {
+    constructor(client) {
+        this.api = client.api;
+        this.tenantId = client.tenantId;
+    }
+    list(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.api.v1WebhookList(this.tenantId, {
+                limit: options === null || options === void 0 ? void 0 : options.limit,
+                offset: options === null || options === void 0 ? void 0 : options.offset,
+                webhookNames: options === null || options === void 0 ? void 0 : options.webhookNames,
+                sourceNames: options === null || options === void 0 ? void 0 : options.sourceNames,
+            });
+            return response.data;
+        });
+    }
+    get(webhookName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.api.v1WebhookGet(this.tenantId, webhookName);
+            return response.data;
+        });
+    }
+    create(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = toCreateWebhookRequest(request);
+            const response = yield this.api.v1WebhookCreate(this.tenantId, payload);
+            return response.data;
+        });
+    }
+    update(webhookName_1) {
+        return __awaiter(this, arguments, void 0, function* (webhookName, options = {}) {
+            const response = yield this.api.v1WebhookUpdate(this.tenantId, webhookName, {
+                eventKeyExpression: options.eventKeyExpression,
+                scopeExpression: options.scopeExpression,
+                staticPayload: options.staticPayload,
+            });
+            return response.data;
+        });
+    }
+    delete(webhookName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.api.v1WebhookDelete(this.tenantId, webhookName);
+            return response.data;
+        });
+    }
+}
+exports.WebhooksClient = WebhooksClient;

package/v1/client/worker/context.d.ts

@@ -112,7 +112,7 @@ export declare class Context<T, K = {}> {
      * Gets the ID of the current task run.
      * @returns The task run ID.
      */
-    taskRunId(): string;
+    taskRunExternalId(): string;
     /**
      * Gets the number of times the current task has been retried.
      * @returns The retry count.

package/v1/client/worker/context.js

@@ -59,7 +59,7 @@ class Context {
     cancel() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.v1.runs.cancel({
-                ids: [this.action.stepRunId],
+                ids: [this.action.taskRunExternalId],
             });
             // optimistically abort the run
             this.controller.abort();
@@ -150,7 +150,7 @@ class Context {
      * @returns The name of the task.
      */
     taskName() {
-        return this.action.stepName;
+        return this.action.taskName;
     }
     /**
      * Gets the ID of the current workflow run.
@@ -177,8 +177,8 @@ class Context {
      * Gets the ID of the current task run.
      * @returns The task run ID.
      */
-    taskRunId() {
-        return this.action.stepRunId;
+    taskRunExternalId() {
+        return this.action.taskRunExternalId;
     }
     /**
      * Gets the number of times the current task has been retried.
@@ -194,14 +194,14 @@ class Context {
      * @deprecated use ctx.logger.infoger.info, ctx.logger.infoger.debug, ctx.logger.infoger.warn, ctx.logger.infoger.error, ctx.logger.infoger.trace instead
      */
     log(message, level, extra) {
-        const { stepRunId } = this.action;
-        if (!stepRunId) {
+        const { taskRunExternalId } = this.action;
+        if (!taskRunExternalId) {
             // log a warning
             this._logger.warn('cannot log from context without stepRunId');
             return Promise.resolve();
         }
         const logger = this.v1.config.logger('ctx', this.v1.config.log_level);
-        const contextExtra = Object.assign({ workflowRunId: this.action.workflowRunId, taskRunId: this.action.stepRunId, retryCount: this.action.retryCount, workflowName: this.action.jobName }, extra === null || extra === void 0 ? void 0 : extra.extra);
+        const contextExtra = Object.assign({ workflowRunId: this.action.workflowRunId, taskRunExternalId: this.action.taskRunExternalId, retryCount: this.action.retryCount, workflowName: this.action.jobName }, extra === null || extra === void 0 ? void 0 : extra.extra);
         const promises = [];
         if (!level || level === 'INFO') {
             promises.push(logger.info(message, contextExtra));
@@ -216,7 +216,7 @@ class Context {
             promises.push(logger.error(message, extra === null || extra === void 0 ? void 0 : extra.error, contextExtra));
         }
         // FIXME: this is a hack to get around the fact that the log level is not typed
-        promises.push(this.v1.event.putLog(stepRunId, message, level, this.retryCount(), extra === null || extra === void 0 ? void 0 : extra.extra));
+        promises.push(this.v1.event.putLog(taskRunExternalId, message, level, this.retryCount(), extra === null || extra === void 0 ? void 0 : extra.extra));
         return Promise.all(promises);
     }
     get logger() {
@@ -249,13 +249,13 @@ class Context {
      */
     refreshTimeout(incrementBy) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { stepRunId } = this.action;
-            if (!stepRunId) {
+            const { taskRunExternalId } = this.action;
+            if (!taskRunExternalId) {
                 // log a warning
                 this._logger.warn('cannot refresh timeout from context without stepRunId');
                 return;
             }
-            yield this.v1._v0.dispatcher.refreshTimeout(incrementBy, stepRunId);
+            yield this.v1._v0.dispatcher.refreshTimeout(incrementBy, taskRunExternalId);
         });
     }
     /**
@@ -266,7 +266,7 @@ class Context {
     releaseSlot() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.v1._v0.dispatcher.client.releaseSlot({
-                stepRunId: this.action.stepRunId,
+                taskRunExternalId: this.action.taskRunExternalId,
             });
         });
     }
@@ -277,14 +277,14 @@ class Context {
      */
     putStream(data) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { stepRunId } = this.action;
-            if (!stepRunId) {
+            const { taskRunExternalId } = this.action;
+            if (!taskRunExternalId) {
                 // log a warning
                 this._logger.warn('cannot log from context without stepRunId');
                 return;
             }
             const index = this._incrementStreamIndex();
-            yield this.v1._v0.event.putStream(stepRunId, data, index);
+            yield this.v1._v0.event.putStream(taskRunExternalId, data, index);
         });
     }
     spawnOptions(workflow, options) {
@@ -300,8 +300,8 @@ class Context {
         if (sticky && !this.worker.hasWorkflow(workflowName)) {
             throw new hatchet_error_1.default(`Cannot run with sticky: workflow ${workflowName} is not registered on the worker`);
         }
-        const { workflowRunId, stepRunId } = this.action;
-        const finalOpts = Object.assign(Object.assign({}, options), { parentId: workflowRunId, parentStepRunId: stepRunId, 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 { 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 });
         this.spawnIndex += 1;
         return { workflowName, opts: finalOpts };
     }
@@ -452,7 +452,7 @@ class Context {
      */
     spawnWorkflows(workflows) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { workflowRunId, stepRunId } = this.action;
+            const { workflowRunId, taskRunExternalId } = this.action;
             const workflowRuns = workflows.map(({ workflow, input, options }) => {
                 let workflowName;
                 if (typeof workflow === 'string') {
@@ -470,7 +470,7 @@ class Context {
                 const resp = {
                     workflowName: name,
                     input,
-                    options: Object.assign(Object.assign({}, opts), { parentId: workflowRunId, parentStepRunId: stepRunId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }),
+                    options: Object.assign(Object.assign({}, opts), { parentId: workflowRunId, parentTaskRunExternalId: taskRunExternalId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }),
                 };
                 this.spawnIndex += 1;
                 return resp;
@@ -510,7 +510,7 @@ class Context {
      */
     spawnWorkflow(workflow, input, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { workflowRunId, stepRunId } = this.action;
+            const { workflowRunId, taskRunExternalId } = this.action;
             let workflowName = '';
             if (typeof workflow === 'string') {
                 workflowName = workflow;
@@ -525,7 +525,7 @@ class Context {
                 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, parentStepRunId: stepRunId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }, opts));
+                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));
                 this.spawnIndex += 1;
                 if (workflow instanceof declaration_1.TaskWorkflowDeclaration) {
                     resp._standaloneTaskName = workflow._standalone_task_name;
@@ -572,13 +572,13 @@ class DurableContext extends Context {
             // eslint-disable-next-line no-plusplus
             const key = `waitFor-${this.waitKey++}`;
             yield this.v1._v0.durableListener.registerDurableEvent({
-                taskId: this.action.stepRunId,
+                taskId: this.action.taskRunExternalId,
                 signalKey: key,
                 sleepConditions: pbConditions.sleepConditions,
                 userEventConditions: pbConditions.userEventConditions,
             });
             const listener = this.v1._v0.durableListener.subscribe({
-                taskId: this.action.stepRunId,
+                taskId: this.action.taskRunExternalId,
                 signalKey: key,
             });
             const event = yield listener.get();

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

@@ -26,8 +26,8 @@ export declare class V1Worker {
     action_registry: ActionRegistry;
     workflow_registry: Array<WorkflowDefinition | Workflow>;
     listener: ActionListener | undefined;
-    futures: Record<Action['stepRunId'], HatchetPromise<any>>;
-    contexts: Record<Action['stepRunId'], Context<any, any>>;
+    futures: Record<Action['taskRunExternalId'], HatchetPromise<any>>;
+    contexts: Record<Action['taskRunExternalId'], Context<any, any>>;
     maxRuns?: number;
     logger: Logger;
     registeredWorkflowPromises: Array<Promise<any>>;

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

@@ -398,11 +398,11 @@ class V1Worker {
     }
     handleStartStepRun(action) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { actionId } = action;
+            const { actionId, taskRunExternalId } = action;
             try {
                 // Note: we always use a DurableContext since its a superset of the Context class
                 const context = new context_1.DurableContext(action, this.client, this);
-                this.contexts[action.stepRunId] = context;
+                this.contexts[taskRunExternalId] = context;
                 const step = this.action_registry[actionId];
                 if (!step) {
                     this.logger.error(`Registered actions: '${Object.keys(this.action_registry).join(', ')}'`);
@@ -412,7 +412,7 @@ class V1Worker {
                 const run = () => __awaiter(this, void 0, void 0, function* () {
                     parent_run_context_vars_1.parentRunContextManager.setContext({
                         parentId: action.workflowRunId,
-                        parentRunId: action.stepRunId,
+                        parentTaskRunExternalId: taskRunExternalId,
                         childIndex: 0,
                         desiredWorkerId: this.workerId || '',
                     });
@@ -423,7 +423,7 @@ class V1Worker {
                         if (context.cancelled) {
                             return;
                         }
-                        this.logger.info(`Task run ${action.stepRunId} succeeded`);
+                        this.logger.info(`Task run ${taskRunExternalId} succeeded`);
                         // Send the action event to the dispatcher
                         const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_COMPLETED, false, result || null, action.retryCount);
                         yield this.client._v0.dispatcher.sendStepActionEvent(event);
@@ -442,8 +442,8 @@ class V1Worker {
                     }
                     finally {
                         // delete the run from the futures
-                        delete this.futures[action.stepRunId];
-                        delete this.contexts[action.stepRunId];
+                        delete this.futures[taskRunExternalId];
+                        delete this.contexts[taskRunExternalId];
                     }
                 });
                 const failure = (error) => __awaiter(this, void 0, void 0, function* () {
@@ -452,7 +452,7 @@ class V1Worker {
                         if (context.cancelled) {
                             return;
                         }
-                        this.logger.error(`Task run ${action.stepRunId} failed: ${error.message}`);
+                        this.logger.error(`Task run ${taskRunExternalId} failed: ${error.message}`);
                         if (error.stack) {
                             this.logger.error(error.stack);
                         }
@@ -468,8 +468,8 @@ class V1Worker {
                     }
                     finally {
                         // delete the run from the futures
-                        delete this.futures[action.stepRunId];
-                        delete this.contexts[action.stepRunId];
+                        delete this.futures[taskRunExternalId];
+                        delete this.contexts[taskRunExternalId];
                     }
                 });
                 const future = new hatchet_promise_1.default((() => __awaiter(this, void 0, void 0, function* () {
@@ -483,7 +483,7 @@ class V1Worker {
                     }
                     yield success(result);
                 }))());
-                this.futures[action.stepRunId] = future;
+                this.futures[taskRunExternalId] = future;
                 // Send the action event to the dispatcher
                 const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_STARTED, false, undefined, action.retryCount);
                 this.client._v0.dispatcher.sendStepActionEvent(event).catch((e) => {
@@ -495,10 +495,10 @@ class V1Worker {
                 catch (e) {
                     const message = (e === null || e === void 0 ? void 0 : e.message) || String(e);
                     if (message.includes('Cancelled')) {
-                        this.logger.debug(`Task run ${action.stepRunId} was cancelled`);
+                        this.logger.debug(`Task run ${taskRunExternalId} was cancelled`);
                     }
                     else {
-                        this.logger.error(`Could not wait for task run ${action.stepRunId} to finish. ` +
+                        this.logger.error(`Could not wait for task run ${taskRunExternalId} to finish. ` +
                             `See https://docs.hatchet.run/home/cancellation for best practices on handling cancellation: `, e);
                     }
                 }
@@ -510,11 +510,11 @@ class V1Worker {
     }
     handleStartGroupKeyRun(action) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { actionId } = action;
+            const { actionId, getGroupKeyRunId, taskRunExternalId } = action;
             this.logger.error('Concurrency Key Functions have been deprecated and will be removed in a future release. Use Concurrency Expressions instead.');
             try {
                 const context = new context_1.Context(action, this.client, this);
-                const key = action.getGroupKeyRunId;
+                const key = getGroupKeyRunId;
                 if (!key) {
                     this.logger.error(`No group key run id provided for action ${actionId}`);
                     return;
@@ -530,7 +530,7 @@ class V1Worker {
                     return step(context);
                 });
                 const success = (result) => {
-                    this.logger.info(`Task run ${action.stepRunId} succeeded`);
+                    this.logger.info(`Task run ${taskRunExternalId} succeeded`);
                     try {
                         // Send the action event to the dispatcher
                         const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_COMPLETED, result);
@@ -584,8 +584,8 @@ class V1Worker {
             workerId: this.name,
             jobId: action.jobId,
             jobRunId: action.jobRunId,
-            stepId: action.stepId,
-            stepRunId: action.stepRunId,
+            taskId: action.taskId,
+            taskRunExternalId: action.taskRunExternalId,
             actionId: action.actionId,
             eventTimestamp: new Date(),
             eventType,
@@ -610,17 +610,17 @@ class V1Worker {
     }
     handleCancelStepRun(action) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { stepRunId } = action;
+            const { taskRunExternalId } = action;
             try {
-                this.logger.info(`Cancelling task run ${action.stepRunId}`);
-                const future = this.futures[stepRunId];
-                const context = this.contexts[stepRunId];
+                this.logger.info(`Cancelling task run ${taskRunExternalId}`);
+                const future = this.futures[taskRunExternalId];
+                const context = this.contexts[taskRunExternalId];
                 if (context && context.abortController) {
                     context.abortController.abort('Cancelled by worker');
                 }
                 if (future) {
                     future.promise.catch(() => {
-                        this.logger.info(`Cancelled task run ${action.stepRunId}`);
+                        this.logger.info(`Cancelled task run ${taskRunExternalId}`);
                     });
                     future.cancel('Cancelled by worker');
                     yield future.promise;
@@ -628,11 +628,11 @@ class V1Worker {
             }
             catch (e) {
                 // Expected: the promise rejects when cancelled
-                this.logger.debug(`Task run ${stepRunId} cancellation completed`);
+                this.logger.debug(`Task run ${taskRunExternalId} cancellation completed`);
             }
             finally {
-                delete this.futures[stepRunId];
-                delete this.contexts[stepRunId];
+                delete this.futures[taskRunExternalId];
+                delete this.contexts[taskRunExternalId];
             }
         });
     }