@hatchet-dev/typescript-sdk 1.10.6 → 1.10.8

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(`Step run ${action.stepRunId} succeeded`);
+                    this.logger.info(`Task run ${action.stepRunId} 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(`Step run ${action.stepRunId} failed: ${error.message}`);
+                    this.logger.error(`Task run ${action.stepRunId} failed: ${error.message}`);
                     if (error.stack) {
                         this.logger.error(error.stack);
                     }
@@ -255,7 +255,14 @@ class V0Worker {
                     yield future.promise;
                 }
                 catch (e) {
-                    this.logger.error('Could not wait for step run to finish: ', 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`);
+                    }
+                    else {
+                        this.logger.error(`Could not wait for task run ${action.stepRunId} to finish. ` +
+                            `See https://docs.hatchet.run/home/cancellation for best practices on handling cancellation: `, e);
+                    }
                 }
             }
             catch (e) {
@@ -284,7 +291,7 @@ class V0Worker {
                     return step(context);
                 });
                 const success = (result) => {
-                    this.logger.info(`Step run ${action.stepRunId} succeeded`);
+                    this.logger.info(`Task run ${action.stepRunId} succeeded`);
                     try {
                         // Send the action event to the dispatcher
                         const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_COMPLETED, result);
@@ -302,7 +309,7 @@ class V0Worker {
                     }
                 };
                 const failure = (error) => {
-                    this.logger.error(`Step run ${key} failed: ${error.message}`);
+                    this.logger.error(`Task run ${key} failed: ${error.message}`);
                     try {
                         // Send the action event to the dispatcher
                         const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_FAILED, error);
@@ -366,7 +373,7 @@ class V0Worker {
         return __awaiter(this, void 0, void 0, function* () {
             const { stepRunId } = action;
             try {
-                this.logger.info(`Cancelling step run ${action.stepRunId}`);
+                this.logger.info(`Cancelling task run ${action.stepRunId}`);
                 const future = this.futures[(0, action_listener_1.createActionKey)(action)];
                 const context = this.contexts[(0, action_listener_1.createActionKey)(action)];
                 if (context && context.controller) {
@@ -374,14 +381,15 @@ class V0Worker {
                 }
                 if (future) {
                     future.promise.catch(() => {
-                        this.logger.info(`Cancelled step run ${action.stepRunId}`);
+                        this.logger.info(`Cancelled task run ${action.stepRunId}`);
                     });
                     future.cancel('Cancelled by worker');
                     yield future.promise;
                 }
             }
             catch (e) {
-                this.logger.error('Could not cancel step run: ', e);
+                // Expected: the promise rejects when cancelled
+                this.logger.debug(`Task run ${stepRunId} cancellation completed`);
             }
             finally {
                 delete this.futures[(0, action_listener_1.createActionKey)(action)];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.10.6",
+  "version": "1.10.8",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -65,7 +65,8 @@
     "qs": "^6.14.1",
     "semver": "^7.7.1",
     "yaml": "^2.7.1",
-    "zod": "^3.24.2"
+    "zod": "^3.24.2",
+    "zod-to-json-schema": "^3.24.1"
   },
   "optionalDependencies": {
     "prom-client": "^15.1.3"

package/protoc/v1/workflows.d.ts

@@ -21,6 +21,16 @@ export declare enum RateLimitDuration {
 }
 export declare function rateLimitDurationFromJSON(object: any): RateLimitDuration;
 export declare function rateLimitDurationToJSON(object: RateLimitDuration): string;
+export declare enum RunStatus {
+    QUEUED = 0,
+    RUNNING = 1,
+    COMPLETED = 2,
+    FAILED = 3,
+    CANCELLED = 4,
+    UNRECOGNIZED = -1
+}
+export declare function runStatusFromJSON(object: any): RunStatus;
+export declare function runStatusToJSON(object: RunStatus): string;
 export declare enum ConcurrencyLimitStrategy {
     CANCEL_IN_PROGRESS = 0,
     /** DROP_NEWEST - deprecated */
@@ -104,6 +114,8 @@ export interface CreateWorkflowVersionRequest {
     concurrencyArr: Concurrency[];
     /** (optional) the default filters for the workflow */
     defaultFilters: DefaultFilter[];
+    /** (optional) the JSON schema for the workflow input */
+    inputJsonSchema?: Uint8Array | undefined;
 }
 export interface DefaultFilter {
     /** (required) the CEL expression for the filter */
@@ -197,6 +209,40 @@ export interface CreateWorkflowVersionResponse {
     id: string;
     workflowId: string;
 }
+export interface GetRunDetailsRequest {
+    /** (required) the external id (uuid) of the workflow run */
+    externalId: string;
+}
+export interface TaskRunDetail {
+    /** the external id (uuid) of the task run */
+    externalId: string;
+    /** the status of the task run */
+    status: RunStatus;
+    /** (optional) error message from the task run, if any */
+    error?: string | undefined;
+    /** (optional) the output payload for the task run */
+    output?: Uint8Array | undefined;
+    /** the readable id of the task */
+    readableId: string;
+}
+export interface GetRunDetailsResponse {
+    /** the input payload for the workflow run */
+    input: Uint8Array;
+    /** the status of the workflow run */
+    status: RunStatus;
+    /** map of task run external ids to their details */
+    taskRuns: {
+        [key: string]: TaskRunDetail;
+    };
+    /** indicates if the workflow run is done */
+    done: boolean;
+    /** (optional) additional metadata for the workflow run */
+    additionalMetadata: Uint8Array;
+}
+export interface GetRunDetailsResponse_TaskRunsEntry {
+    key: string;
+    value: TaskRunDetail | undefined;
+}
 export declare const CancelTasksRequest: MessageFns<CancelTasksRequest>;
 export declare const ReplayTasksRequest: MessageFns<ReplayTasksRequest>;
 export declare const TasksFilter: MessageFns<TasksFilter>;
@@ -212,6 +258,10 @@ export declare const CreateTaskOpts: MessageFns<CreateTaskOpts>;
 export declare const CreateTaskOpts_WorkerLabelsEntry: MessageFns<CreateTaskOpts_WorkerLabelsEntry>;
 export declare const CreateTaskRateLimit: MessageFns<CreateTaskRateLimit>;
 export declare const CreateWorkflowVersionResponse: MessageFns<CreateWorkflowVersionResponse>;
+export declare const GetRunDetailsRequest: MessageFns<GetRunDetailsRequest>;
+export declare const TaskRunDetail: MessageFns<TaskRunDetail>;
+export declare const GetRunDetailsResponse: MessageFns<GetRunDetailsResponse>;
+export declare const GetRunDetailsResponse_TaskRunsEntry: MessageFns<GetRunDetailsResponse_TaskRunsEntry>;
 /** AdminService represents a set of RPCs for admin management of tasks, workflows, etc. */
 export type AdminServiceDefinition = typeof AdminServiceDefinition;
 export declare const AdminServiceDefinition: {
@@ -250,6 +300,14 @@ export declare const AdminServiceDefinition: {
             readonly responseStream: false;
             readonly options: {};
         };
+        readonly getRunDetails: {
+            readonly name: "GetRunDetails";
+            readonly requestType: MessageFns<GetRunDetailsRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<GetRunDetailsResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
     };
 };
 export interface AdminServiceImplementation<CallContextExt = {}> {
@@ -257,12 +315,14 @@ export interface AdminServiceImplementation<CallContextExt = {}> {
     cancelTasks(request: CancelTasksRequest, context: CallContext & CallContextExt): Promise<DeepPartial<CancelTasksResponse>>;
     replayTasks(request: ReplayTasksRequest, context: CallContext & CallContextExt): Promise<DeepPartial<ReplayTasksResponse>>;
     triggerWorkflowRun(request: TriggerWorkflowRunRequest, context: CallContext & CallContextExt): Promise<DeepPartial<TriggerWorkflowRunResponse>>;
+    getRunDetails(request: GetRunDetailsRequest, context: CallContext & CallContextExt): Promise<DeepPartial<GetRunDetailsResponse>>;
 }
 export interface AdminServiceClient<CallOptionsExt = {}> {
     putWorkflow(request: DeepPartial<CreateWorkflowVersionRequest>, options?: CallOptions & CallOptionsExt): Promise<CreateWorkflowVersionResponse>;
     cancelTasks(request: DeepPartial<CancelTasksRequest>, options?: CallOptions & CallOptionsExt): Promise<CancelTasksResponse>;
     replayTasks(request: DeepPartial<ReplayTasksRequest>, options?: CallOptions & CallOptionsExt): Promise<ReplayTasksResponse>;
     triggerWorkflowRun(request: DeepPartial<TriggerWorkflowRunRequest>, options?: CallOptions & CallOptionsExt): Promise<TriggerWorkflowRunResponse>;
+    getRunDetails(request: DeepPartial<GetRunDetailsRequest>, options?: CallOptions & CallOptionsExt): Promise<GetRunDetailsResponse>;
 }
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {

package/protoc/v1/workflows.js

@@ -5,11 +5,13 @@
 //   protoc               v3.19.1
 // source: v1/workflows.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdminServiceDefinition = exports.CreateWorkflowVersionResponse = exports.CreateTaskRateLimit = exports.CreateTaskOpts_WorkerLabelsEntry = exports.CreateTaskOpts = exports.DesiredWorkerLabels = exports.Concurrency = exports.DefaultFilter = exports.CreateWorkflowVersionRequest = exports.TriggerWorkflowRunResponse = exports.TriggerWorkflowRunRequest = exports.ReplayTasksResponse = exports.CancelTasksResponse = exports.TasksFilter = exports.ReplayTasksRequest = exports.CancelTasksRequest = exports.WorkerLabelComparator = exports.ConcurrencyLimitStrategy = exports.RateLimitDuration = exports.StickyStrategy = exports.protobufPackage = void 0;
+exports.AdminServiceDefinition = exports.GetRunDetailsResponse_TaskRunsEntry = exports.GetRunDetailsResponse = exports.TaskRunDetail = exports.GetRunDetailsRequest = exports.CreateWorkflowVersionResponse = exports.CreateTaskRateLimit = exports.CreateTaskOpts_WorkerLabelsEntry = exports.CreateTaskOpts = exports.DesiredWorkerLabels = exports.Concurrency = exports.DefaultFilter = exports.CreateWorkflowVersionRequest = exports.TriggerWorkflowRunResponse = exports.TriggerWorkflowRunRequest = exports.ReplayTasksResponse = exports.CancelTasksResponse = exports.TasksFilter = exports.ReplayTasksRequest = exports.CancelTasksRequest = exports.WorkerLabelComparator = exports.ConcurrencyLimitStrategy = exports.RunStatus = exports.RateLimitDuration = exports.StickyStrategy = exports.protobufPackage = void 0;
 exports.stickyStrategyFromJSON = stickyStrategyFromJSON;
 exports.stickyStrategyToJSON = stickyStrategyToJSON;
 exports.rateLimitDurationFromJSON = rateLimitDurationFromJSON;
 exports.rateLimitDurationToJSON = rateLimitDurationToJSON;
+exports.runStatusFromJSON = runStatusFromJSON;
+exports.runStatusToJSON = runStatusToJSON;
 exports.concurrencyLimitStrategyFromJSON = concurrencyLimitStrategyFromJSON;
 exports.concurrencyLimitStrategyToJSON = concurrencyLimitStrategyToJSON;
 exports.workerLabelComparatorFromJSON = workerLabelComparatorFromJSON;
@@ -111,6 +113,55 @@ function rateLimitDurationToJSON(object) {
             return 'UNRECOGNIZED';
     }
 }
+var RunStatus;
+(function (RunStatus) {
+    RunStatus[RunStatus["QUEUED"] = 0] = "QUEUED";
+    RunStatus[RunStatus["RUNNING"] = 1] = "RUNNING";
+    RunStatus[RunStatus["COMPLETED"] = 2] = "COMPLETED";
+    RunStatus[RunStatus["FAILED"] = 3] = "FAILED";
+    RunStatus[RunStatus["CANCELLED"] = 4] = "CANCELLED";
+    RunStatus[RunStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(RunStatus || (exports.RunStatus = RunStatus = {}));
+function runStatusFromJSON(object) {
+    switch (object) {
+        case 0:
+        case 'QUEUED':
+            return RunStatus.QUEUED;
+        case 1:
+        case 'RUNNING':
+            return RunStatus.RUNNING;
+        case 2:
+        case 'COMPLETED':
+            return RunStatus.COMPLETED;
+        case 3:
+        case 'FAILED':
+            return RunStatus.FAILED;
+        case 4:
+        case 'CANCELLED':
+            return RunStatus.CANCELLED;
+        case -1:
+        case 'UNRECOGNIZED':
+        default:
+            return RunStatus.UNRECOGNIZED;
+    }
+}
+function runStatusToJSON(object) {
+    switch (object) {
+        case RunStatus.QUEUED:
+            return 'QUEUED';
+        case RunStatus.RUNNING:
+            return 'RUNNING';
+        case RunStatus.COMPLETED:
+            return 'COMPLETED';
+        case RunStatus.FAILED:
+            return 'FAILED';
+        case RunStatus.CANCELLED:
+            return 'CANCELLED';
+        case RunStatus.UNRECOGNIZED:
+        default:
+            return 'UNRECOGNIZED';
+    }
+}
 var ConcurrencyLimitStrategy;
 (function (ConcurrencyLimitStrategy) {
     ConcurrencyLimitStrategy[ConcurrencyLimitStrategy["CANCEL_IN_PROGRESS"] = 0] = "CANCEL_IN_PROGRESS";
@@ -781,6 +832,7 @@ function createBaseCreateWorkflowVersionRequest() {
         defaultPriority: undefined,
         concurrencyArr: [],
         defaultFilters: [],
+        inputJsonSchema: undefined,
     };
 }
 exports.CreateWorkflowVersionRequest = {
@@ -824,6 +876,9 @@ exports.CreateWorkflowVersionRequest = {
         for (const v of message.defaultFilters) {
             exports.DefaultFilter.encode(v, writer.uint32(106).fork()).join();
         }
+        if (message.inputJsonSchema !== undefined) {
+            writer.uint32(114).bytes(message.inputJsonSchema);
+        }
         return writer;
     },
     decode(input, length) {
@@ -924,6 +979,13 @@ exports.CreateWorkflowVersionRequest = {
                     message.defaultFilters.push(exports.DefaultFilter.decode(reader, reader.uint32()));
                     continue;
                 }
+                case 14: {
+                    if (tag !== 114) {
+                        break;
+                    }
+                    message.inputJsonSchema = reader.bytes();
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -961,6 +1023,9 @@ exports.CreateWorkflowVersionRequest = {
             defaultFilters: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.defaultFilters)
                 ? object.defaultFilters.map((e) => exports.DefaultFilter.fromJSON(e))
                 : [],
+            inputJsonSchema: isSet(object.inputJsonSchema)
+                ? bytesFromBase64(object.inputJsonSchema)
+                : undefined,
         };
     },
     toJSON(message) {
@@ -1005,13 +1070,16 @@ exports.CreateWorkflowVersionRequest = {
         if ((_e = message.defaultFilters) === null || _e === void 0 ? void 0 : _e.length) {
             obj.defaultFilters = message.defaultFilters.map((e) => exports.DefaultFilter.toJSON(e));
         }
+        if (message.inputJsonSchema !== undefined) {
+            obj.inputJsonSchema = base64FromBytes(message.inputJsonSchema);
+        }
         return obj;
     },
     create(base) {
         return exports.CreateWorkflowVersionRequest.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         const message = createBaseCreateWorkflowVersionRequest();
         message.name = (_a = object.name) !== null && _a !== void 0 ? _a : '';
         message.description = (_b = object.description) !== null && _b !== void 0 ? _b : '';
@@ -1032,6 +1100,7 @@ exports.CreateWorkflowVersionRequest = {
         message.defaultPriority = (_j = object.defaultPriority) !== null && _j !== void 0 ? _j : undefined;
         message.concurrencyArr = ((_k = object.concurrencyArr) === null || _k === void 0 ? void 0 : _k.map((e) => exports.Concurrency.fromPartial(e))) || [];
         message.defaultFilters = ((_l = object.defaultFilters) === null || _l === void 0 ? void 0 : _l.map((e) => exports.DefaultFilter.fromPartial(e))) || [];
+        message.inputJsonSchema = (_m = object.inputJsonSchema) !== null && _m !== void 0 ? _m : undefined;
         return message;
     },
 };
@@ -1889,6 +1958,385 @@ exports.CreateWorkflowVersionResponse = {
         return message;
     },
 };
+function createBaseGetRunDetailsRequest() {
+    return { externalId: '' };
+}
+exports.GetRunDetailsRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.externalId !== '') {
+            writer.uint32(10).string(message.externalId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGetRunDetailsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.externalId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { externalId: isSet(object.externalId) ? globalThis.String(object.externalId) : '' };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.externalId !== '') {
+            obj.externalId = message.externalId;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.GetRunDetailsRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseGetRunDetailsRequest();
+        message.externalId = (_a = object.externalId) !== null && _a !== void 0 ? _a : '';
+        return message;
+    },
+};
+function createBaseTaskRunDetail() {
+    return { externalId: '', status: 0, error: undefined, output: undefined, readableId: '' };
+}
+exports.TaskRunDetail = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.externalId !== '') {
+            writer.uint32(10).string(message.externalId);
+        }
+        if (message.status !== 0) {
+            writer.uint32(16).int32(message.status);
+        }
+        if (message.error !== undefined) {
+            writer.uint32(26).string(message.error);
+        }
+        if (message.output !== undefined) {
+            writer.uint32(34).bytes(message.output);
+        }
+        if (message.readableId !== '') {
+            writer.uint32(42).string(message.readableId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTaskRunDetail();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.externalId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.status = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.error = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.output = reader.bytes();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.readableId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            externalId: isSet(object.externalId) ? globalThis.String(object.externalId) : '',
+            status: isSet(object.status) ? runStatusFromJSON(object.status) : 0,
+            error: isSet(object.error) ? globalThis.String(object.error) : undefined,
+            output: isSet(object.output) ? bytesFromBase64(object.output) : undefined,
+            readableId: isSet(object.readableId) ? globalThis.String(object.readableId) : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.externalId !== '') {
+            obj.externalId = message.externalId;
+        }
+        if (message.status !== 0) {
+            obj.status = runStatusToJSON(message.status);
+        }
+        if (message.error !== undefined) {
+            obj.error = message.error;
+        }
+        if (message.output !== undefined) {
+            obj.output = base64FromBytes(message.output);
+        }
+        if (message.readableId !== '') {
+            obj.readableId = message.readableId;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.TaskRunDetail.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c, _d, _e;
+        const message = createBaseTaskRunDetail();
+        message.externalId = (_a = object.externalId) !== null && _a !== void 0 ? _a : '';
+        message.status = (_b = object.status) !== null && _b !== void 0 ? _b : 0;
+        message.error = (_c = object.error) !== null && _c !== void 0 ? _c : undefined;
+        message.output = (_d = object.output) !== null && _d !== void 0 ? _d : undefined;
+        message.readableId = (_e = object.readableId) !== null && _e !== void 0 ? _e : '';
+        return message;
+    },
+};
+function createBaseGetRunDetailsResponse() {
+    return {
+        input: new Uint8Array(0),
+        status: 0,
+        taskRuns: {},
+        done: false,
+        additionalMetadata: new Uint8Array(0),
+    };
+}
+exports.GetRunDetailsResponse = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.input.length !== 0) {
+            writer.uint32(10).bytes(message.input);
+        }
+        if (message.status !== 0) {
+            writer.uint32(16).int32(message.status);
+        }
+        Object.entries(message.taskRuns).forEach(([key, value]) => {
+            exports.GetRunDetailsResponse_TaskRunsEntry.encode({ key: key, value }, writer.uint32(26).fork()).join();
+        });
+        if (message.done !== false) {
+            writer.uint32(32).bool(message.done);
+        }
+        if (message.additionalMetadata.length !== 0) {
+            writer.uint32(42).bytes(message.additionalMetadata);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGetRunDetailsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.input = reader.bytes();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.status = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    const entry3 = exports.GetRunDetailsResponse_TaskRunsEntry.decode(reader, reader.uint32());
+                    if (entry3.value !== undefined) {
+                        message.taskRuns[entry3.key] = entry3.value;
+                    }
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.done = reader.bool();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.additionalMetadata = reader.bytes();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            input: isSet(object.input) ? bytesFromBase64(object.input) : new Uint8Array(0),
+            status: isSet(object.status) ? runStatusFromJSON(object.status) : 0,
+            taskRuns: isObject(object.taskRuns)
+                ? Object.entries(object.taskRuns).reduce((acc, [key, value]) => {
+                    acc[key] = exports.TaskRunDetail.fromJSON(value);
+                    return acc;
+                }, {})
+                : {},
+            done: isSet(object.done) ? globalThis.Boolean(object.done) : false,
+            additionalMetadata: isSet(object.additionalMetadata)
+                ? bytesFromBase64(object.additionalMetadata)
+                : new Uint8Array(0),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.input.length !== 0) {
+            obj.input = base64FromBytes(message.input);
+        }
+        if (message.status !== 0) {
+            obj.status = runStatusToJSON(message.status);
+        }
+        if (message.taskRuns) {
+            const entries = Object.entries(message.taskRuns);
+            if (entries.length > 0) {
+                obj.taskRuns = {};
+                entries.forEach(([k, v]) => {
+                    obj.taskRuns[k] = exports.TaskRunDetail.toJSON(v);
+                });
+            }
+        }
+        if (message.done !== false) {
+            obj.done = message.done;
+        }
+        if (message.additionalMetadata.length !== 0) {
+            obj.additionalMetadata = base64FromBytes(message.additionalMetadata);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.GetRunDetailsResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c, _d, _e;
+        const message = createBaseGetRunDetailsResponse();
+        message.input = (_a = object.input) !== null && _a !== void 0 ? _a : new Uint8Array(0);
+        message.status = (_b = object.status) !== null && _b !== void 0 ? _b : 0;
+        message.taskRuns = Object.entries((_c = object.taskRuns) !== null && _c !== void 0 ? _c : {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = exports.TaskRunDetail.fromPartial(value);
+            }
+            return acc;
+        }, {});
+        message.done = (_d = object.done) !== null && _d !== void 0 ? _d : false;
+        message.additionalMetadata = (_e = object.additionalMetadata) !== null && _e !== void 0 ? _e : new Uint8Array(0);
+        return message;
+    },
+};
+function createBaseGetRunDetailsResponse_TaskRunsEntry() {
+    return { key: '', value: undefined };
+}
+exports.GetRunDetailsResponse_TaskRunsEntry = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.key !== '') {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== undefined) {
+            exports.TaskRunDetail.encode(message.value, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGetRunDetailsResponse_TaskRunsEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.key = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value = exports.TaskRunDetail.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : '',
+            value: isSet(object.value) ? exports.TaskRunDetail.fromJSON(object.value) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== '') {
+            obj.key = message.key;
+        }
+        if (message.value !== undefined) {
+            obj.value = exports.TaskRunDetail.toJSON(message.value);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.GetRunDetailsResponse_TaskRunsEntry.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseGetRunDetailsResponse_TaskRunsEntry();
+        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : '';
+        message.value =
+            object.value !== undefined && object.value !== null
+                ? exports.TaskRunDetail.fromPartial(object.value)
+                : undefined;
+        return message;
+    },
+};
 exports.AdminServiceDefinition = {
     name: 'AdminService',
     fullName: 'v1.AdminService',
@@ -1925,6 +2373,14 @@ exports.AdminServiceDefinition = {
             responseStream: false,
             options: {},
         },
+        getRunDetails: {
+            name: 'GetRunDetails',
+            requestType: exports.GetRunDetailsRequest,
+            requestStream: false,
+            responseType: exports.GetRunDetailsResponse,
+            responseStream: false,
+            options: {},
+        },
     },
 };
 function bytesFromBase64(b64) {

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

@@ -28,6 +28,7 @@ const hatchet_promise_1 = __importDefault(require("../../../util/hatchet-promise
 const workflows_1 = require("../../../protoc/workflows");
 const task_1 = require("../../task");
 const transformer_1 = require("../../conditions/transformer");
+const zod_to_json_schema_1 = require("zod-to-json-schema");
 const step_1 = require("../../../step");
 const apply_namespace_1 = require("../../../util/apply-namespace");
 const context_1 = require("./context");
@@ -244,6 +245,13 @@ class V1Worker {
                 ];
                 const concurrencyArr = Array.isArray(concurrency) ? concurrency : [];
                 const concurrencySolo = !Array.isArray(concurrency) ? concurrency : undefined;
+                // Convert Zod schema to JSON Schema if provided
+                let inputJsonSchema;
+                if (workflow.inputValidator) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const jsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(workflow.inputValidator);
+                    inputJsonSchema = new TextEncoder().encode(JSON.stringify(jsonSchema));
+                }
                 const registeredWorkflow = this.client._v0.admin.putWorkflowV1({
                     name: workflow.name,
                     description: workflow.description || '',
@@ -254,6 +262,7 @@ class V1Worker {
                     concurrencyArr,
                     onFailureTask,
                     defaultPriority: workflow.defaultPriority,
+                    inputJsonSchema,
                     tasks: [...workflow._tasks, ...workflow._durableTasks].map((task) => {
                         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
                         return ({
@@ -414,7 +423,7 @@ class V1Worker {
                         if (context.cancelled) {
                             return;
                         }
-                        this.logger.info(`Step run ${action.stepRunId} succeeded`);
+                        this.logger.info(`Task run ${action.stepRunId} 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);
@@ -443,7 +452,7 @@ class V1Worker {
                         if (context.cancelled) {
                             return;
                         }
-                        this.logger.error(`Step run ${action.stepRunId} failed: ${error.message}`);
+                        this.logger.error(`Task run ${action.stepRunId} failed: ${error.message}`);
                         if (error.stack) {
                             this.logger.error(error.stack);
                         }
@@ -484,7 +493,14 @@ class V1Worker {
                     yield future.promise;
                 }
                 catch (e) {
-                    this.logger.error('Could not wait for step run to finish: ', 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`);
+                    }
+                    else {
+                        this.logger.error(`Could not wait for task run ${action.stepRunId} to finish. ` +
+                            `See https://docs.hatchet.run/home/cancellation for best practices on handling cancellation: `, e);
+                    }
                 }
             }
             catch (e) {
@@ -514,7 +530,7 @@ class V1Worker {
                     return step(context);
                 });
                 const success = (result) => {
-                    this.logger.info(`Step run ${action.stepRunId} succeeded`);
+                    this.logger.info(`Task run ${action.stepRunId} succeeded`);
                     try {
                         // Send the action event to the dispatcher
                         const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_COMPLETED, result);
@@ -532,7 +548,7 @@ class V1Worker {
                     }
                 };
                 const failure = (error) => {
-                    this.logger.error(`Step run ${key} failed: ${error.message}`);
+                    this.logger.error(`Task run ${key} failed: ${error.message}`);
                     try {
                         // Send the action event to the dispatcher
                         const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_FAILED, error);
@@ -596,7 +612,7 @@ class V1Worker {
         return __awaiter(this, void 0, void 0, function* () {
             const { stepRunId } = action;
             try {
-                this.logger.info(`Cancelling step run ${action.stepRunId}`);
+                this.logger.info(`Cancelling task run ${action.stepRunId}`);
                 const future = this.futures[stepRunId];
                 const context = this.contexts[stepRunId];
                 if (context && context.abortController) {
@@ -604,14 +620,15 @@ class V1Worker {
                 }
                 if (future) {
                     future.promise.catch(() => {
-                        this.logger.info(`Cancelled step run ${action.stepRunId}`);
+                        this.logger.info(`Cancelled task run ${action.stepRunId}`);
                     });
                     future.cancel('Cancelled by worker');
                     yield future.promise;
                 }
             }
             catch (e) {
-                this.logger.error('Could not cancel step run: ', e);
+                // Expected: the promise rejects when cancelled
+                this.logger.debug(`Task run ${stepRunId} cancellation completed`);
             }
             finally {
                 delete this.futures[stepRunId];

package/v1/declaration.d.ts

@@ -1,6 +1,7 @@
 import WorkflowRunRef from '../util/workflow-run-ref';
 import { CronWorkflows, ScheduledWorkflows, V1CreateFilterRequest } from '../clients/rest/generated/data-contracts';
 import { Workflow as WorkflowV0 } from '../workflow';
+import { z } from 'zod';
 import { IHatchetClient } from './client/client.interface';
 import { CreateWorkflowTaskOpts, CreateOnFailureTaskOpts, TaskFn, CreateWorkflowDurableTaskOpts, CreateBaseTaskOpts, CreateOnSuccessTaskOpts, Concurrency, DurableTaskFn } from './task';
 import { Duration } from './client/duration';
@@ -90,6 +91,12 @@ export type CreateBaseWorkflowOpts = {
      */
     defaultPriority?: Priority;
     defaultFilters?: DefaultFilter[];
+    /**
+     * (optional) Zod schema for the workflow input.
+     * When provided, a JSON Schema is generated and sent to the Hatchet backend, which
+     * can be used on the dashboard for autocomplete.
+     */
+    inputValidator?: z.ZodType<any>;
 };
 export type CreateTaskWorkflowOpts<I extends InputType = UnknownInputType, O extends OutputType = void> = CreateBaseWorkflowOpts & CreateBaseTaskOpts<I, O, TaskFn<I, O>>;
 export type CreateDurableTaskWorkflowOpts<I extends InputType = UnknownInputType, O extends OutputType = void> = CreateBaseWorkflowOpts & CreateBaseTaskOpts<I, O, DurableTaskFn<I, O>>;
@@ -363,7 +370,8 @@ export declare function CreateTaskWorkflow<Fn extends (input: I, ctx?: any) => O
  * Creates a new workflow instance.
  * @template I The input type for the workflow.
  * @template O The return type of the workflow.
- * @param options The options for creating the workflow.
+ * @param options The options for creating the workflow. Optionally include a Zod schema
+ *                via the `input` field to generate a JSON Schema for the backend.
  * @param client Optional Hatchet client instance.
  * @returns A new Workflow instance.
  */

package/v1/declaration.js

@@ -360,7 +360,8 @@ function CreateTaskWorkflow(options, client) {
  * Creates a new workflow instance.
  * @template I The input type for the workflow.
  * @template O The return type of the workflow.
- * @param options The options for creating the workflow.
+ * @param options The options for creating the workflow. Optionally include a Zod schema
+ *                via the `input` field to generate a JSON Schema for the backend.
  * @param client Optional Hatchet client instance.
  * @returns A new Workflow instance.
  */

package/v1/examples/simple/worker.js

@@ -13,11 +13,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const hatchet_client_1 = require("../hatchet-client");
 const workflow_1 = require("./workflow");
 const workflow_with_child_1 = require("./workflow-with-child");
+const zod_1 = require("./zod");
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         const worker = yield hatchet_client_1.hatchet.worker('simple-worker', {
             // 👀 Declare the workflows that the worker can execute
-            workflows: [workflow_1.simple, workflow_with_child_1.parent, workflow_with_child_1.child],
+            workflows: [workflow_1.simple, zod_1.simpleWithZod, workflow_with_child_1.parent, workflow_with_child_1.child],
             // 👀 Declare the number of concurrent task runs the worker can accept
             slots: 100,
         });

package/v1/examples/simple/zod.d.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+declare const SimpleInputSchema: z.ZodObject<{
+    Message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    Message: string;
+}, {
+    Message: string;
+}>;
+export type SimpleInputWithZod = z.infer<typeof SimpleInputSchema>;
+export declare const simpleWithZod: import("../..").TaskWorkflowDeclaration<{
+    Message: string;
+}, {
+    TransformedMessage: string;
+}>;
+export {};

package/v1/examples/simple/zod.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleWithZod = void 0;
+// > Declaring a Task
+const z = __importStar(require("zod"));
+const hatchet_client_1 = require("../hatchet-client");
+const SimpleInputSchema = z.object({
+    Message: z.string(),
+});
+exports.simpleWithZod = hatchet_client_1.hatchet.task({
+    name: 'simple-with-zod',
+    retries: 3,
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        return {
+            TransformedMessage: input.Message.toLowerCase(),
+        };
+    }),
+    inputValidator: SimpleInputSchema,
+});
+// !!
+// see ./worker.ts and ./run.ts for how to run the workflow

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.10.6";
+export declare const HATCHET_VERSION = "1.10.8";

package/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HATCHET_VERSION = void 0;
-exports.HATCHET_VERSION = '1.10.6';
+exports.HATCHET_VERSION = '1.10.8';