@hatchet-dev/typescript-sdk 1.12.1 → 1.13.1

package/clients/hatchet-client/client-config.d.ts

@@ -1,5 +1,6 @@
 import { ChannelCredentials } from 'nice-grpc';
 import { z } from 'zod';
+import type { Context } from '../../v1/client/worker/context';
 import { Logger, LogLevel } from '../../util/logger';
 declare const ClientTLSConfigSchema: z.ZodObject<{
     tls_strategy: z.ZodOptional<z.ZodEnum<["tls", "mtls", "none"]>>;
@@ -56,6 +57,16 @@ export declare const ClientConfigSchema: z.ZodObject<{
     log_level: z.ZodOptional<z.ZodEnum<["OFF", "DEBUG", "INFO", "WARN", "ERROR"]>>;
     tenant_id: z.ZodString;
     namespace: z.ZodOptional<z.ZodString>;
+    middleware: z.ZodOptional<z.ZodObject<{
+        before: z.ZodOptional<z.ZodAny>;
+        after: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        before?: any;
+        after?: any;
+    }, {
+        before?: any;
+        after?: any;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     token: string;
     tls_config: {
@@ -74,6 +85,10 @@ export declare const ClientConfigSchema: z.ZodObject<{
     } | undefined;
     log_level?: "OFF" | "DEBUG" | "INFO" | "WARN" | "ERROR" | undefined;
     namespace?: string | undefined;
+    middleware?: {
+        before?: any;
+        after?: any;
+    } | undefined;
 }, {
     token: string;
     tls_config: {
@@ -92,12 +107,56 @@ export declare const ClientConfigSchema: z.ZodObject<{
     } | undefined;
     log_level?: "OFF" | "DEBUG" | "INFO" | "WARN" | "ERROR" | undefined;
     namespace?: string | undefined;
+    middleware?: {
+        before?: any;
+        after?: any;
+    } | undefined;
 }>;
 export type LogConstructor = (context: string, logLevel?: LogLevel) => Logger;
+/**
+ * A middleware function that runs before every task invocation.
+ * Returns extra fields to replace the task input, or void to skip.
+ * @template T - The expected input type for the hook.
+ * @param input - The current task input.
+ * @param ctx - The task execution context.
+ * @returns The new input value, or void to pass through unchanged.
+ */
+export type BeforeHookFn<T = any> = (input: T, ctx: Context<any>) => Record<string, any> | void | Promise<Record<string, any> | void>;
+/**
+ * A middleware function that runs after every task invocation.
+ * Returns extra fields to replace the task output, or void to skip.
+ * @param output - The task output.
+ * @param ctx - The task execution context.
+ * @param input - The task input (after before-hooks have run).
+ * @returns The new output value, or void to pass through unchanged.
+ */
+export type AfterHookFn<TOutput = any, TInput = any> = (output: TOutput, ctx: Context<any>, input: TInput) => Record<string, any> | void | Promise<Record<string, any> | void>;
+/**
+ * Middleware hooks that run before/after every task invocation.
+ *
+ * Each hook can be a single function or an array of functions.
+ * When an array is provided the functions run in order and each
+ * result replaces the value (input for `before`, output for `after`).
+ *
+ * Return `void` (or `undefined`) from a hook to pass through unchanged.
+ */
+export type TaskMiddleware<TInput = any, TOutput = any> = {
+    before?: BeforeHookFn<TInput> | readonly BeforeHookFn<TInput>[];
+    after?: AfterHookFn<TOutput, TInput> | readonly AfterHookFn<TOutput, TInput>[];
+};
+type NonVoidReturn<F> = F extends (...args: any[]) => infer R ? Exclude<Awaited<R>, void | undefined> : {};
+type MergeReturns<T> = T extends readonly [infer F, ...infer Rest] ? NonVoidReturn<F> & MergeReturns<Rest> : {};
+export type InferMiddlewareBefore<M> = M extends {
+    before: infer P;
+} ? P extends (...args: any[]) => any ? NonVoidReturn<P> : P extends readonly any[] ? MergeReturns<P> : {} : {};
+export type InferMiddlewareAfter<M> = M extends {
+    after: infer P;
+} ? P extends (...args: any[]) => any ? NonVoidReturn<P> : P extends readonly any[] ? MergeReturns<P> : {} : {};
 export type ClientConfig = z.infer<typeof ClientConfigSchema> & {
     credentials?: ChannelCredentials;
 } & {
     logger: LogConstructor;
+    middleware?: TaskMiddleware;
 };
 export type ClientTLSConfig = z.infer<typeof ClientTLSConfigSchema>;
 export {};

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

@@ -13,6 +13,12 @@ const HealthcheckConfigSchema = zod_1.z.object({
     enabled: zod_1.z.boolean().optional().default(false),
     port: zod_1.z.number().optional().default(8001),
 });
+const TaskMiddlewareSchema = zod_1.z
+    .object({
+    before: zod_1.z.any().optional(),
+    after: zod_1.z.any().optional(),
+})
+    .optional();
 exports.ClientConfigSchema = zod_1.z.object({
     token: zod_1.z.string(),
     tls_config: ClientTLSConfigSchema,
@@ -22,4 +28,5 @@ exports.ClientConfigSchema = zod_1.z.object({
     log_level: zod_1.z.enum(['OFF', 'DEBUG', 'INFO', 'WARN', 'ERROR']).optional(),
     tenant_id: zod_1.z.string(),
     namespace: zod_1.z.string().optional(),
+    middleware: TaskMiddlewareSchema,
 });

package/clients/worker/worker.js

@@ -184,7 +184,31 @@ class V0Worker {
                     return;
                 }
                 const run = () => __awaiter(this, void 0, void 0, function* () {
-                    return step(context);
+                    const { middleware } = this.client.config;
+                    if (middleware === null || middleware === void 0 ? void 0 : middleware.before) {
+                        const hooks = Array.isArray(middleware.before) ? middleware.before : [middleware.before];
+                        for (const hook of hooks) {
+                            const extra = yield hook(context.input, context);
+                            if (extra !== undefined) {
+                                const merged = Object.assign(Object.assign({}, context.input), extra);
+                                context.input = merged;
+                                if (context.data && typeof context.data === 'object') {
+                                    context.data.input = merged;
+                                }
+                            }
+                        }
+                    }
+                    let result = yield step(context);
+                    if (middleware === null || middleware === void 0 ? void 0 : middleware.after) {
+                        const hooks = Array.isArray(middleware.after) ? middleware.after : [middleware.after];
+                        for (const hook of hooks) {
+                            const extra = yield hook(result, context, context.input);
+                            if (extra !== undefined) {
+                                result = Object.assign(Object.assign({}, result), extra);
+                            }
+                        }
+                    }
+                    return result;
                 });
                 const success = (result) => __awaiter(this, void 0, void 0, function* () {
                     this.logger.info(`Task run ${action.taskRunExternalId} succeeded`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.12.1",
+  "version": "1.13.1",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -22,12 +22,12 @@
     "@tsd/typescript": "^5.8.2",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.13.14",
-    "@typescript-eslint/eslint-plugin": "^6.21.0",
-    "@typescript-eslint/parser": "^6.21.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
     "autoprefixer": "^10.4.21",
     "dotenv-cli": "^7.4.4",
     "eslint": "^8.56.0",
-    "eslint-config-airbnb-typescript": "^17.1.0",
+    "eslint-config-airbnb-typescript": "^18.0.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-config-standard": "^17.1.0",
     "eslint-import-resolver-typescript": "^3.10.0",
@@ -57,12 +57,12 @@
     "@bufbuild/protobuf": "^2.2.5",
     "@types/qs": "^6.9.18",
     "abort-controller-x": "^0.4.3",
-    "axios": "^1.11.0",
+    "axios": "^1.13.5",
     "long": "^5.3.1",
     "nice-grpc": "^2.1.12",
     "nice-grpc-common": "^2.0.2",
     "protobufjs": "^7.4.0",
-    "qs": "^6.14.1",
+    "qs": "^6.14.2",
     "semver": "^7.7.1",
     "yaml": "^2.7.1",
     "zod": "^3.24.2",

package/step.d.ts

@@ -25,17 +25,17 @@ export declare const CreateRateLimitSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     units: string | number;
     key?: string | undefined;
-    duration?: RateLimitDuration | undefined;
-    limit?: string | number | undefined;
     staticKey?: string | undefined;
     dynamicKey?: string | undefined;
+    limit?: string | number | undefined;
+    duration?: RateLimitDuration | undefined;
 }, {
     units: string | number;
     key?: string | undefined;
-    duration?: RateLimitDuration | undefined;
-    limit?: string | number | undefined;
     staticKey?: string | undefined;
     dynamicKey?: string | undefined;
+    limit?: string | number | undefined;
+    duration?: RateLimitDuration | undefined;
 }>;
 export declare const DesiredWorkerLabelSchema: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodObject<{
     value: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
@@ -45,13 +45,13 @@ export declare const DesiredWorkerLabelSchema: z.ZodOptional<z.ZodUnion<[z.ZodSt
 }, "strip", z.ZodTypeAny, {
     value: string | number;
     required?: boolean | undefined;
-    comparator?: WorkerLabelComparator | undefined;
     weight?: number | undefined;
+    comparator?: WorkerLabelComparator | undefined;
 }, {
     value: string | number;
     required?: boolean | undefined;
-    comparator?: WorkerLabelComparator | undefined;
     weight?: number | undefined;
+    comparator?: WorkerLabelComparator | undefined;
 }>]>>;
 export declare const CreateStepSchema: z.ZodObject<{
     name: z.ZodString;
@@ -68,17 +68,17 @@ export declare const CreateStepSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         units: string | number;
         key?: string | undefined;
-        duration?: RateLimitDuration | undefined;
-        limit?: string | number | undefined;
         staticKey?: string | undefined;
         dynamicKey?: string | undefined;
+        limit?: string | number | undefined;
+        duration?: RateLimitDuration | undefined;
     }, {
         units: string | number;
         key?: string | undefined;
-        duration?: RateLimitDuration | undefined;
-        limit?: string | number | undefined;
         staticKey?: string | undefined;
         dynamicKey?: string | undefined;
+        limit?: string | number | undefined;
+        duration?: RateLimitDuration | undefined;
     }>, "many">>;
     worker_labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodLazy<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodObject<{
         value: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
@@ -88,13 +88,13 @@ export declare const CreateStepSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         value: string | number;
         required?: boolean | undefined;
-        comparator?: WorkerLabelComparator | undefined;
         weight?: number | undefined;
+        comparator?: WorkerLabelComparator | undefined;
     }, {
         value: string | number;
         required?: boolean | undefined;
-        comparator?: WorkerLabelComparator | undefined;
         weight?: number | undefined;
+        comparator?: WorkerLabelComparator | undefined;
     }>]>>>>>;
     backoff: z.ZodOptional<z.ZodObject<{
         factor: z.ZodOptional<z.ZodNumber>;
@@ -114,16 +114,16 @@ export declare const CreateStepSchema: z.ZodObject<{
     rate_limits?: {
         units: string | number;
         key?: string | undefined;
-        duration?: RateLimitDuration | undefined;
-        limit?: string | number | undefined;
         staticKey?: string | undefined;
         dynamicKey?: string | undefined;
+        limit?: string | number | undefined;
+        duration?: RateLimitDuration | undefined;
     }[] | undefined;
     worker_labels?: Record<string, string | number | {
         value: string | number;
         required?: boolean | undefined;
-        comparator?: WorkerLabelComparator | undefined;
         weight?: number | undefined;
+        comparator?: WorkerLabelComparator | undefined;
     } | undefined> | undefined;
     backoff?: {
         factor?: number | undefined;
@@ -137,16 +137,16 @@ export declare const CreateStepSchema: z.ZodObject<{
     rate_limits?: {
         units: string | number;
         key?: string | undefined;
-        duration?: RateLimitDuration | undefined;
-        limit?: string | number | undefined;
         staticKey?: string | undefined;
         dynamicKey?: string | undefined;
+        limit?: string | number | undefined;
+        duration?: RateLimitDuration | undefined;
     }[] | undefined;
     worker_labels?: Record<string, string | number | {
         value: string | number;
         required?: boolean | undefined;
-        comparator?: WorkerLabelComparator | undefined;
         weight?: number | undefined;
+        comparator?: WorkerLabelComparator | undefined;
     } | undefined> | undefined;
     backoff?: {
         factor?: number | undefined;

package/v1/client/client.d.ts

@@ -1,4 +1,4 @@
-import { ClientConfig, HatchetClientOptions, LegacyHatchetClient } from '../../clients/hatchet-client';
+import { ClientConfig, HatchetClientOptions, LegacyHatchetClient, TaskMiddleware, InferMiddlewareBefore, InferMiddlewareAfter } from '../../clients/hatchet-client';
 import { AxiosRequestConfig } from 'axios';
 import WorkflowRunRef from '../../util/workflow-run-ref';
 import { Workflow as V0Workflow } from '../../workflow';
@@ -12,7 +12,7 @@ import { MetricsClient } from './features/metrics';
 import { WorkersClient } from './features/workers';
 import { WorkflowsClient } from './features/workflows';
 import { RunsClient } from './features/runs';
-import { InputType, OutputType, UnknownInputType, StrictWorkflowOutputType } from '../types';
+import { InputType, OutputType, UnknownInputType, StrictWorkflowOutputType, Resolved } from '../types';
 import { RatelimitsClient } from './features';
 import { AdminClient } from './admin';
 import { FiltersClient } from './features/filters';
@@ -21,11 +21,16 @@ import { CronClient } from './features/crons';
 import { CELClient } from './features/cel';
 import { TenantClient } from './features/tenant';
 import { WebhooksClient } from './features/webhooks';
+type MergeIfNonEmpty<Base, Extra extends Record<string, any>> = keyof Extra extends never ? Base : Base & Extra;
 /**
  * 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.
+ *
+ * @template GlobalInput - Global input type required by all tasks. Set via `init<T>()`. Defaults to `{}`.
+ * @template MiddlewareBefore - Extra fields merged into task input by pre-middleware hooks. Inferred from middleware config.
+ * @template MiddlewareAfter - Extra fields merged into task output by post-middleware hooks. Inferred from middleware config.
  */
-export declare class HatchetClient implements IHatchetClient {
+export declare class HatchetClient<GlobalInput extends Record<string, any> = {}, GlobalOutput extends Record<string, any> = {}, MiddlewareBefore extends Record<string, any> = {}, MiddlewareAfter extends Record<string, any> = {}> implements IHatchetClient {
     /** The underlying v0 client instance */
     _v0: LegacyHatchetClient;
     _api: Api;
@@ -47,12 +52,22 @@ export declare class HatchetClient implements IHatchetClient {
     constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig);
     /**
      * Static factory method to create a new Hatchet client instance.
-     * @param config - Optional configuration for the client
-     * @param options - Optional client options
-     * @param axiosConfig - Optional Axios configuration for HTTP requests
-     * @returns A new Hatchet client instance
-     */
-    static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient;
+     * @template T - Global input type required by all tasks created from this client. Defaults to `{}`.
+     * @template U - Global output type required by all tasks created from this client. Defaults to `{}`.
+     * @param config - Optional configuration for the client.
+     * @param options - Optional client options.
+     * @param axiosConfig - Optional Axios configuration for HTTP requests.
+     * @returns A new Hatchet client instance. Chain `.withMiddleware()` to attach typed middleware.
+     */
+    static init<T extends Record<string, any> = {}, U extends Record<string, any> = {}>(config?: Omit<Partial<ClientConfig>, 'middleware'>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient<T, U>;
+    /**
+     * Attaches middleware to this client and returns a re-typed instance
+     * with inferred pre/post middleware types.
+     *
+     * Use this after `init<T, U>()` to get full middleware return-type inference
+     * that TypeScript can't provide when global types are explicitly set on `init`.
+     */
+    withMiddleware<const M extends TaskMiddleware<Resolved<GlobalInput, MiddlewareBefore>, Resolved<GlobalOutput, MiddlewareAfter>>>(middleware: M): HatchetClient<GlobalInput, GlobalOutput, MiddlewareBefore & InferMiddlewareBefore<M>, MiddlewareAfter & InferMiddlewareAfter<M>>;
     private _config;
     get config(): ClientConfig;
     /**
@@ -63,7 +78,7 @@ export declare class HatchetClient implements IHatchetClient {
      * @returns A new Workflow instance
      * @note It is possible to create an orphaned workflow if no client is available using @hatchet/client CreateWorkflow
      */
-    workflow<I extends InputType = UnknownInputType, O extends StrictWorkflowOutputType = {}>(options: CreateWorkflowOpts): WorkflowDeclaration<I, O>;
+    workflow<I extends InputType = UnknownInputType, O extends StrictWorkflowOutputType = {}>(options: CreateWorkflowOpts): WorkflowDeclaration<I, O, Resolved<GlobalInput, MiddlewareBefore>>;
     /**
      * Creates a new task workflow.
      * Types can be explicitly specified as generics or inferred from the function signature.
@@ -72,7 +87,7 @@ export declare class HatchetClient implements IHatchetClient {
      * @param options Task configuration options
      * @returns A TaskWorkflowDeclaration instance
      */
-    task<I extends InputType = UnknownInputType, O extends OutputType = void>(options: CreateTaskWorkflowOpts<I, O>): TaskWorkflowDeclaration<I, O>;
+    task<I extends InputType = UnknownInputType, O extends OutputType = void>(options: CreateTaskWorkflowOpts<I & Resolved<GlobalInput, MiddlewareBefore>, MergeIfNonEmpty<O, GlobalOutput>>): TaskWorkflowDeclaration<I, O, GlobalInput, GlobalOutput, MiddlewareBefore, MiddlewareAfter>;
     /**
      * 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
@@ -81,7 +96,7 @@ export declare class HatchetClient implements IHatchetClient {
      */
     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>;
+    } & Omit<CreateTaskWorkflowOpts<I, O>, 'fn'>): TaskWorkflowDeclaration<I, O, GlobalInput, GlobalOutput, MiddlewareBefore, MiddlewareAfter>;
     /**
      * Creates a new durable task workflow.
      * Types can be explicitly specified as generics or inferred from the function signature.
@@ -90,7 +105,7 @@ export declare class HatchetClient implements IHatchetClient {
      * @param options Durable task configuration options
      * @returns A TaskWorkflowDeclaration instance for a durable task
      */
-    durableTask<I extends InputType, O extends OutputType>(options: CreateDurableTaskWorkflowOpts<I, O>): TaskWorkflowDeclaration<I, O>;
+    durableTask<I extends InputType, O extends OutputType>(options: CreateDurableTaskWorkflowOpts<I & Resolved<GlobalInput, MiddlewareBefore>, MergeIfNonEmpty<O, GlobalOutput>>): TaskWorkflowDeclaration<I, O, GlobalInput, GlobalOutput, MiddlewareBefore, MiddlewareAfter>;
     /**
      * 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
@@ -99,7 +114,7 @@ export declare class HatchetClient implements IHatchetClient {
      */
     durableTask<Fn extends (input: I, ctx: V0DurableContext<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<CreateDurableTaskWorkflowOpts<I, O>, 'fn'>): TaskWorkflowDeclaration<I, O>;
+    } & Omit<CreateDurableTaskWorkflowOpts<I, O>, 'fn'>): TaskWorkflowDeclaration<I, O, GlobalInput, GlobalOutput, MiddlewareBefore, MiddlewareAfter>;
     /**
      * Triggers a workflow run without waiting for completion.
      * @template I - The input type for the workflow
@@ -255,3 +270,4 @@ export declare class HatchetClient implements IHatchetClient {
     v0webhooks(workflows: V0Workflow[]): import("../../clients/worker/handler").WebhookHandler;
     runRef<T extends Record<string, any> = any>(id: string): WorkflowRunRef<T>;
 }
+export {};

package/v1/client/client.js

@@ -41,6 +41,10 @@ const webhooks_1 = require("./features/webhooks");
 /**
  * HatchetV1 implements the main client interface for interacting with the Hatchet workflow engine.
  * It provides methods for creating and executing workflows, as well as managing workers.
+ *
+ * @template GlobalInput - Global input type required by all tasks. Set via `init<T>()`. Defaults to `{}`.
+ * @template MiddlewareBefore - Extra fields merged into task input by pre-middleware hooks. Inferred from middleware config.
+ * @template MiddlewareAfter - Extra fields merged into task output by post-middleware hooks. Inferred from middleware config.
  */
 class HatchetClient {
     /**
@@ -105,14 +109,38 @@ class HatchetClient {
     }
     /**
      * Static factory method to create a new Hatchet client instance.
-     * @param config - Optional configuration for the client
-     * @param options - Optional client options
-     * @param axiosConfig - Optional Axios configuration for HTTP requests
-     * @returns A new Hatchet client instance
+     * @template T - Global input type required by all tasks created from this client. Defaults to `{}`.
+     * @template U - Global output type required by all tasks created from this client. Defaults to `{}`.
+     * @param config - Optional configuration for the client.
+     * @param options - Optional client options.
+     * @param axiosConfig - Optional Axios configuration for HTTP requests.
+     * @returns A new Hatchet client instance. Chain `.withMiddleware()` to attach typed middleware.
      */
     static init(config, options, axiosConfig) {
         return new HatchetClient(config, options, axiosConfig);
     }
+    /**
+     * Attaches middleware to this client and returns a re-typed instance
+     * with inferred pre/post middleware types.
+     *
+     * Use this after `init<T, U>()` to get full middleware return-type inference
+     * that TypeScript can't provide when global types are explicitly set on `init`.
+     */
+    withMiddleware(middleware) {
+        const existing = this._config.middleware || {};
+        const toArray = (v) => {
+            if (v == null)
+                return [];
+            if (Array.isArray(v))
+                return [...v];
+            return [v];
+        };
+        this._config.middleware = {
+            before: [...toArray(existing.before), ...toArray(middleware.before)],
+            after: [...toArray(existing.after), ...toArray(middleware.after)],
+        };
+        return this;
+    }
     get config() {
         return this._config;
     }

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

@@ -424,7 +424,30 @@ class V1Worker {
                         childIndex: 0,
                         desiredWorkerId: this.workerId || '',
                     });
-                    return step(context);
+                    const { middleware } = this.client.config;
+                    if (middleware === null || middleware === void 0 ? void 0 : middleware.before) {
+                        const hooks = Array.isArray(middleware.before) ? middleware.before : [middleware.before];
+                        for (const hook of hooks) {
+                            const returned = yield hook(context.input, context);
+                            if (returned !== undefined) {
+                                context.input = returned;
+                                if (context.data && typeof context.data === 'object') {
+                                    context.data.input = returned;
+                                }
+                            }
+                        }
+                    }
+                    let result = yield step(context);
+                    if (middleware === null || middleware === void 0 ? void 0 : middleware.after) {
+                        const hooks = Array.isArray(middleware.after) ? middleware.after : [middleware.after];
+                        for (const hook of hooks) {
+                            const returned = yield hook(result, context, context.input);
+                            if (returned !== undefined) {
+                                result = returned;
+                            }
+                        }
+                    }
+                    return result;
                 });
                 const success = (result) => __awaiter(this, void 0, void 0, function* () {
                     try {

package/v1/declaration.d.ts

@@ -6,7 +6,7 @@ import { IHatchetClient } from './client/client.interface';
 import { CreateWorkflowTaskOpts, CreateOnFailureTaskOpts, TaskFn, CreateWorkflowDurableTaskOpts, CreateBaseTaskOpts, CreateOnSuccessTaskOpts, Concurrency, DurableTaskFn } from './task';
 import { Duration } from './client/duration';
 import { MetricsClient } from './client/features/metrics';
-import { InputType, OutputType, UnknownInputType, JsonObject } from './types';
+import { InputType, OutputType, UnknownInputType, JsonObject, Resolved } from './types';
 import { Context, DurableContext } from './client/worker/context';
 export declare enum Priority {
     LOW = 1,
@@ -290,7 +290,7 @@ export declare class BaseWorkflowDeclaration<I extends InputType = UnknownInputT
      */
     get name(): string;
 }
-export declare class WorkflowDeclaration<I extends InputType = UnknownInputType, O extends OutputType = void> extends BaseWorkflowDeclaration<I, O> {
+export declare class WorkflowDeclaration<I extends InputType = UnknownInputType, O extends OutputType = void, MiddlewareBefore extends Record<string, any> = {}> extends BaseWorkflowDeclaration<I, O> {
     /**
      * Adds a task to the workflow.
      * The return type will be either the property on O that corresponds to the task name,
@@ -300,7 +300,7 @@ export declare class WorkflowDeclaration<I extends InputType = UnknownInputType,
      * @param options The task configuration options.
      * @returns The task options that were added.
      */
-    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'> & {
+    task<Name extends string, Fn extends Name extends keyof O ? (input: I & MiddlewareBefore, ctx: Context<I & MiddlewareBefore>) => O[Name] extends OutputType ? O[Name] | Promise<O[Name]> : void : (input: I & MiddlewareBefore, ctx: Context<I & MiddlewareBefore>) => 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?: Fn;
     }) | TaskWorkflowDeclaration<I, TO>): CreateWorkflowTaskOpts<I, TO>;
@@ -335,25 +335,73 @@ export declare class WorkflowDeclaration<I extends InputType = UnknownInputType,
      * @param options The task configuration options.
      * @returns The task options that were added.
      */
-    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'> & {
+    durableTask<Name extends string, Fn extends Name extends keyof O ? (input: I & MiddlewareBefore, ctx: DurableContext<I & MiddlewareBefore>) => O[Name] extends OutputType ? O[Name] | Promise<O[Name]> : void : (input: I & MiddlewareBefore, ctx: DurableContext<I & MiddlewareBefore>) => 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: Fn;
     }): CreateWorkflowDurableTaskOpts<I, TO>;
 }
-export declare class TaskWorkflowDeclaration<I extends InputType = UnknownInputType, O extends OutputType = void> extends BaseWorkflowDeclaration<I, O> {
+/**
+ * A standalone task workflow that can be run, scheduled, or triggered via cron.
+ *
+ * @template I - The task-specific input type.
+ * @template O - The task output type.
+ * @template GlobalInput - Global input type from the client, merged into all run/schedule/cron input signatures.
+ * @template MiddlewareBefore - Extra fields added to the task fn input by pre-middleware hooks.
+ * @template MiddlewareAfter - Extra fields merged into the task output by post-middleware hooks.
+ */
+export declare class TaskWorkflowDeclaration<I extends InputType = UnknownInputType, O extends OutputType = void, GlobalInput extends Record<string, any> = {}, GlobalOutput extends Record<string, any> = {}, MiddlewareBefore extends Record<string, any> = {}, MiddlewareAfter extends Record<string, any> = {}> 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[]>;
+    constructor(options: CreateTaskWorkflowOpts<any, any>, client?: IHatchetClient);
     /**
-     * Triggers a workflow run without waiting for completion.
-     * @param input The input data for the workflow.
-     * @param options Optional configuration for this workflow run.
-     * @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.
+     * Triggers a task run and waits for the result.
+     * @param input - The input data for the task, including global input fields.
+     * @param options - Optional configuration for this task run.
+     * @returns A promise that resolves with the task output merged with post-middleware fields.
+     */
+    runAndWait(input: I & GlobalInput, options?: RunOpts): Promise<O & Resolved<GlobalOutput, MiddlewareAfter>>;
+    runAndWait(input: (I & GlobalInput)[], options?: RunOpts): Promise<(O & Resolved<GlobalOutput, MiddlewareAfter>)[]>;
+    /**
+     * Triggers a task run and waits for the result.
+     * @param input - The input data for the task, including global input fields.
+     * @param options - Optional configuration for this task run.
+     * @returns A promise that resolves with the task output merged with post-middleware fields.
+     */
+    run(input: I & GlobalInput, options?: RunOpts): Promise<O & Resolved<GlobalOutput, MiddlewareAfter>>;
+    run(input: (I & GlobalInput)[], options?: RunOpts): Promise<(O & Resolved<GlobalOutput, MiddlewareAfter>)[]>;
+    /**
+     * Triggers a task run without waiting for completion.
+     * @param input - The input data for the task, including global input fields.
+     * @param options - Optional configuration for this task run.
+     * @returns A WorkflowRunRef containing the run ID and methods to get results.
+     */
+    runNoWait(input: I & GlobalInput, options?: RunOpts): Promise<WorkflowRunRef<O & Resolved<GlobalOutput, MiddlewareAfter>>>;
+    runNoWait(input: (I & GlobalInput)[], options?: RunOpts): Promise<WorkflowRunRef<O & Resolved<GlobalOutput, MiddlewareAfter>>[]>;
+    /**
+     * Schedules the task to run at a specific date and time.
+     * @param enqueueAt - The date when the task should be triggered.
+     * @param input - The input data for the task, including global input fields.
+     * @param options - Optional configuration for this task run.
+     * @returns A promise that resolves with the scheduled workflow details.
+     */
+    schedule(enqueueAt: Date, input: I & GlobalInput, options?: RunOpts): Promise<ScheduledWorkflows>;
+    /**
+     * Schedules the task to run after a specified delay.
+     * @param duration - The delay in seconds before the task should run.
+     * @param input - The input data for the task, including global input fields.
+     * @param options - Optional configuration for this task run.
+     * @returns A promise that resolves with the scheduled workflow details.
+     */
+    delay(duration: number, input: I & GlobalInput, options?: RunOpts): Promise<ScheduledWorkflows>;
+    /**
+     * Creates a cron schedule for the task.
+     * @param name - The name of the cron schedule.
+     * @param expression - The cron expression defining the schedule.
+     * @param input - The input data for the task, including global input fields.
+     * @param options - Optional configuration for this task run.
+     * @returns A promise that resolves with the cron workflow details.
      */
-    runNoWait(input: I, options?: RunOpts): Promise<WorkflowRunRef<O>>;
-    runNoWait(input: I[], options?: RunOpts): Promise<WorkflowRunRef<O>[]>;
+    cron(name: string, expression: string, input: I & GlobalInput, options?: RunOpts): Promise<CronWorkflows>;
+    /** Returns the underlying task definition for this declaration. */
     get taskDef(): CreateWorkflowTaskOpts<any, any>;
 }
 /**