@hatchet-dev/typescript-sdk 1.0.3 → 1.0.5

package/clients/dispatcher/heartbeat/heartbeat-controller.d.ts

@@ -3,6 +3,11 @@ import { DispatcherClient as PbDispatcherClient } from '../../../protoc/dispatch
 import { Worker } from 'worker_threads';
 import { ClientConfig } from '../../hatchet-client';
 import { DispatcherClient } from '../dispatcher-client';
+export interface HeartbeatMessage {
+    type: 'info' | 'warn' | 'error' | 'debug';
+    message: string;
+}
+export declare const STOP_HEARTBEAT = "stop";
 export declare class Heartbeat {
     config: ClientConfig;
     client: PbDispatcherClient;

package/clients/dispatcher/heartbeat/heartbeat-controller.js

@@ -12,9 +12,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Heartbeat = void 0;
+exports.Heartbeat = exports.STOP_HEARTBEAT = void 0;
 const path_1 = __importDefault(require("path"));
 const thread_helper_1 = require("../../../util/thread-helper");
+exports.STOP_HEARTBEAT = 'stop';
 class Heartbeat {
     constructor(client, workerId) {
         this.config = client.config;
@@ -31,13 +32,16 @@ class Heartbeat {
                         workerId: this.workerId,
                     },
                 });
+                this.heartbeatWorker.on('message', (message) => {
+                    this.logger[message.type](message.message);
+                });
             }
         });
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
-            (_a = this.heartbeatWorker) === null || _a === void 0 ? void 0 : _a.postMessage('stop');
+            (_a = this.heartbeatWorker) === null || _a === void 0 ? void 0 : _a.postMessage(exports.STOP_HEARTBEAT);
             (_b = this.heartbeatWorker) === null || _b === void 0 ? void 0 : _b.terminate();
             this.heartbeatWorker = undefined;
         });

package/clients/dispatcher/heartbeat/heartbeat-worker.js

@@ -14,16 +14,25 @@ const hatchet_client_1 = require("../../hatchet-client");
 const config_loader_1 = require("../../../util/config-loader");
 const nice_grpc_1 = require("nice-grpc");
 const dispatcher_client_1 = require("../dispatcher-client");
+const heartbeat_controller_1 = require("./heartbeat-controller");
 const HEARTBEAT_INTERVAL = 4000;
+const postMessage = (message) => {
+    worker_threads_1.parentPort === null || worker_threads_1.parentPort === void 0 ? void 0 : worker_threads_1.parentPort.postMessage(message);
+};
 class HeartbeatWorker {
     constructor(config, workerId) {
         this.timeLastHeartbeat = new Date().getTime();
         this.workerId = workerId;
-        this.logger = new hatchet_client_1.HatchetLogger(`Heartbeat`, config.log_level);
+        this.logger = new hatchet_client_1.HatchetLogger(`HeartbeatThread`, config.log_level);
+        this.logger.debug('Heartbeat thread starting...');
         const credentials = config_loader_1.ConfigLoader.createCredentials(config.tls_config);
         const clientFactory = (0, nice_grpc_1.createClientFactory)().use((0, hatchet_client_1.addTokenMiddleware)(config.token));
         const dispatcher = new dispatcher_client_1.DispatcherClient(Object.assign(Object.assign({}, config), { logger: (ctx, level) => new hatchet_client_1.HatchetLogger(ctx, level) }), (0, hatchet_client_1.channelFactory)(config, credentials), clientFactory);
         this.client = dispatcher.client;
+        postMessage({
+            type: 'debug',
+            message: 'Heartbeat thread started.',
+        });
     }
     start() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -33,6 +42,10 @@ class HeartbeatWorker {
             const beat = () => __awaiter(this, void 0, void 0, function* () {
                 try {
                     this.logger.debug('Heartbeat sending...');
+                    postMessage({
+                        type: 'debug',
+                        message: 'Heartbeat sending...',
+                    });
                     yield this.client.heartbeat({
                         workerId: this.workerId,
                         heartbeatAt: new Date(),
@@ -40,19 +53,38 @@ class HeartbeatWorker {
                     const now = new Date().getTime();
                     const actualInterval = now - this.timeLastHeartbeat;
                     if (actualInterval > HEARTBEAT_INTERVAL * 1.2) {
-                        this.logger.warn(`Heartbeat interval delay (${actualInterval}ms >> ${HEARTBEAT_INTERVAL}ms)`);
+                        const message = `Heartbeat interval delay (${actualInterval}ms >> ${HEARTBEAT_INTERVAL}ms)`;
+                        this.logger.warn(message);
+                        postMessage({
+                            type: 'warn',
+                            message,
+                        });
                     }
                     this.logger.debug(`Heartbeat sent ${actualInterval}ms ago`);
+                    postMessage({
+                        type: 'debug',
+                        message: `Heartbeat sent ${actualInterval}ms ago`,
+                    });
                     this.timeLastHeartbeat = now;
                 }
                 catch (e) {
                     if (e.code === nice_grpc_1.Status.UNIMPLEMENTED) {
                         // break out of interval
-                        this.logger.error('Heartbeat not implemented, closing heartbeat');
+                        const message = 'Heartbeat not implemented, closing heartbeat';
+                        this.logger.debug(message);
+                        postMessage({
+                            type: 'error',
+                            message,
+                        });
                         this.stop();
                         return;
                     }
-                    this.logger.error(`Failed to send heartbeat: ${e.message}`);
+                    const message = `Failed to send heartbeat: ${e.message}`;
+                    this.logger.debug(message);
+                    postMessage({
+                        type: 'error',
+                        message,
+                    });
                 }
             });
             // start with a heartbeat
@@ -69,6 +101,6 @@ class HeartbeatWorker {
 }
 const heartbeat = new HeartbeatWorker(worker_threads_1.workerData.config, worker_threads_1.workerData.workerId);
 heartbeat.start();
-worker_threads_1.parentPort === null || worker_threads_1.parentPort === void 0 ? void 0 : worker_threads_1.parentPort.on('stop', () => {
+worker_threads_1.parentPort === null || worker_threads_1.parentPort === void 0 ? void 0 : worker_threads_1.parentPort.on(heartbeat_controller_1.STOP_HEARTBEAT, () => {
     heartbeat.stop();
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -70,7 +70,8 @@
   "author": "",
   "license": "MIT",
   "devDependencies": {
-    "@types/jest": "^29.5.11",
+    "@tsd/typescript": "^5.8.2",
+    "@types/jest": "^29.5.14",
     "@types/node": "^22.0.0",
     "@typescript-eslint/eslint-plugin": "^6.4.0",
     "autoprefixer": "^10.4.16",
@@ -91,6 +92,7 @@
     "eslint-plugin-unused-imports": "^4.1.3",
     "grpc-tools": "^1.12.4",
     "jest": "^29.7.0",
+    "jest-tsd": "^0.2.2",
     "pino": "^9.6.0",
     "prettier": "^3.1.1",
     "resolve-tspaths": "^0.8.17",

package/step.d.ts

@@ -9,9 +9,10 @@ import { V0Worker } from './clients/worker';
 import { WorkerLabels } from './clients/dispatcher/dispatcher-client';
 import { CreateStepRateLimit, RateLimitDuration, WorkerLabelComparator } from './protoc/workflows';
 import { CreateWorkflowTaskOpts } from './v1/task';
-import { BaseWorkflowDeclaration as WorkflowV1 } from './v1/declaration';
+import { TaskWorkflowDeclaration, BaseWorkflowDeclaration as WorkflowV1 } from './v1/declaration';
 import { Conditions } from './v1/conditions';
 import { Duration } from './v1/client/duration';
+import { JsonObject, JsonValue, OutputType } from './v1/types';
 export declare const CreateRateLimitSchema: z.ZodObject<{
     key: z.ZodOptional<z.ZodString>;
     staticKey: z.ZodOptional<z.ZodString>;
@@ -150,14 +151,6 @@ export declare const CreateStepSchema: z.ZodObject<{
         maxSeconds?: number | undefined;
     } | undefined;
 }>;
-export type JsonObject = {
-    [Key in string]: JsonValue;
-} & {
-    [Key in string]?: JsonValue | undefined;
-};
-export type JsonArray = JsonValue[] | readonly JsonValue[];
-export type JsonPrimitive = string | number | boolean | null;
-export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
 export type NextStep = {
     [key: string]: JsonValue;
 };
@@ -211,12 +204,11 @@ export declare class Context<T, K = {}> {
     get cancelled(): boolean;
     /**
      * Retrieves the output of a parent task.
-     * @param task - The name of the task or a CreateTaskOpts object.
+     * @param parentTask - The a CreateTaskOpts or string of the parent task name.
      * @returns The output of the specified parent task.
      * @throws An error if the task output is not found.
-     *
      */
-    parentOutput<L = NextStep>(task: CreateWorkflowTaskOpts<any, L> | string): Promise<L>;
+    parentOutput<L extends OutputType>(parentTask: CreateWorkflowTaskOpts<any, L> | string): Promise<L>;
     /**
      * Get the output of a task.
      * @param task - The name of the task to get the output for.
@@ -229,7 +221,7 @@ export declare class Context<T, K = {}> {
      * Returns errors from any task runs in the workflow.
      * @returns A record mapping task names to error messages.
      * @throws A warning if no errors are found (this method should be used in on-failure tasks).
-     * @deprecated use ctx.errors instead
+     * @deprecated use ctx.errors() instead
      */
     stepRunErrors(): Record<string, string>;
     /**
@@ -251,6 +243,7 @@ export declare class Context<T, K = {}> {
     /**
      * Gets the input data for the current workflow.
      * @returns The input data for the workflow.
+     * @deprecated use task input parameter instead
      */
     workflowInput(): T;
     /**
@@ -279,6 +272,11 @@ export declare class Context<T, K = {}> {
      * @returns The workflow run ID.
      */
     workflowRunId(): string;
+    /**
+     * Gets the ID of the current task run.
+     * @returns The task run ID.
+     */
+    taskRunId(): string;
     /**
      * Gets the number of times the current task has been retried.
      * @returns The retry count.
@@ -357,10 +355,10 @@ export declare class Context<T, K = {}> {
      *
      * @param workflow - The workflow to run (name, Workflow instance, or WorkflowV1 instance).
      * @param input - The input data for the workflow.
-     * @param options - Additional options for spawning the workflow. If a string is provided, it is used as the key.
+     * @param optionsOrKey - Either a string key or an options object containing key, sticky, and additionalMetadata.
      * @returns The result of the workflow.
      */
-    runChild<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P>, input: Q, options?: string | {
+    runChild<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P> | TaskWorkflowDeclaration<Q, P>, input: Q, optionsOrKey?: string | {
         key?: string;
         sticky?: boolean;
         additionalMetadata?: Record<string, string>;
@@ -370,10 +368,10 @@ export declare class Context<T, K = {}> {
      *
      * @param workflow - The workflow to enqueue (name, Workflow instance, or WorkflowV1 instance).
      * @param input - The input data for the workflow.
-     * @param options - Additional options for spawning the workflow.
+     * @param optionsOrKey - Either a string key or an options object containing key, sticky, and additionalMetadata.
      * @returns A reference to the spawned workflow run.
      */
-    runNoWaitChild<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P>, input: Q, options?: string | {
+    runNoWaitChild<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P>, input: Q, optionsOrKey?: string | {
         key?: string;
         sticky?: boolean;
         additionalMetadata?: Record<string, string>;
@@ -387,7 +385,7 @@ export declare class Context<T, K = {}> {
      * @returns A reference to the spawned workflow run.
      * @deprecated Use runChild or runNoWaitChild instead.
      */
-    spawnWorkflow<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P>, input: Q, options?: string | {
+    spawnWorkflow<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P> | TaskWorkflowDeclaration<Q, P>, input: Q, options?: string | {
         key?: string;
         sticky?: boolean;
         additionalMetadata?: Record<string, string>;

package/step.js

@@ -52,6 +52,7 @@ const hatchet_error_1 = __importDefault(require("./util/errors/hatchet-error"));
 const z = __importStar(require("zod"));
 const parse_1 = require("./util/parse");
 const workflows_1 = require("./protoc/workflows");
+const declaration_1 = require("./v1/declaration");
 const conditions_1 = require("./v1/conditions");
 const condition_1 = require("./protoc/v1/shared/condition");
 const transformer_1 = require("./v1/conditions/transformer");
@@ -162,18 +163,17 @@ class Context {
     }
     /**
      * Retrieves the output of a parent task.
-     * @param task - The name of the task or a CreateTaskOpts object.
+     * @param parentTask - The a CreateTaskOpts or string of the parent task name.
      * @returns The output of the specified parent task.
      * @throws An error if the task output is not found.
-     *
      */
-    parentOutput(task) {
+    parentOutput(parentTask) {
         return __awaiter(this, void 0, void 0, function* () {
             // NOTE: parentOutput is async since we plan on potentially making this a cacheable server call
-            if (typeof task === 'string') {
-                return this.stepOutput(task);
+            if (typeof parentTask === 'string') {
+                return this.stepOutput(parentTask);
             }
-            return this.stepOutput(task.name);
+            return this.stepOutput(parentTask.name);
         });
     }
     /**
@@ -185,10 +185,10 @@ class Context {
      */
     stepOutput(step) {
         if (!this.data.parents) {
-            throw new hatchet_error_1.default('output not found');
+            throw new hatchet_error_1.default('Parent task outputs not found');
         }
         if (!this.data.parents[step]) {
-            throw new hatchet_error_1.default(`output for '${step}' not found`);
+            throw new hatchet_error_1.default(`Output for parent task '${step}' not found`);
         }
         return this.data.parents[step];
     }
@@ -196,7 +196,7 @@ class Context {
      * Returns errors from any task runs in the workflow.
      * @returns A record mapping task names to error messages.
      * @throws A warning if no errors are found (this method should be used in on-failure tasks).
-     * @deprecated use ctx.errors instead
+     * @deprecated use ctx.errors() instead
      */
     stepRunErrors() {
         return this.errors();
@@ -231,6 +231,7 @@ class Context {
     /**
      * Gets the input data for the current workflow.
      * @returns The input data for the workflow.
+     * @deprecated use task input parameter instead
      */
     workflowInput() {
         return this.input;
@@ -272,6 +273,13 @@ class Context {
     workflowRunId() {
         return this.action.workflowRunId;
     }
+    /**
+     * Gets the ID of the current task run.
+     * @returns The task run ID.
+     */
+    taskRunId() {
+        return this.action.stepRunId;
+    }
     /**
      * Gets the number of times the current task has been retried.
      * @returns The retry count.
@@ -353,7 +361,14 @@ class Context {
     bulkRunChildren(children) {
         return __awaiter(this, void 0, void 0, function* () {
             const runs = yield this.bulkRunNoWaitChildren(children);
-            const res = runs.map((run) => run.output);
+            const res = runs.map((run, index) => {
+                const wf = children[index].workflow;
+                if (wf instanceof declaration_1.TaskWorkflowDeclaration) {
+                    // eslint-disable-next-line no-underscore-dangle
+                    return run.output[wf._standalone_task_name];
+                }
+                return run.output;
+            });
             return Promise.all(res);
         });
     }
@@ -414,12 +429,19 @@ class Context {
      *
      * @param workflow - The workflow to run (name, Workflow instance, or WorkflowV1 instance).
      * @param input - The input data for the workflow.
-     * @param options - Additional options for spawning the workflow. If a string is provided, it is used as the key.
+     * @param optionsOrKey - Either a string key or an options object containing key, sticky, and additionalMetadata.
      * @returns The result of the workflow.
      */
-    runChild(workflow, input, options) {
+    runChild(workflow, input, optionsOrKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            const run = yield this.spawnWorkflow(workflow, input, options);
+            const run = yield this.spawnWorkflow(workflow, input, optionsOrKey);
+            if (workflow instanceof declaration_1.TaskWorkflowDeclaration) {
+                // eslint-disable-next-line no-underscore-dangle
+                if (workflow._standalone_task_name) {
+                    // eslint-disable-next-line no-underscore-dangle
+                    return run.output[workflow._standalone_task_name];
+                }
+            }
             return run.output;
         });
     }
@@ -428,11 +450,11 @@ class Context {
      *
      * @param workflow - The workflow to enqueue (name, Workflow instance, or WorkflowV1 instance).
      * @param input - The input data for the workflow.
-     * @param options - Additional options for spawning the workflow.
+     * @param optionsOrKey - Either a string key or an options object containing key, sticky, and additionalMetadata.
      * @returns A reference to the spawned workflow run.
      */
-    runNoWaitChild(workflow, input, options) {
-        return this.spawnWorkflow(workflow, input, options);
+    runNoWaitChild(workflow, input, optionsOrKey) {
+        return this.spawnWorkflow(workflow, input, optionsOrKey);
     }
     /**
      * Spawns a new workflow.

package/v1/client/client.d.ts

@@ -2,7 +2,7 @@ import { ClientConfig, InternalHatchetClient, HatchetClientOptions } from '../..
 import { AxiosRequestConfig } from 'axios';
 import WorkflowRunRef from '../../util/workflow-run-ref';
 import { Workflow as V0Workflow } from '../../workflow';
-import { JsonObject, DurableContext } from '../../step';
+import { DurableContext } from '../../step';
 import { Api } from '../../clients/rest';
 import { CreateTaskWorkflowOpts, CreateWorkflowOpts, RunOpts, BaseWorkflowDeclaration, WorkflowDeclaration, TaskWorkflowDeclaration } from '../declaration';
 import { IHatchetClient } from './client.interface';
@@ -12,6 +12,7 @@ import { WorkersClient } from './features/workers';
 import { WorkflowsClient } from './features/workflows';
 import { RunsClient } from './features/runs';
 import { CreateStandaloneDurableTaskOpts } from '../task';
+import { InputType, OutputType, UnknownInputType, WorkflowOutputType } from '../types';
 /**
  * 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.
@@ -45,80 +46,80 @@ export declare class HatchetClient implements IHatchetClient {
     static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient;
     /**
      * Creates a new workflow definition.
-     * @template T - The input type for the workflow
-     * @template K - The return type of the workflow
+     * @template I - The input type for the workflow
+     * @template O - The return type of the workflow
      * @param options - Configuration options for creating the workflow
      * @returns A new Workflow instance
      * @note It is possible to create an orphaned workflow if no client is available using @hatchet/client CreateWorkflow
      */
-    workflow<T extends JsonObject | unknown = unknown, K extends JsonObject | unknown = unknown>(options: CreateWorkflowOpts): WorkflowDeclaration<T, K>;
+    workflow<I extends InputType = UnknownInputType, O extends WorkflowOutputType = {}>(options: CreateWorkflowOpts): WorkflowDeclaration<I, O>;
     /**
      * Creates a new task workflow.
      * Types can be explicitly specified as generics or inferred from the function signature.
-     * @template T The input type for the task
-     * @template K The output type of the task
+     * @template I The input type for the task
+     * @template O The output type of the task
      * @param options Task configuration options
      * @returns A TaskWorkflowDeclaration instance
      */
-    task<T extends JsonObject | unknown, K extends JsonObject | unknown>(options: CreateTaskWorkflowOpts<T, K>): TaskWorkflowDeclaration<T, K>;
+    task<I extends InputType = UnknownInputType, O extends OutputType = void>(options: CreateTaskWorkflowOpts<I, O>): TaskWorkflowDeclaration<I, O>;
     /**
      * Creates a new task workflow with types inferred from the function parameter.
      * @template Fn The type of the task function with input and output extending JsonObject
      * @param options Task configuration options with function that defines types
      * @returns A TaskWorkflowDeclaration instance with inferred types
      */
-    task<Fn extends (input: I, ctx?: any) => O | Promise<O>, I extends JsonObject | unknown = Parameters<Fn>[0], O extends JsonObject | unknown = ReturnType<Fn> extends Promise<infer P> ? P extends JsonObject ? P : never : ReturnType<Fn> extends JsonObject ? ReturnType<Fn> : never>(options: {
+    task<Fn extends (input: I, ctx?: any) => O | Promise<O>, I extends InputType = Parameters<Fn>[0] | UnknownInputType, O extends OutputType = ReturnType<Fn> extends Promise<infer P> ? P extends OutputType ? P : void : ReturnType<Fn> extends OutputType ? ReturnType<Fn> : void>(options: {
         fn: Fn;
     } & Omit<CreateTaskWorkflowOpts<I, O>, 'fn'>): TaskWorkflowDeclaration<I, O>;
     /**
      * Creates a new durable task workflow.
      * Types can be explicitly specified as generics or inferred from the function signature.
-     * @template T The input type for the durable task
-     * @template K The output type of the durable task
+     * @template I The input type for the durable task
+     * @template O The output type of the durable task
      * @param options Durable task configuration options
      * @returns A TaskWorkflowDeclaration instance for a durable task
      */
-    durableTask<T extends JsonObject, K extends JsonObject>(options: CreateStandaloneDurableTaskOpts<T, K>): TaskWorkflowDeclaration<T, K>;
+    durableTask<I extends InputType, O extends OutputType>(options: CreateStandaloneDurableTaskOpts<I, O>): TaskWorkflowDeclaration<I, O>;
     /**
      * Creates a new durable task workflow with types inferred from the function parameter.
      * @template Fn The type of the durable task function with input and output extending JsonObject
      * @param options Durable task configuration options with function that defines types
      * @returns A TaskWorkflowDeclaration instance with inferred types
      */
-    durableTask<Fn extends (input: I, ctx: DurableContext<I>) => O | Promise<O>, I extends JsonObject = Parameters<Fn>[0], O extends JsonObject = ReturnType<Fn> extends Promise<infer P> ? P extends JsonObject ? P : never : ReturnType<Fn> extends JsonObject ? ReturnType<Fn> : never>(options: {
+    durableTask<Fn extends (input: I, ctx: DurableContext<I>) => O | Promise<O>, I extends InputType = Parameters<Fn>[0], O extends OutputType = ReturnType<Fn> extends Promise<infer P> ? P extends OutputType ? P : void : ReturnType<Fn> extends OutputType ? ReturnType<Fn> : void>(options: {
         fn: Fn;
     } & Omit<CreateStandaloneDurableTaskOpts<I, O>, 'fn'>): TaskWorkflowDeclaration<I, O>;
     /**
      * Triggers a workflow run without waiting for completion.
-     * @template T - The input type for the workflow
-     * @template K - The return type of the workflow
+     * @template I - The input type for the workflow
+     * @template O - The return type of the workflow
      * @param workflow - The workflow to run, either as a Workflow instance or workflow name
      * @param input - The input data for the workflow
      * @param options - Configuration options for the workflow run
      * @returns A WorkflowRunRef containing the run ID and methods to interact with the run
      */
-    runNoWait<T extends JsonObject = any, K extends JsonObject = any>(workflow: BaseWorkflowDeclaration<T, K> | string | V0Workflow, input: T, options: RunOpts): WorkflowRunRef<K>;
+    runNoWait<I extends InputType = UnknownInputType, O extends OutputType = void>(workflow: BaseWorkflowDeclaration<I, O> | string | V0Workflow, input: I, options: RunOpts): WorkflowRunRef<O>;
     /**
      * @alias run
      * Triggers a workflow run and waits for the result.
-     * @template T - The input type for the workflow
-     * @template K - The return type of the workflow
+     * @template I - The input type for the workflow
+     * @template O - The return type of the workflow
      * @param workflow - The workflow to run, either as a Workflow instance or workflow name
      * @param input - The input data for the workflow
      * @param options - Configuration options for the workflow run
      * @returns A promise that resolves with the workflow result
      */
-    runAndWait<T extends JsonObject = any, K extends JsonObject = any>(workflow: BaseWorkflowDeclaration<T, K> | string | V0Workflow, input: T, options?: RunOpts): Promise<K>;
+    runAndWait<I extends InputType = UnknownInputType, O extends OutputType = void>(workflow: BaseWorkflowDeclaration<I, O> | string | V0Workflow, input: I, options?: RunOpts): Promise<O>;
     /**
      * Triggers a workflow run and waits for the result.
-     * @template T - The input type for the workflow
-     * @template K - The return type of the workflow
+     * @template I - The input type for the workflow
+     * @template O - The return type of the workflow
      * @param workflow - The workflow to run, either as a Workflow instance or workflow name
      * @param input - The input data for the workflow
      * @param options - Configuration options for the workflow run
      * @returns A promise that resolves with the workflow result
      */
-    run<T extends JsonObject = any, K extends JsonObject = any>(workflow: BaseWorkflowDeclaration<T, K> | string | V0Workflow, input: T, options?: RunOpts): Promise<K>;
+    run<I extends InputType = UnknownInputType, O extends OutputType = void>(workflow: BaseWorkflowDeclaration<I, O> | string | V0Workflow, input: I, options?: RunOpts): Promise<O>;
     /**
      * Get the cron client for creating and managing cron workflow runs
      * @returns A cron client instance

package/v1/client/client.js

@@ -82,8 +82,8 @@ class HatchetClient {
     }
     /**
      * Creates a new workflow definition.
-     * @template T - The input type for the workflow
-     * @template K - The return type of the workflow
+     * @template I - The input type for the workflow
+     * @template O - The return type of the workflow
      * @param options - Configuration options for creating the workflow
      * @returns A new Workflow instance
      * @note It is possible to create an orphaned workflow if no client is available using @hatchet/client CreateWorkflow
@@ -105,8 +105,8 @@ class HatchetClient {
     }
     /**
      * Triggers a workflow run without waiting for completion.
-     * @template T - The input type for the workflow
-     * @template K - The return type of the workflow
+     * @template I - The input type for the workflow
+     * @template O - The return type of the workflow
      * @param workflow - The workflow to run, either as a Workflow instance or workflow name
      * @param input - The input data for the workflow
      * @param options - Configuration options for the workflow run
@@ -128,8 +128,8 @@ class HatchetClient {
     /**
      * @alias run
      * Triggers a workflow run and waits for the result.
-     * @template T - The input type for the workflow
-     * @template K - The return type of the workflow
+     * @template I - The input type for the workflow
+     * @template O - The return type of the workflow
      * @param workflow - The workflow to run, either as a Workflow instance or workflow name
      * @param input - The input data for the workflow
      * @param options - Configuration options for the workflow run
@@ -142,8 +142,8 @@ class HatchetClient {
     }
     /**
      * Triggers a workflow run and waits for the result.
-     * @template T - The input type for the workflow
-     * @template K - The return type of the workflow
+     * @template I - The input type for the workflow
+     * @template O - The return type of the workflow
      * @param workflow - The workflow to run, either as a Workflow instance or workflow name
      * @param input - The input data for the workflow
      * @param options - Configuration options for the workflow run

package/v1/declaration.d.ts

@@ -1,11 +1,12 @@
 import WorkflowRunRef from '../util/workflow-run-ref';
-import { Context, DurableContext, JsonObject } from '../step';
+import { Context, DurableContext } from '../step';
 import { CronWorkflows, ScheduledWorkflows } from '../clients/rest/generated/data-contracts';
 import { Workflow as WorkflowV0 } from '../workflow';
 import { IHatchetClient } from './client/client.interface';
 import { CreateWorkflowTaskOpts, CreateOnFailureTaskOpts, TaskConcurrency, TaskFn, CreateWorkflowDurableTaskOpts, CreateBaseTaskOpts, CreateOnSuccessTaskOpts } from './task';
 import { Duration } from './client/duration';
 import { MetricsClient } from './client/features/metrics';
+import { InputType, OutputType, UnknownInputType, JsonObject } from './types';
 /**
  * Additional metadata that can be attached to a workflow run.
  */
@@ -19,10 +20,14 @@ export type RunOpts = {
      */
     additionalMetadata?: AdditionalMetadata;
 };
+/**
+ * Helper type to safely extract output types from task results
+ */
+export type TaskOutput<O, Key extends string, Fallback> = O extends Record<Key, infer Value> ? (Value extends OutputType ? Value : Fallback) : Fallback;
 /**
  * Extracts a property from an object type based on task name, or falls back to inferred type
  */
-export type TaskOutputType<K, TaskName extends string, InferredType> = TaskName extends keyof K ? K[TaskName] : InferredType;
+export type TaskOutputType<O, TaskName extends string, InferredType extends OutputType> = TaskName extends keyof O ? O[TaskName] extends OutputType ? O[TaskName] : InferredType : InferredType;
 export type CreateBaseWorkflowOpts = {
     /**
      * The name of the workflow.
@@ -55,7 +60,7 @@ export type CreateBaseWorkflowOpts = {
     onEvents?: string[];
     concurrency?: TaskConcurrency;
 };
-export type CreateTaskWorkflowOpts<T extends JsonObject | unknown = unknown, K extends JsonObject | unknown = unknown> = CreateBaseWorkflowOpts & CreateBaseTaskOpts<T, K, TaskFn<T, K>>;
+export type CreateTaskWorkflowOpts<I extends InputType = UnknownInputType, O extends OutputType = void> = CreateBaseWorkflowOpts & CreateBaseTaskOpts<I, O, TaskFn<I, O>>;
 /**
  * Options for creating a new workflow.
  */
@@ -141,10 +146,10 @@ export type WorkflowDefinition = CreateWorkflowOpts & {
 };
 /**
  * Represents a workflow that can be executed by Hatchet.
- * @template T The input type for the workflow.
- * @template K The return type of the workflow.
+ * @template I The input type for the workflow.
+ * @template O The return type of the workflow.
  */
-export declare class BaseWorkflowDeclaration<T extends JsonObject | unknown, K extends JsonObject | unknown> {
+export declare class BaseWorkflowDeclaration<I extends InputType = UnknownInputType, O extends OutputType = void> {
     /**
      * The Hatchet client instance used to execute the workflow.
      */
@@ -166,18 +171,18 @@ export declare class BaseWorkflowDeclaration<T extends JsonObject | unknown, K e
      * @returns A WorkflowRunRef containing the run ID and methods to get results and interact with the run.
      * @throws Error if the workflow is not bound to a Hatchet client.
      */
-    runNoWait(input: T, options?: RunOpts): WorkflowRunRef<K>;
+    runNoWait(input: I, options?: RunOpts): WorkflowRunRef<O>;
     /**
      * @alias run
      * Triggers a workflow run and waits for the result.
-     * @template T - The input type for the workflow
-     * @template K - The return type of the workflow
+     * @template I - The input type for the workflow
+     * @template O - The return type of the workflow
      * @param input - The input data for the workflow
      * @param options - Configuration options for the workflow run
      * @returns A promise that resolves with the workflow result
      */
-    runAndWait(input: T, options?: RunOpts): Promise<K>;
-    runAndWait(input: T[], options?: RunOpts): Promise<K[]>;
+    runAndWait(input: I, options?: RunOpts): Promise<O>;
+    runAndWait(input: I[], options?: RunOpts): Promise<O[]>;
     /**
      * Executes the workflow with the given input and awaits the results.
      * @param input The input data for the workflow.
@@ -185,8 +190,8 @@ export declare class BaseWorkflowDeclaration<T extends JsonObject | unknown, K e
      * @returns A promise that resolves with the workflow result.
      * @throws Error if the workflow is not bound to a Hatchet client.
      */
-    run(input: T, options?: RunOpts): Promise<K>;
-    run(input: T[], options?: RunOpts): Promise<K[]>;
+    run(input: I, options?: RunOpts): Promise<O>;
+    run(input: I[], options?: RunOpts): Promise<O[]>;
     /**
      * Schedules a workflow to run at a specific date and time in the future.
      * @param enqueueAt The date when the workflow should be triggered.
@@ -195,7 +200,7 @@ export declare class BaseWorkflowDeclaration<T extends JsonObject | unknown, K e
      * @returns A promise that resolves with the scheduled workflow details.
      * @throws Error if the workflow is not bound to a Hatchet client.
      */
-    schedule(enqueueAt: Date, input: T, options?: RunOpts): Promise<ScheduledWorkflows>;
+    schedule(enqueueAt: Date, input: I, options?: RunOpts): Promise<ScheduledWorkflows>;
     /**
      * Schedules a workflow to run after a specified delay.
      * @param duration The delay in seconds before the workflow should run.
@@ -204,7 +209,7 @@ export declare class BaseWorkflowDeclaration<T extends JsonObject | unknown, K e
      * @returns A promise that resolves with the scheduled workflow details.
      * @throws Error if the workflow is not bound to a Hatchet client.
      */
-    delay(duration: number, input: T, options?: RunOpts): Promise<ScheduledWorkflows>;
+    delay(duration: number, input: I, options?: RunOpts): Promise<ScheduledWorkflows>;
     /**
      * Creates a cron schedule for the workflow.
      * @param name The name of the cron schedule.
@@ -214,7 +219,7 @@ export declare class BaseWorkflowDeclaration<T extends JsonObject | unknown, K e
      * @returns A promise that resolves with the cron workflow details.
      * @throws Error if the workflow is not bound to a Hatchet client.
      */
-    cron(name: string, expression: string, input: T, options?: RunOpts): Promise<CronWorkflows>;
+    cron(name: string, expression: string, input: I, options?: RunOpts): Promise<CronWorkflows>;
     /**
      * Get metrics for the workflow.
      * @param opts Optional configuration for the metrics request.
@@ -242,20 +247,20 @@ export declare class BaseWorkflowDeclaration<T extends JsonObject | unknown, K e
      */
     get name(): string;
 }
-export declare class WorkflowDeclaration<T extends JsonObject | unknown = unknown, K extends JsonObject | unknown = unknown> extends BaseWorkflowDeclaration<T, K> {
+export declare class WorkflowDeclaration<I extends InputType = UnknownInputType, O extends OutputType = void> extends BaseWorkflowDeclaration<I, O> {
     /**
      * Adds a task to the workflow.
-     * The return type will be either the property on K that corresponds to the task name,
+     * The return type will be either the property on O that corresponds to the task name,
      * or if there is no matching property, the inferred return type of the function.
      * @template Name The literal string name of the task.
-     * @template L The inferred return type of the task function.
+     * @template Fn The type of the task function.
      * @param options The task configuration options.
      * @returns The task options that were added.
      */
-    task<Name extends string, L>(options: (Omit<CreateWorkflowTaskOpts<T, TaskOutputType<K, Name, L>>, 'fn'> & {
+    task<Name extends string, Fn extends Name extends keyof O ? (input: I, ctx: Context<I>) => O[Name] extends OutputType ? O[Name] | Promise<O[Name]> : void : (input: I, ctx: Context<I>) => void, FnReturn = ReturnType<Fn> extends Promise<infer P> ? P : ReturnType<Fn>, TO extends OutputType = Name extends keyof O ? O[Name] extends OutputType ? O[Name] : never : FnReturn extends OutputType ? FnReturn : never>(options: (Omit<CreateWorkflowTaskOpts<I, TO>, 'fn'> & {
         name: Name;
-        fn: (input: T, ctx: Context<T>) => TaskOutputType<K, Name, L> | Promise<TaskOutputType<K, Name, L>>;
-    }) | TaskWorkflowDeclaration<any, any>): CreateWorkflowTaskOpts<T, TaskOutputType<K, Name, L>>;
+        fn: Fn;
+    }) | TaskWorkflowDeclaration<I, TO>): CreateWorkflowTaskOpts<I, TO>;
     /**
      * Adds an onFailure task to the workflow.
      * This will only run if any task in the workflow fails.
@@ -264,9 +269,9 @@ export declare class WorkflowDeclaration<T extends JsonObject | unknown = unknow
      * @param options The task configuration options.
      * @returns The task options that were added.
      */
-    onFailure<Name extends string, L>(options: (Omit<CreateOnFailureTaskOpts<T, TaskOutputType<K, Name, L>>, 'fn'> & {
-        fn: (input: T, ctx: Context<T>) => TaskOutputType<K, Name, L> | Promise<TaskOutputType<K, Name, L>>;
-    }) | TaskWorkflowDeclaration<any, any>): CreateWorkflowTaskOpts<T, TaskOutputType<K, Name, L>>;
+    onFailure<Name extends string, L extends OutputType>(options: (Omit<CreateOnFailureTaskOpts<I, TaskOutputType<O, Name, L>>, 'fn'> & {
+        fn: (input: I, ctx: Context<I>) => TaskOutputType<O, Name, L> | Promise<TaskOutputType<O, Name, L>>;
+    }) | TaskWorkflowDeclaration<any, any>): CreateWorkflowTaskOpts<I, TaskOutputType<O, Name, L>>;
     /**
      * Adds an onSuccess task to the workflow.
      * This will only run if all tasks in the workflow complete successfully.
@@ -275,28 +280,28 @@ export declare class WorkflowDeclaration<T extends JsonObject | unknown = unknow
      * @param options The task configuration options.
      * @returns The task options that were added.
      */
-    onSuccess<Name extends string, L>(options: (Omit<CreateOnSuccessTaskOpts<T, TaskOutputType<K, Name, L>>, 'fn'> & {
-        fn: (input: T, ctx: Context<T>) => TaskOutputType<K, Name, L> | Promise<TaskOutputType<K, Name, L>>;
-    }) | TaskWorkflowDeclaration<any, any>): CreateWorkflowTaskOpts<T, TaskOutputType<K, Name, L>>;
+    onSuccess<Name extends string, L extends OutputType>(options: (Omit<CreateOnSuccessTaskOpts<I, TaskOutputType<O, Name, L>>, 'fn'> & {
+        fn: (input: I, ctx: Context<I>) => TaskOutputType<O, Name, L> | Promise<TaskOutputType<O, Name, L>>;
+    }) | TaskWorkflowDeclaration<any, any>): CreateWorkflowTaskOpts<I, TaskOutputType<O, Name, L>>;
     /**
      * Adds a durable task to the workflow.
-     * The return type will be either the property on K that corresponds to the task name,
+     * The return type will be either the property on O that corresponds to the task name,
      * or if there is no matching property, the inferred return type of the function.
      * @template Name The literal string name of the task.
-     * @template L The inferred return type of the task function.
+     * @template Fn The type of the task function.
      * @param options The task configuration options.
      * @returns The task options that were added.
      */
-    durableTask<Name extends string, L>(options: Omit<CreateWorkflowTaskOpts<T, TaskOutputType<K, Name, L>>, 'fn'> & {
+    durableTask<Name extends string, Fn extends Name extends keyof O ? (input: I, ctx: DurableContext<I>) => O[Name] extends OutputType ? O[Name] | Promise<O[Name]> : void : (input: I, ctx: DurableContext<I>) => void, FnReturn = ReturnType<Fn> extends Promise<infer P> ? P : ReturnType<Fn>, TO extends OutputType = Name extends keyof O ? O[Name] extends OutputType ? O[Name] : never : FnReturn extends OutputType ? FnReturn : never>(options: Omit<CreateWorkflowTaskOpts<I, TO>, 'fn'> & {
         name: Name;
-        fn: (input: T, ctx: DurableContext<T>) => TaskOutputType<K, Name, L> | Promise<TaskOutputType<K, Name, L>>;
-    }): CreateWorkflowDurableTaskOpts<T, TaskOutputType<K, Name, L>>;
+        fn: Fn;
+    }): CreateWorkflowDurableTaskOpts<I, TO>;
 }
-export declare class TaskWorkflowDeclaration<T extends JsonObject | unknown = unknown, K extends JsonObject | unknown = unknown> extends BaseWorkflowDeclaration<T, K> {
-    private _standalone_task_name;
-    constructor(options: CreateTaskWorkflowOpts<T, K>, client?: IHatchetClient);
-    run(input: T, options?: RunOpts): Promise<K>;
-    run(input: T[], options?: RunOpts): Promise<K[]>;
+export declare class TaskWorkflowDeclaration<I extends InputType = UnknownInputType, O extends OutputType = void> extends BaseWorkflowDeclaration<I, O> {
+    _standalone_task_name: string;
+    constructor(options: CreateTaskWorkflowOpts<I, O>, client?: IHatchetClient);
+    run(input: I, options?: RunOpts): Promise<O>;
+    run(input: I[], options?: RunOpts): Promise<O[]>;
     get taskDef(): CreateWorkflowTaskOpts<any, any>;
 }
 /**
@@ -306,18 +311,18 @@ export declare class TaskWorkflowDeclaration<T extends JsonObject | unknown = un
  * @param client Optional Hatchet client instance.
  * @returns A new TaskWorkflowDeclaration with inferred types.
  */
-export declare function CreateTaskWorkflow<Fn extends (input: I, ctx?: any) => O | Promise<O>, I extends JsonObject | unknown = Parameters<Fn>[0], O extends JsonObject | unknown = ReturnType<Fn> extends Promise<infer P> ? P extends JsonObject ? P : never : ReturnType<Fn> extends JsonObject ? ReturnType<Fn> : never>(options: {
+export declare function CreateTaskWorkflow<Fn extends (input: I, ctx?: any) => O | Promise<O>, I extends InputType = Parameters<Fn>[0], O extends OutputType = ReturnType<Fn> extends Promise<infer P> ? P extends OutputType ? P : void : ReturnType<Fn> extends OutputType ? ReturnType<Fn> : void>(options: {
     fn: Fn;
 } & Omit<CreateTaskWorkflowOpts<I, O>, 'fn'>, client?: IHatchetClient): TaskWorkflowDeclaration<I, O>;
 /**
  * Creates a new workflow instance.
- * @template T The input type for the workflow.
- * @template K The return type of the workflow.
+ * @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 client Optional Hatchet client instance.
  * @returns A new Workflow instance.
  */
-export declare function CreateWorkflow<T extends JsonObject | unknown = unknown, K extends JsonObject | unknown = unknown>(options: CreateWorkflowOpts, client?: IHatchetClient): WorkflowDeclaration<T, K>;
+export declare function CreateWorkflow<I extends InputType = UnknownInputType, O extends OutputType = void>(options: CreateWorkflowOpts, client?: IHatchetClient): WorkflowDeclaration<I, O>;
 /**
  * Creates a new durable task workflow declaration with types inferred from the function parameter.
  * @template Fn The type of the durable task function

package/v1/declaration.js

@@ -16,8 +16,8 @@ exports.CreateDurableTaskWorkflow = CreateDurableTaskWorkflow;
 const UNBOUND_ERR = new Error('workflow unbound to hatchet client, hint: use client.run instead');
 /**
  * Represents a workflow that can be executed by Hatchet.
- * @template T The input type for the workflow.
- * @template K The return type of the workflow.
+ * @template I The input type for the workflow.
+ * @template O The return type of the workflow.
  */
 class BaseWorkflowDeclaration {
     /**
@@ -197,10 +197,10 @@ exports.BaseWorkflowDeclaration = BaseWorkflowDeclaration;
 class WorkflowDeclaration extends BaseWorkflowDeclaration {
     /**
      * Adds a task to the workflow.
-     * The return type will be either the property on K that corresponds to the task name,
+     * The return type will be either the property on O that corresponds to the task name,
      * or if there is no matching property, the inferred return type of the function.
      * @template Name The literal string name of the task.
-     * @template L The inferred return type of the task function.
+     * @template Fn The type of the task function.
      * @param options The task configuration options.
      * @returns The task options that were added.
      */
@@ -263,10 +263,10 @@ class WorkflowDeclaration extends BaseWorkflowDeclaration {
     }
     /**
      * Adds a durable task to the workflow.
-     * The return type will be either the property on K that corresponds to the task name,
+     * The return type will be either the property on O that corresponds to the task name,
      * or if there is no matching property, the inferred return type of the function.
      * @template Name The literal string name of the task.
-     * @template L The inferred return type of the task function.
+     * @template Fn The type of the task function.
      * @param options The task configuration options.
      * @returns The task options that were added.
      */
@@ -312,8 +312,8 @@ function CreateTaskWorkflow(options, client) {
 }
 /**
  * Creates a new workflow instance.
- * @template T The input type for the workflow.
- * @template K The return type of the workflow.
+ * @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 client Optional Hatchet client instance.
  * @returns A new Workflow instance.

package/v1/examples/cancellations/workflow.d.ts

@@ -1,3 +1,3 @@
-export declare const cancellation: import("../..").TaskWorkflowDeclaration<unknown, {
-    Completed: boolean;
+export declare const cancellation: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
+    Completed: true;
 }>;

package/v1/examples/durable-sleep/workflow.d.ts

@@ -1 +1 @@
-export declare const durableSleep: import("../..").WorkflowDeclaration<unknown, unknown>;
+export declare const durableSleep: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}>;

package/v1/examples/on_failure/workflow.d.ts

@@ -1 +1 @@
-export declare const failureWorkflow: import("../..").WorkflowDeclaration<unknown, unknown>;
+export declare const failureWorkflow: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}>;

package/v1/examples/on_success/workflow.d.ts

@@ -1 +1 @@
-export declare const onSuccessDag: import("../..").WorkflowDeclaration<unknown, unknown>;
+export declare const onSuccessDag: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}>;

package/v1/examples/rate_limit/workflow.d.ts

@@ -1,5 +1,5 @@
 type RateLimitInput = {
     userId: string;
 };
-export declare const rateLimitWorkflow: import("../..").WorkflowDeclaration<RateLimitInput, unknown>;
+export declare const rateLimitWorkflow: import("../..").WorkflowDeclaration<RateLimitInput, {}>;
 export {};

package/v1/examples/retries/workflow.d.ts

@@ -1,5 +1,5 @@
-export declare const retries: import("../..").TaskWorkflowDeclaration<unknown, never>;
-export declare const retriesWithCount: import("../..").TaskWorkflowDeclaration<unknown, {
+export declare const retries: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, never>;
+export declare const retriesWithCount: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
     message: string;
 }>;
-export declare const withBackoff: import("../..").TaskWorkflowDeclaration<unknown, never>;
+export declare const withBackoff: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, never>;

package/v1/examples/sticky/workflow.d.ts

@@ -1,4 +1,4 @@
-export declare const sticky: import("../..").TaskWorkflowDeclaration<unknown, {
+export declare const sticky: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
     result: {
         Value: number;
     };

package/v1/examples/timeouts/workflow.d.ts

@@ -1,3 +1,3 @@
-export declare const cancellation: import("../..").TaskWorkflowDeclaration<unknown, {
-    Completed: boolean;
+export declare const cancellation: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
+    Completed: true;
 }>;

package/v1/index.d.ts

@@ -4,3 +4,4 @@ export * from './client/worker';
 export * from './declaration';
 export * from './conditions';
 export * from './client/duration';
+export * from './types';

package/v1/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./client/worker"), exports);
 __exportStar(require("./declaration"), exports);
 __exportStar(require("./conditions"), exports);
 __exportStar(require("./client/duration"), exports);
+__exportStar(require("./types"), exports);

package/v1/task.d.ts

@@ -2,6 +2,7 @@ import { ConcurrencyLimitStrategy } from '../protoc/v1/workflows';
 import { Context, CreateStep, DurableContext } from '../step';
 import { Conditions } from './conditions';
 import { Duration } from './client/duration';
+import { InputType, OutputType, UnknownInputType } from './types';
 /**
  * Options for configuring the concurrency for a task.
  */
@@ -28,14 +29,14 @@ export type TaskConcurrency = {
      */
     limitStrategy?: ConcurrencyLimitStrategy;
 };
-export type TaskFn<T, K> = (input: T, ctx: Context<T>) => K | Promise<K>;
-export type DurableTaskFn<T, K> = (input: T, ctx: DurableContext<T>) => K | Promise<K>;
+export type TaskFn<I extends InputType = UnknownInputType, O extends OutputType = void, C = Context<I>> = (input: I, ctx: C) => O | Promise<O>;
+export type DurableTaskFn<I extends InputType = UnknownInputType, O extends OutputType = void> = TaskFn<I, O, DurableContext<I>>;
 /**
  * Options for creating a hatchet task which is an atomic unit of work in a workflow.
- * @template T The input type for the task function.
- * @template K The return type of the task function (can be inferred from the return value of fn).
+ * @template I The input type for the task function.
+ * @template O The return type of the task function (can be inferred from the return value of fn).
  */
-export type CreateBaseTaskOpts<T, K, C> = {
+export type CreateBaseTaskOpts<I extends InputType = UnknownInputType, O extends OutputType = void, C = TaskFn<I, O>> = {
     /**
      * The name of the task.
      */
@@ -50,7 +51,7 @@ export type CreateBaseTaskOpts<T, K, C> = {
     /**
      * @deprecated use executionTimeout instead
      */
-    timeout?: CreateStep<T, K>['timeout'];
+    timeout?: CreateStep<I, O>['timeout'];
     /**
      * (optional) execution timeout duration for the task after it starts running
      * go duration format (e.g., "1s", "5m", "1h").
@@ -70,17 +71,17 @@ export type CreateBaseTaskOpts<T, K, C> = {
      *
      * default: 0
      */
-    retries?: CreateStep<T, K>['retries'];
+    retries?: CreateStep<I, O>['retries'];
     /**
      * (optional) backoff strategy configuration for retries.
      * - factor: Base of the exponential backoff (base ^ retry count)
      * - maxSeconds: Maximum backoff duration in seconds
      */
-    backoff?: CreateStep<T, K>['backoff'];
+    backoff?: CreateStep<I, O>['backoff'];
     /**
      * (optional) rate limits for the task.
      */
-    rateLimits?: CreateStep<T, K>['rate_limits'];
+    rateLimits?: CreateStep<I, O>['rate_limits'];
     /**
      * (optional) worker labels for task routing and scheduling.
      * Each label can be a simple string/number value or an object with additional configuration:
@@ -89,18 +90,18 @@ export type CreateBaseTaskOpts<T, K, C> = {
      * - weight: Priority weight for worker selection
      * - comparator: Custom comparison logic for label matching
      */
-    desiredWorkerLabels?: CreateStep<T, K>['worker_labels'];
+    desiredWorkerLabels?: CreateStep<I, O>['worker_labels'];
     /**
      * (optional) the concurrency options for the task
      */
     concurrency?: TaskConcurrency | TaskConcurrency[];
 };
-export type CreateWorkflowTaskOpts<T, K, C = TaskFn<T, K>> = CreateBaseTaskOpts<T, K, C> & {
+export type CreateWorkflowTaskOpts<I extends InputType = UnknownInputType, O extends OutputType = void, C extends TaskFn<I, O> | DurableTaskFn<I, O> = TaskFn<I, O>> = CreateBaseTaskOpts<I, O, C> & {
     /**
      * Parent tasks that must complete before this task runs.
      * Used to define the directed acyclic graph (DAG) of the workflow.
      */
-    parents?: CreateWorkflowTaskOpts<T, any, any>[];
+    parents?: CreateWorkflowTaskOpts<I, any, any>[];
     /**
      * (optional) the conditions to match before the task is queued
      * all provided conditions must be met (AND logic)
@@ -154,28 +155,28 @@ export type CreateWorkflowTaskOpts<T, K, C = TaskFn<T, K>> = CreateBaseTaskOpts<
      */
     skipIf?: Conditions | Conditions[];
 };
-export type CreateStandaloneTaskOpts<T, K> = CreateBaseTaskOpts<T, K, TaskFn<T, K>>;
+export type CreateStandaloneTaskOpts<I extends InputType = UnknownInputType, O extends OutputType = void, C extends TaskFn<I, O> = TaskFn<I, O>> = CreateBaseTaskOpts<I, O, C>;
 /**
  * Options for creating a hatchet durable task which is an atomic unit of work in a workflow.
- * @template T The input type for the task function.
- * @template K The return type of the task function (can be inferred from the return value of fn).
+ * @template I The input type for the task function.
+ * @template O The return type of the task function (can be inferred from the return value of fn).
  */
-export type CreateWorkflowDurableTaskOpts<T, K> = CreateWorkflowTaskOpts<T, K, DurableTaskFn<T, K>>;
+export type CreateWorkflowDurableTaskOpts<I extends InputType = UnknownInputType, O extends OutputType = void, C extends DurableTaskFn<I, O> = DurableTaskFn<I, O>> = CreateWorkflowTaskOpts<I, O, C>;
 /**
  * Options for creating a hatchet task which is an atomic unit of work in a workflow.
- * @template T The input type for the task function.
- * @template K The return type of the task function (can be inferred from the return value of fn).
+ * @template I The input type for the task function.
+ * @template O The return type of the task function (can be inferred from the return value of fn).
  */
-export type CreateStandaloneDurableTaskOpts<T, K> = CreateBaseTaskOpts<T, K, DurableTaskFn<T, K>>;
+export type CreateStandaloneDurableTaskOpts<I extends InputType = UnknownInputType, O extends OutputType = void, C extends DurableTaskFn<I, O> = DurableTaskFn<I, O>> = CreateBaseTaskOpts<I, O, C>;
 /**
  * Options for configuring the onSuccess task that is invoked when a task succeeds.
- * @template T The input type for the task function.
- * @template K The return type of the task function (can be inferred from the return value of fn).
+ * @template I The input type for the task function.
+ * @template O The return type of the task function (can be inferred from the return value of fn).
  */
-export type CreateOnSuccessTaskOpts<T, K> = Omit<CreateBaseTaskOpts<T, K, TaskFn<T, K>>, 'name'>;
+export type CreateOnSuccessTaskOpts<I extends InputType = UnknownInputType, O extends OutputType = void, C extends TaskFn<I, O> = TaskFn<I, O>> = Omit<CreateBaseTaskOpts<I, O, C>, 'name'>;
 /**
  * Options for configuring the onFailure task that is invoked when a task fails.
- * @template T The input type for the task function.
- * @template K The return type of the task function (can be inferred from the return value of fn).
+ * @template I The input type for the task function.
+ * @template O The return type of the task function (can be inferred from the return value of fn).
  */
-export type CreateOnFailureTaskOpts<T, K> = Omit<CreateBaseTaskOpts<T, K, TaskFn<T, K>>, 'name'>;
+export type CreateOnFailureTaskOpts<I extends InputType = UnknownInputType, O extends OutputType = void, C extends TaskFn<I, O> = TaskFn<I, O>> = Omit<CreateBaseTaskOpts<I, O, C>, 'name'>;

package/v1/types.d.ts

@@ -0,0 +1,17 @@
+export type JsonPrimitive = string | number | boolean | null | undefined;
+export type JsonArray = JsonValue[];
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+export type JsonObject = {
+    [Key in string]: JsonValue;
+} & {
+    [Key in string]?: JsonValue | undefined;
+};
+export type InputType = JsonObject;
+export type UnknownInputType = {};
+export type OutputType = JsonObject | void;
+type IsValidWorkflowOutput<T> = T extends Record<string, JsonObject> ? true : false;
+export type WorkflowOutputType<T = any> = IsValidWorkflowOutput<T> extends true ? T : (Record<string, JsonObject> | void) & {
+    [ERROR_WORKFLOW_OUTPUT]?: 'Workflow output must be shaped as Record<"task-name", JsonObject>. Each property must be an object, not a primitive value.';
+};
+declare const ERROR_WORKFLOW_OUTPUT: unique symbol;
+export {};

package/v1/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.0.3";
+export declare const HATCHET_VERSION = "1.0.5";

package/version.js

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

package/workflow.d.ts

@@ -380,10 +380,6 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         } | undefined;
     }[];
     id: string;
-    version?: string | undefined;
-    scheduleTimeout?: string | undefined;
-    sticky?: PbStickyStrategy | undefined;
-    timeout?: string | undefined;
     on?: {
         cron: string;
         event?: undefined;
@@ -391,6 +387,10 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         event: string;
         cron?: undefined;
     } | undefined;
+    version?: string | undefined;
+    scheduleTimeout?: string | undefined;
+    sticky?: PbStickyStrategy | undefined;
+    timeout?: string | undefined;
     onFailure?: {
         name: string;
         timeout?: string | undefined;
@@ -442,10 +442,6 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         } | undefined;
     }[];
     id: string;
-    version?: string | undefined;
-    scheduleTimeout?: string | undefined;
-    sticky?: PbStickyStrategy | undefined;
-    timeout?: string | undefined;
     on?: {
         cron: string;
         event?: undefined;
@@ -453,6 +449,10 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         event: string;
         cron?: undefined;
     } | undefined;
+    version?: string | undefined;
+    scheduleTimeout?: string | undefined;
+    sticky?: PbStickyStrategy | undefined;
+    timeout?: string | undefined;
     onFailure?: {
         name: string;
         timeout?: string | undefined;