@hatchet-dev/typescript-sdk 1.10.8 → 1.12.0

package/clients/admin/admin-client.d.ts

@@ -19,6 +19,16 @@ export type WorkflowRun<T = object> = {
     input: T;
     options?: {
         parentId?: string | undefined;
+        /**
+         * (optional) the parent task external run id.
+         *
+         * This is the field understood by the workflows gRPC API.
+         */
+        parentTaskRunExternalId?: string | undefined;
+        /**
+         * @deprecated Use `parentTaskRunExternalId` instead.
+         * Kept for backward compatibility; will be mapped to `parentTaskRunExternalId`.
+         */
         parentStepRunId?: string | undefined;
         childIndex?: number | undefined;
         childKey?: string | undefined;
@@ -65,6 +75,14 @@ export declare class AdminClient {
      */
     run_workflow<T = object>(workflowName: string, input: T, options?: {
         parentId?: string | undefined;
+        /**
+         * (optional) the parent task external run id.
+         */
+        parentTaskRunExternalId?: string | undefined;
+        /**
+         * @deprecated Use `parentTaskRunExternalId` instead.
+         * Kept for backward compatibility; will be mapped to `parentTaskRunExternalId`.
+         */
         parentStepRunId?: string | undefined;
         childIndex?: number | undefined;
         childKey?: string | undefined;
@@ -80,6 +98,16 @@ export declare class AdminClient {
      */
     runWorkflow<Q = object, P = object>(workflowName: string, input: Q, options?: {
         parentId?: string | undefined;
+        /**
+         * (optional) the parent task external run id.
+         *
+         * This is the field understood by the workflows gRPC API.
+         */
+        parentTaskRunExternalId?: string | undefined;
+        /**
+         * @deprecated Use `parentTaskRunExternalId` instead.
+         * Kept for backward compatibility; will be mapped to `parentTaskRunExternalId`.
+         */
         parentStepRunId?: string | undefined;
         childIndex?: number | undefined;
         childKey?: string | undefined;
@@ -98,6 +126,16 @@ export declare class AdminClient {
         input: Q;
         options?: {
             parentId?: string | undefined;
+            /**
+             * (optional) the parent task external run id.
+             *
+             * This is the field understood by the workflows gRPC API.
+             */
+            parentTaskRunExternalId?: string | undefined;
+            /**
+             * @deprecated Use `parentTaskRunExternalId` instead.
+             * Kept for backward compatibility; will be mapped to `parentTaskRunExternalId`.
+             */
             parentStepRunId?: string | undefined;
             childIndex?: number | undefined;
             childKey?: string | undefined;

package/clients/admin/admin-client.js

@@ -8,6 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -120,9 +131,11 @@ class AdminClient {
         const computedName = (0, apply_namespace_1.applyNamespace)(workflowName, this.config.namespace);
         try {
             const inputStr = JSON.stringify(input);
-            const resp = this.client.triggerWorkflow(Object.assign(Object.assign({ name: computedName, input: inputStr }, options), { additionalMetadata: (options === null || options === void 0 ? void 0 : options.additionalMetadata)
-                    ? JSON.stringify(options === null || options === void 0 ? void 0 : options.additionalMetadata)
-                    : undefined, priority: options === null || options === void 0 ? void 0 : options.priority }));
+            const opts = options !== null && options !== void 0 ? options : {};
+            const { additionalMetadata, parentStepRunId, parentTaskRunExternalId } = opts, rest = __rest(opts, ["additionalMetadata", "parentStepRunId", "parentTaskRunExternalId"]);
+            const resp = this.client.triggerWorkflow(Object.assign(Object.assign({ name: computedName, input: inputStr }, rest), { 
+                // API expects `parentTaskRunExternalId`; accept the old name as an alias.
+                parentTaskRunExternalId: parentTaskRunExternalId !== null && parentTaskRunExternalId !== void 0 ? parentTaskRunExternalId : parentStepRunId, additionalMetadata: additionalMetadata ? JSON.stringify(additionalMetadata) : undefined, priority: opts.priority }));
             return new workflow_run_ref_1.default(resp, this.listenerClient, this.workflows, options === null || options === void 0 ? void 0 : options.parentId);
         }
         catch (e) {
@@ -140,9 +153,9 @@ class AdminClient {
         const workflowRequests = workflowRuns.map(({ workflowName, input, options }) => {
             const computedName = (0, apply_namespace_1.applyNamespace)(workflowName, this.config.namespace);
             const inputStr = JSON.stringify(input);
-            return Object.assign(Object.assign({ name: computedName, input: inputStr }, options), { additionalMetadata: (options === null || options === void 0 ? void 0 : options.additionalMetadata)
-                    ? JSON.stringify(options.additionalMetadata)
-                    : undefined });
+            const opts = options !== null && options !== void 0 ? options : {};
+            const { additionalMetadata, parentStepRunId, parentTaskRunExternalId } = opts, rest = __rest(opts, ["additionalMetadata", "parentStepRunId", "parentTaskRunExternalId"]);
+            return Object.assign(Object.assign({ name: computedName, input: inputStr }, rest), { parentTaskRunExternalId: parentTaskRunExternalId !== null && parentTaskRunExternalId !== void 0 ? parentTaskRunExternalId : parentStepRunId, additionalMetadata: additionalMetadata ? JSON.stringify(additionalMetadata) : undefined });
         });
         try {
             // Call the bulk trigger workflow method

package/clients/dispatcher/action-listener.d.ts

@@ -7,8 +7,12 @@ declare enum ListenStrategy {
     LISTEN_STRATEGY_V1 = 1,
     LISTEN_STRATEGY_V2 = 2
 }
-export interface Action extends AssignedAction {
-}
+export type Action = AssignedAction & {
+    /** @deprecated use taskRunId */
+    stepRunId?: string;
+    /** @deprecated use taskId */
+    stepId?: string;
+};
 export type ActionKey = string;
 export declare function createActionKey(action: Action): ActionKey;
 export declare class ActionListener {

package/clients/dispatcher/action-listener.js

@@ -55,7 +55,7 @@ function createActionKey(action) {
         case dispatcher_1.ActionType.CANCEL_STEP_RUN:
         case dispatcher_1.ActionType.START_STEP_RUN:
         case dispatcher_1.ActionType.UNRECOGNIZED:
-            return `${action.stepRunId}/${action.retryCount}`;
+            return `${action.taskRunExternalId}/${action.retryCount}`;
         default:
             // eslint-disable-next-line no-case-declarations
             const exhaustivenessCheck = action.actionType;
@@ -84,7 +84,7 @@ class ActionListener {
                                 _c = listenClient_1_1.value;
                                 _d = false;
                                 const assignedAction = _c;
-                                const action = Object.assign({}, assignedAction);
+                                const action = Object.assign(Object.assign({}, assignedAction), { stepRunId: assignedAction.taskRunExternalId, stepId: assignedAction.taskId });
                                 yield yield __await(action);
                             }
                         }

package/clients/dispatcher/dispatcher-client.d.ts

@@ -11,6 +11,12 @@ interface GetActionListenerOptions {
     maxRuns?: number;
     labels: Record<string, string | number | undefined>;
 }
+type StepActionEventInput = StepActionEvent & {
+    /** @deprecated use taskId */
+    stepId?: string;
+    /** @deprecated use taskRunId */
+    stepRunId?: string;
+};
 export declare class DispatcherClient {
     config: ClientConfig;
     client: PbDispatcherClient;
@@ -18,10 +24,10 @@ export declare class DispatcherClient {
     constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
     getRuntimeInfo(): RuntimeInfo;
     getActionListener(options: GetActionListenerOptions): Promise<ActionListener>;
-    sendStepActionEvent(in_: StepActionEvent): Promise<import("../../protoc/dispatcher").ActionEventResponse>;
+    sendStepActionEvent(in_: StepActionEventInput): Promise<import("../../protoc/dispatcher").ActionEventResponse>;
     sendGroupKeyActionEvent(in_: GroupKeyActionEvent): Promise<import("../../protoc/dispatcher").ActionEventResponse>;
     putOverridesData(in_: DeepPartial<OverridesData>): Promise<void | import("../../protoc/dispatcher").OverridesDataResponse>;
-    refreshTimeout(incrementTimeoutBy: string, stepRunId: string): Promise<import("../../protoc/dispatcher").RefreshTimeoutResponse>;
+    refreshTimeout(incrementTimeoutBy: string, taskRunExternalId: string): Promise<import("../../protoc/dispatcher").RefreshTimeoutResponse>;
     upsertWorkerLabels(workerId: string, labels: WorkerLabels): Promise<import("../../protoc/dispatcher").UpsertWorkerLabelsResponse>;
 }
 export {};

package/clients/dispatcher/dispatcher-client.js

@@ -8,6 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -35,14 +46,17 @@ class DispatcherClient {
     getActionListener(options) {
         return __awaiter(this, void 0, void 0, function* () {
             // Register the worker
-            const registration = yield this.client.register(Object.assign(Object.assign({}, options), { labels: options.labels ? mapLabels(options.labels) : undefined, runtimeInfo: this.getRuntimeInfo() }));
+            const { maxRuns } = options, rest = __rest(options, ["maxRuns"]);
+            const registration = yield this.client.register(Object.assign(Object.assign({}, rest), { slots: maxRuns, labels: options.labels ? mapLabels(options.labels) : undefined, runtimeInfo: this.getRuntimeInfo() }));
             return new action_listener_1.ActionListener(this, registration.workerId);
         });
     }
     sendStepActionEvent(in_) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { taskId, taskRunExternalId } = in_, rest = __rest(in_, ["taskId", "taskRunExternalId"]);
+            const event = Object.assign(Object.assign({}, rest), { taskId: taskId !== null && taskId !== void 0 ? taskId : '', taskRunExternalId: taskRunExternalId !== null && taskRunExternalId !== void 0 ? taskRunExternalId : '' });
             try {
-                return yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.client.sendStepActionEvent(in_); }), this.logger);
+                return yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.client.sendStepActionEvent(event); }), this.logger);
             }
             catch (e) {
                 throw new hatchet_error_1.default(e.message);
@@ -66,11 +80,11 @@ class DispatcherClient {
             });
         });
     }
-    refreshTimeout(incrementTimeoutBy, stepRunId) {
+    refreshTimeout(incrementTimeoutBy, taskRunExternalId) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 return this.client.refreshTimeout({
-                    stepRunId,
+                    taskRunExternalId,
                     incrementTimeoutBy,
                 });
             }

package/clients/event/event-client.d.ts

@@ -32,7 +32,7 @@ export declare class EventClient {
     constructor(config: ClientConfig, channel: Channel, factory: ClientFactory, hatchetClient: LegacyHatchetClient);
     push<T>(type: string, input: T, options?: PushEventOptions): Promise<import("../../protoc/events/events").Event>;
     bulkPush<T>(type: string, inputs: EventWithMetadata<T>[], options?: PushEventOptions): Promise<import("../../protoc/events/events").Events>;
-    putLog(stepRunId: string, log: string, level?: LogLevel, taskRetryCount?: number, metadata?: Record<string, any>): Promise<void>;
-    putStream(stepRunId: string, data: string | Uint8Array, index: number | undefined): Promise<void>;
+    putLog(taskRunExternalId: string, log: string, level?: LogLevel, taskRetryCount?: number, metadata?: Record<string, any>): Promise<void>;
+    putStream(taskRunExternalId: string, data: string | Uint8Array, index: number | undefined): Promise<void>;
     list(opts?: Parameters<typeof this.api.v1EventList>[1]): Promise<import("../rest/generated/data-contracts").V1EventList>;
 }

package/clients/event/event-client.js

@@ -87,7 +87,7 @@ class EventClient {
             throw new hatchet_error_1.default(e.message);
         }
     }
-    putLog(stepRunId, log, level, taskRetryCount, metadata) {
+    putLog(taskRunExternalId, log, level, taskRetryCount, metadata) {
         return __awaiter(this, void 0, void 0, function* () {
             const createdAt = new Date();
             if (log.length > 1000) {
@@ -97,7 +97,7 @@ class EventClient {
             //  fire and forget the log
             yield this.client
                 .putLog({
-                stepRunId,
+                taskRunExternalId,
                 createdAt,
                 message: log,
                 level: level || LogLevel.INFO,
@@ -110,7 +110,7 @@ class EventClient {
             });
         });
     }
-    putStream(stepRunId, data, index) {
+    putStream(taskRunExternalId, data, index) {
         return __awaiter(this, void 0, void 0, function* () {
             const createdAt = new Date();
             let dataBytes;
@@ -125,7 +125,7 @@ class EventClient {
             }
             (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () {
                 return this.client.putStreamEvent({
-                    stepRunId,
+                    taskRunExternalId,
                     createdAt,
                     message: dataBytes,
                     eventIndex: index,

package/clients/hatchet-client/hatchet-logger.js

@@ -64,12 +64,12 @@ class HatchetLogger {
     }
     warn(message, error) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.log('WARN', `${message} ${error}`, '93');
+            yield this.log('WARN', error ? `${message} ${error}` : message, '93');
         });
     }
     error(message, error) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.log('ERROR', `${message} ${error}`, '91');
+            yield this.log('ERROR', error ? `${message} ${error}` : message, '91');
         });
     }
     util(key, message, extra) {

package/clients/rest/generated/data-contracts.d.ts

@@ -807,6 +807,10 @@ export interface V1Webhook {
     sourceName: V1WebhookSourceName;
     /** The CEL expression to use for the event key. This is used to create the event key from the webhook payload. */
     eventKeyExpression: string;
+    /** The CEL expression to use for the scope. This is used to filter the correct workflow to trigger. */
+    scopeExpression?: string;
+    /** The static payload to use for the webhook. This is used to send a static payload with the webhook. */
+    staticPayload?: object;
     /** The type of authentication to use for the webhook */
     authType: V1WebhookAuthType;
 }
@@ -821,6 +825,10 @@ export interface V1CreateWebhookRequestBase {
     name: string;
     /** The CEL expression to use for the event key. This is used to create the event key from the webhook payload. */
     eventKeyExpression: string;
+    /** The CEL expression to use for the scope. This is used to filter the correct workflow to trigger. */
+    scopeExpression?: string;
+    /** The static payload to use for the webhook. This is used to send a static payload with the webhook. */
+    staticPayload?: object;
 }
 export interface V1WebhookBasicAuth {
     /** The username for basic auth */
@@ -862,7 +870,11 @@ export type V1CreateWebhookRequestHMAC = V1CreateWebhookRequestBase & {
 export type V1CreateWebhookRequest = V1CreateWebhookRequestBasicAuth | V1CreateWebhookRequestAPIKey | V1CreateWebhookRequestHMAC;
 export interface V1UpdateWebhookRequest {
     /** The CEL expression to use for the event key. This is used to create the event key from the webhook payload. */
-    eventKeyExpression: string;
+    eventKeyExpression?: string;
+    /** The CEL expression to use for the scope. This is used to filter the correct workflow to trigger. */
+    scopeExpression?: string;
+    /** The static payload to use for the webhook. This is used to send a static payload with the webhook. */
+    staticPayload?: object;
 }
 export interface V1CELDebugRequest {
     /** The CEL expression to evaluate */

package/clients/worker/worker.js

@@ -187,7 +187,7 @@ class V0Worker {
                     return step(context);
                 });
                 const success = (result) => __awaiter(this, void 0, void 0, function* () {
-                    this.logger.info(`Task run ${action.stepRunId} succeeded`);
+                    this.logger.info(`Task run ${action.taskRunExternalId} succeeded`);
                     try {
                         // Send the action event to the dispatcher
                         const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_COMPLETED, false, result || null, action.retryCount);
@@ -212,7 +212,7 @@ class V0Worker {
                     }
                 });
                 const failure = (error) => __awaiter(this, void 0, void 0, function* () {
-                    this.logger.error(`Task run ${action.stepRunId} failed: ${error.message}`);
+                    this.logger.error(`Task run ${action.taskRunExternalId} failed: ${error.message}`);
                     if (error.stack) {
                         this.logger.error(error.stack);
                     }
@@ -257,10 +257,10 @@ class V0Worker {
                 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 ${action.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 ${action.taskRunExternalId} to finish. ` +
                             `See https://docs.hatchet.run/home/cancellation for best practices on handling cancellation: `, e);
                     }
                 }
@@ -291,7 +291,7 @@ class V0Worker {
                     return step(context);
                 });
                 const success = (result) => {
-                    this.logger.info(`Task run ${action.stepRunId} succeeded`);
+                    this.logger.info(`Task run ${action.taskRunExternalId} succeeded`);
                     try {
                         // Send the action event to the dispatcher
                         const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_COMPLETED, result);
@@ -345,8 +345,8 @@ class V0Worker {
             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,
@@ -371,9 +371,9 @@ class V0Worker {
     }
     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}`);
+                this.logger.info(`Cancelling task run ${action.taskRunExternalId}`);
                 const future = this.futures[(0, action_listener_1.createActionKey)(action)];
                 const context = this.contexts[(0, action_listener_1.createActionKey)(action)];
                 if (context && context.controller) {
@@ -381,7 +381,7 @@ class V0Worker {
                 }
                 if (future) {
                     future.promise.catch(() => {
-                        this.logger.info(`Cancelled task run ${action.stepRunId}`);
+                        this.logger.info(`Cancelled task run ${action.taskRunExternalId}`);
                     });
                     future.cancel('Cancelled by worker');
                     yield future.promise;
@@ -389,7 +389,7 @@ class V0Worker {
             }
             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[(0, action_listener_1.createActionKey)(action)];

package/examples/webhooks.d.ts

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

package/examples/webhooks.js

@@ -0,0 +1,45 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_1 = __importDefault(require("../sdk"));
+const data_contracts_1 = require("../clients/rest/generated/data-contracts");
+const hatchet = sdk_1.default.init();
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        const webhookName = `example-webhook-${Date.now()}`;
+        const namespace = (_b = (_a = hatchet.config) === null || _a === void 0 ? void 0 : _a.namespace) !== null && _b !== void 0 ? _b : 'default';
+        const webhook = yield hatchet.webhooks.create({
+            sourceName: data_contracts_1.V1WebhookSourceName.GENERIC,
+            name: webhookName,
+            eventKeyExpression: `'${namespace}/webhook:' + input.type`,
+            scopeExpression: 'input.customer_id',
+            staticPayload: { customer_id: 'cust-123', environment: 'production' },
+            auth: { username: 'test_user', password: 'test_password' },
+        });
+        console.log('Created webhook:', webhook.name, webhook.scopeExpression, webhook.staticPayload);
+        const one = yield hatchet.webhooks.get(webhook.name);
+        console.log('Get webhook:', one.name);
+        yield hatchet.webhooks.update(webhook.name, {
+            scopeExpression: 'input.environment',
+        });
+        const updated = yield hatchet.webhooks.get(webhook.name);
+        console.log('Updated scope expression:', updated.scopeExpression);
+        const list = yield hatchet.webhooks.list({ limit: 10, offset: 0 });
+        console.log('List webhooks:', (_d = (_c = list.rows) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0);
+        yield hatchet.webhooks.delete(webhook.name);
+        console.log('Deleted example webhook');
+    });
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.10.8",
+  "version": "1.12.0",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [

package/protoc/dispatcher/dispatcher.d.ts

@@ -82,8 +82,8 @@ export interface WorkerRegisterRequest {
     actions: string[];
     /** (optional) the services for this worker */
     services: string[];
-    /** (optional) the max number of runs this worker can handle */
-    maxRuns?: number | undefined;
+    /** (optional) the number of slots this worker can handle */
+    slots?: number | undefined;
     /** (optional) worker labels (i.e. state or other metadata) */
     labels: {
         [key: string]: WorkerLabels;
@@ -136,18 +136,18 @@ export interface AssignedAction {
     jobName: string;
     /** the job run id */
     jobRunId: string;
-    /** the step id */
-    stepId: string;
-    /** the step run id */
-    stepRunId: string;
+    /** the task id */
+    taskId: string;
+    /** the task external run id */
+    taskRunExternalId: string;
     /** the action id */
     actionId: string;
     /** the action type */
     actionType: ActionType;
     /** the action payload */
     actionPayload: string;
-    /** the step name */
-    stepName: string;
+    /** the task name */
+    taskName: string;
     /** the count number of the retry attempt */
     retryCount: number;
     /** (optional) additional metadata set on the workflow */
@@ -188,7 +188,7 @@ export interface GroupKeyActionEvent {
     /** the action id */
     actionId: string;
     eventTimestamp: Date | undefined;
-    /** the step event type */
+    /** the task event type */
     eventType: GroupKeyActionEventType;
     /** the event payload */
     eventPayload: string;
@@ -200,14 +200,14 @@ export interface StepActionEvent {
     jobId: string;
     /** the job run id */
     jobRunId: string;
-    /** the id of the step */
-    stepId: string;
-    /** the step run id */
-    stepRunId: string;
+    /** the id of the task */
+    taskId: string;
+    /** the task external run id */
+    taskRunExternalId: string;
     /** the action id */
     actionId: string;
     eventTimestamp: Date | undefined;
-    /** the step event type */
+    /** the task event type */
     eventType: StepActionEventType;
     /** the event payload */
     eventPayload: string;
@@ -248,9 +248,9 @@ export interface WorkflowEvent {
      * will hang up the connection but clients might want to case
      */
     hangup: boolean;
-    /** (optional) the max number of retries this step can handle */
-    stepRetries?: number | undefined;
-    /** (optional) the retry count of this step */
+    /** (optional) the max number of retries this task can handle */
+    taskRetries?: number | undefined;
+    /** (optional) the retry count of this task */
     retryCount?: number | undefined;
     eventIndex?: number | undefined;
 }
@@ -262,15 +262,15 @@ export interface WorkflowRunEvent {
     results: StepRunResult[];
 }
 export interface StepRunResult {
-    stepRunId: string;
-    stepReadableId: string;
+    taskRunExternalId: string;
+    taskName: string;
     jobRunId: string;
     error?: string | undefined;
     output?: string | undefined;
 }
 export interface OverridesData {
-    /** the step run id */
-    stepRunId: string;
+    /** the task run id */
+    taskRunExternalId: string;
     /** the path of the data to set */
     path: string;
     /** the value to set */
@@ -289,16 +289,16 @@ export interface HeartbeatRequest {
 export interface HeartbeatResponse {
 }
 export interface RefreshTimeoutRequest {
-    /** the id of the step run to release */
-    stepRunId: string;
+    /** the id of the task run to release */
+    taskRunExternalId: string;
     incrementTimeoutBy: string;
 }
 export interface RefreshTimeoutResponse {
     timeoutAt: Date | undefined;
 }
 export interface ReleaseSlotRequest {
-    /** the id of the step run to release */
-    stepRunId: string;
+    /** the id of the task run to release */
+    taskRunExternalId: string;
 }
 export interface ReleaseSlotResponse {
 }