@hatchet-dev/typescript-sdk 1.0.6 → 1.1.0

package/README.md

@@ -0,0 +1,109 @@
+# Hatchet TypeScript SDK
+
+<div align="center">
+
+[![npm version](https://badge.fury.io/js/@hatchet-dev%2Ftypescript-sdk.svg)](https://badge.fury.io/js/@hatchet-dev%2Ftypescript-sdk)
+[![Documentation](https://img.shields.io/badge/docs-hatchet.run-blue)](https://docs.hatchet.run)
+[![License: MIT](https://img.shields.io/badge/License-MIT-purple.svg)](https://opensource.org/licenses/MIT)
+
+</div>
+
+This is the official TypeScript SDK for [Hatchet](https://hatchet.run), a distributed, fault-tolerant task queue. The SDK provides a type-safe way to integrate Hatchet's task scheduling and workflow orchestration capabilities into your TypeScript/JavaScript applications.
+
+## Installation
+
+Install the SDK using npm:
+
+```bash
+npm install @hatchet-dev/typescript-sdk
+```
+
+Using yarn:
+
+```bash
+yarn add @hatchet-dev/typescript-sdk
+```
+
+Using pnpm:
+
+```bash
+pnpm add @hatchet-dev/typescript-sdk
+```
+
+## Quick Start
+
+Here's a simple example of how to use the Hatchet TypeScript SDK:
+
+```typescript
+import { HatchetClient } from '@hatchet-dev/typescript-sdk';
+
+export const hatchet = HatchetClient.init();
+
+export type SimpleInput = {
+  Message: string;
+};
+
+export const simple = hatchet.task({
+  name: 'simple',
+  fn: (input: SimpleInput) => {
+    return {
+      TransformedMessage: input.Message.toLowerCase(),
+    };
+  },
+});
+
+async function main() {
+  const worker = await hatchet.worker('simple-worker', {
+    workflows: [simple],
+    slots: 100,
+  });
+
+  await worker.start();
+}
+
+if (require.main === module) {
+  main();
+}
+```
+
+## Features
+
+- 📝 **Type Safety**: Full TypeScript support with type inference for workflow inputs and outputs
+- 🔄 **Workflow Orchestration**: Define complex workflows with dependencies and parallel execution
+- 🔁 **Automatic Retries**: Configure retry policies for handling transient failures
+- 📊 **Observability**: Track workflow progress and monitor execution metrics
+- ⏰ **Scheduling**: Schedule workflows to run at specific times or on a recurring basis
+- 🔄 **Event-Driven**: Trigger workflows based on events in your system
+
+## Documentation
+
+For detailed documentation, examples, and best practices, visit:
+- [Hatchet Documentation](https://docs.hatchet.run)
+- [Examples](https://github.com/hatchet-dev/hatchet/tree/main/sdks/typescript/src/v1/examples)
+
+## Development
+
+We use `pnpm` as our package manager. To get started with development:
+
+1. Install dependencies:
+```bash
+pnpm install
+```
+
+2. Build the SDK:
+```bash
+pnpm build
+```
+
+3. Run tests:
+```bash
+pnpm test
+```
+
+## Contributing
+
+We welcome contributions! Please check out our [contributing guidelines](https://docs.hatchet.run/contributing) and join our [Discord community](https://discord.gg/ZMeUafwH89) for discussions and support.
+
+## License
+
+This SDK is released under the MIT License. See [LICENSE](https://github.com/hatchet-dev/hatchet/blob/main/LICENSE) for details.

package/clients/rest/generated/Api.js

@@ -1,6 +1,7 @@
 "use strict";
 /* eslint-disable */
 /* tslint:disable */
+// @ts-nocheck
 /*
  * ---------------------------------------------------------------
  * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##

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

@@ -212,8 +212,10 @@ export declare enum TenantMemberRole {
 }
 export declare enum TenantResource {
     WORKER = "WORKER",
+    WORKER_SLOT = "WORKER_SLOT",
     EVENT = "EVENT",
     WORKFLOW_RUN = "WORKFLOW_RUN",
+    TASK_RUN = "TASK_RUN",
     CRON = "CRON",
     SCHEDULE = "SCHEDULE"
 }

package/clients/rest/generated/data-contracts.js

@@ -1,6 +1,7 @@
 "use strict";
 /* eslint-disable */
 /* tslint:disable */
+// @ts-nocheck
 /*
  * ---------------------------------------------------------------
  * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
@@ -20,8 +21,10 @@ var TenantMemberRole;
 var TenantResource;
 (function (TenantResource) {
     TenantResource["WORKER"] = "WORKER";
+    TenantResource["WORKER_SLOT"] = "WORKER_SLOT";
     TenantResource["EVENT"] = "EVENT";
     TenantResource["WORKFLOW_RUN"] = "WORKFLOW_RUN";
+    TenantResource["TASK_RUN"] = "TASK_RUN";
     TenantResource["CRON"] = "CRON";
     TenantResource["SCHEDULE"] = "SCHEDULE";
 })(TenantResource || (exports.TenantResource = TenantResource = {}));

package/clients/rest/generated/http-client.js

@@ -1,6 +1,7 @@
 "use strict";
 /* eslint-disable */
 /* tslint:disable */
+// @ts-nocheck
 /*
  * ---------------------------------------------------------------
  * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##

package/clients/worker/worker.d.ts

@@ -51,7 +51,7 @@ export declare class V0Worker {
     registerAction<T, K>(actionId: string, action: StepRunFunction<T, K>): void;
     handleStartStepRun(action: Action): Promise<void>;
     handleStartGroupKeyRun(action: Action): Promise<void>;
-    getStepActionEvent(action: Action, eventType: StepActionEventType, payload?: any): StepActionEvent;
+    getStepActionEvent(action: Action, eventType: StepActionEventType, shouldNotRetry: boolean, payload?: any): StepActionEvent;
     getGroupKeyActionEvent(action: Action, eventType: GroupKeyActionEventType, payload?: any): GroupKeyActionEvent;
     handleCancelStepRun(action: Action): Promise<void>;
     stop(): Promise<void>;

package/clients/worker/worker.js

@@ -25,6 +25,7 @@ const dispatcher_1 = require("../../protoc/dispatcher");
 const hatchet_promise_1 = __importDefault(require("../../util/hatchet-promise/hatchet-promise"));
 const workflows_1 = require("../../protoc/workflows");
 const handler_1 = require("./handler");
+const task_1 = require("../../v1/task");
 const transformer_1 = require("../../v1/conditions/transformer");
 const step_1 = require("../../step");
 class V0Worker {
@@ -345,13 +346,13 @@ class V0Worker {
                     this.logger.info(`Step run ${action.stepRunId} succeeded`);
                     try {
                         // Send the action event to the dispatcher
-                        const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_COMPLETED, result || null);
+                        const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_COMPLETED, false, result || null);
                         yield this.client.dispatcher.sendStepActionEvent(event);
                     }
                     catch (actionEventError) {
                         this.logger.error(`Could not send completed action event: ${actionEventError.message || actionEventError}`);
                         // send a failure event
-                        const failureEvent = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, actionEventError.message);
+                        const failureEvent = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, false, actionEventError.message);
                         try {
                             yield this.client.dispatcher.sendStepActionEvent(failureEvent);
                         }
@@ -371,9 +372,10 @@ class V0Worker {
                     if (error.stack) {
                         this.logger.error(error.stack);
                     }
+                    const shouldNotRetry = error instanceof task_1.NonRetryableError;
                     try {
                         // Send the action event to the dispatcher
-                        const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, {
+                        const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, shouldNotRetry, {
                             message: error === null || error === void 0 ? void 0 : error.message,
                             stack: error === null || error === void 0 ? void 0 : error.stack,
                         });
@@ -401,7 +403,7 @@ class V0Worker {
                 }))());
                 this.futures[action.stepRunId] = future;
                 // Send the action event to the dispatcher
-                const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_STARTED);
+                const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_STARTED, false);
                 this.client.dispatcher.sendStepActionEvent(event).catch((e) => {
                     this.logger.error(`Could not send action event: ${e.message}`);
                 });
@@ -487,7 +489,7 @@ class V0Worker {
             }
         });
     }
-    getStepActionEvent(action, eventType, payload = '') {
+    getStepActionEvent(action, eventType, shouldNotRetry, payload = '') {
         return {
             workerId: this.name,
             jobId: action.jobId,
@@ -498,6 +500,7 @@ class V0Worker {
             eventTimestamp: new Date(),
             eventType,
             eventPayload: JSON.stringify(payload),
+            shouldNotRetry,
         };
     }
     getGroupKeyActionEvent(action, eventType, payload = '') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.0.6",
+  "version": "1.1.0",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -8,11 +8,12 @@
     "!**/*.test.js",
     "!**/*.test.d.ts",
     "!**/*.e2e.js",
-    "!**/*.e2e.d.ts"
+    "!**/*.e2e.d.ts",
+    "README.md"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/hatchet-dev/hatchet-typescript.git"
+    "url": "https://github.com/hatchet-dev/hatchet.git"
   },
   "scripts": {
     "build": "echo 'build hatchet sdk with `npm run tsc:build` to ensure it is not build during the publish step' && exit 0",
@@ -23,7 +24,7 @@
     "test:e2e": "jest --testMatch='**/*.e2e.ts'",
     "test:unit:watch": "jest --testMatch='**/*.test.ts' --watch",
     "generate": "pnpm run '/generate-.*/'",
-    "generate-api": "npx --yes swagger-cli bundle ../../api-contracts/openapi/openapi.yaml --outfile openapi.yaml --type yaml && npx swagger-typescript-api -p openapi.yaml -o src/clients/rest/generated -n hatchet.ts --modular --axios",
+    "generate-api": "npx --yes swagger-cli bundle ../../api-contracts/openapi/openapi.yaml --outfile openapi.yaml --type yaml && npx swagger-typescript-api generate -p openapi.yaml -o src/clients/rest/generated -n hatchet.ts --modular --axios",
     "generate-protoc": "./generate-protoc.sh",
     "lint:check": "npm run eslint:check && npm run prettier:check",
     "lint:fix": "npm run eslint:fix && npm run prettier:fix",
@@ -60,8 +61,10 @@
     "worker:multi-workflow": "npm run exec -- ./src/examples/multi-workflow.ts",
     "worker:logger": "npm run exec -- ./src/examples/logger.ts",
     "worker:byo-logger": "npm run exec -- ./src/examples/byo-logger.ts",
+    "worker:no-retry": "npm run exec -- ./src/v1/examples/non_retryable/worker.ts",
+    "worker:no-retry:trigger": "npm run exec -- ./src/v1/examples/non_retryable/run.ts",
     "api": "npm run exec -- ./src/examples/api.ts",
-    "prepublish": "cp package.json dist/package.json;",
+    "prepublish": "cp package.json dist/package.json; cp README.md dist/",
     "publish:ci": "rm -rf ./dist && npm run dump-version && npm run tsc:build && npm run prepublish && cd dist && npm publish --access public --no-git-checks",
     "publish:ci:alpha": "rm -rf ./dist && npm run dump-version && npm run tsc:build && npm run prepublish && cd dist && npm publish --access public --no-git-checks --tag alpha",
     "generate-docs": "typedoc"
@@ -71,49 +74,50 @@
   "license": "MIT",
   "devDependencies": {
     "@tsd/typescript": "^5.8.2",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
     "@types/jest": "^29.5.14",
-    "@types/node": "^22.0.0",
-    "@typescript-eslint/eslint-plugin": "^6.4.0",
-    "autoprefixer": "^10.4.16",
-    "dotenv-cli": "^7.3.0",
+    "@types/node": "^22.13.14",
+    "autoprefixer": "^10.4.21",
+    "dotenv-cli": "^7.4.4",
     "eslint": "^8.56.0",
-    "eslint-config-airbnb-typescript": "^18.0.0",
+    "eslint-config-airbnb-typescript": "^17.1.0",
     "eslint-config-prettier": "^9.1.0",
-    "eslint-config-standard-with-typescript": "^43.0.0",
-    "eslint-import-resolver-typescript": "^3.6.1",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-jest": "^28.5.0",
-    "eslint-plugin-n": "^15.0.0 || ^16.0.0 ",
-    "eslint-plugin-prettier": "^5.0.1",
-    "eslint-plugin-promise": "^6.0.0",
-    "eslint-plugin-react": "^7.34.1",
-    "eslint-plugin-react-hooks": "^4.6.0",
-    "eslint-plugin-react-refresh": "^0.4.6",
-    "eslint-plugin-unused-imports": "^4.1.3",
-    "grpc-tools": "^1.12.4",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-import-resolver-typescript": "^3.10.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-jest": "^28.11.0",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-prettier": "^5.2.5",
+    "eslint-plugin-promise": "^6.6.0",
+    "eslint-plugin-react": "^7.37.4",
+    "eslint-plugin-react-hooks": "^4.6.2",
+    "eslint-plugin-react-refresh": "^0.4.19",
+    "eslint-plugin-unused-imports": "^4.1.4",
+    "grpc-tools": "^1.13.0",
     "jest": "^29.7.0",
     "jest-tsd": "^0.2.2",
     "pino": "^9.6.0",
-    "prettier": "^3.1.1",
-    "resolve-tspaths": "^0.8.17",
-    "ts-jest": "^29.1.1",
+    "prettier": "^3.5.3",
+    "resolve-tspaths": "^0.8.23",
+    "ts-jest": "^29.3.1",
     "ts-node": "^10.9.2",
-    "ts-proto": "^2.0.2",
-    "typedoc": "^0.27.1",
-    "typedoc-plugin-markdown": "^4.0.2",
-    "typescript": "^5.3.3"
+    "ts-proto": "^2.7.0",
+    "typedoc": "^0.28.0",
+    "typedoc-plugin-markdown": "^4.6.0",
+    "typescript": "^5.8.2"
   },
   "dependencies": {
-    "@bufbuild/protobuf": "^2.1.0",
-    "@types/qs": "^6.9.11",
+    "@bufbuild/protobuf": "^2.2.5",
+    "@types/qs": "^6.9.18",
     "abort-controller-x": "^0.4.3",
-    "axios": "^1.6.7",
-    "long": "^5.2.3",
-    "nice-grpc": "^2.1.7",
+    "axios": "^1.8.4",
+    "long": "^5.3.1",
+    "nice-grpc": "^2.1.12",
     "nice-grpc-common": "^2.0.2",
-    "protobufjs": "^7.2.6",
-    "qs": "^6.11.2",
-    "yaml": "^2.3.4",
-    "zod": "^3.22.4"
+    "protobufjs": "^7.4.0",
+    "qs": "^6.14.0",
+    "yaml": "^2.7.1",
+    "zod": "^3.24.2"
   }
 }

package/protoc/dispatcher/dispatcher.d.ts

@@ -130,8 +130,6 @@ export interface AssignedAction {
     workflowRunId: string;
     /** the get group key run id (optional) */
     getGroupKeyRunId: string;
-    /** task id */
-    taskId?: number;
     /** the job id */
     jobId: string;
     /** the job name */
@@ -209,6 +207,8 @@ export interface StepActionEvent {
     eventPayload: string;
     /** the retry count */
     retryCount?: number | undefined;
+    /** a flag indicating if the task should _not_ be retried */
+    shouldNotRetry?: boolean | undefined;
 }
 export interface ActionEventResponse {
     /** the tenant id */

package/protoc/dispatcher/dispatcher.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.6.1
+//   protoc-gen-ts_proto  v2.7.0
 //   protoc               v3.19.1
 // source: dispatcher/dispatcher.proto
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -1737,6 +1737,7 @@ function createBaseStepActionEvent() {
         eventType: 0,
         eventPayload: '',
         retryCount: undefined,
+        shouldNotRetry: undefined,
     };
 }
 exports.StepActionEvent = {
@@ -1771,6 +1772,9 @@ exports.StepActionEvent = {
         if (message.retryCount !== undefined) {
             writer.uint32(80).int32(message.retryCount);
         }
+        if (message.shouldNotRetry !== undefined) {
+            writer.uint32(88).bool(message.shouldNotRetry);
+        }
         return writer;
     },
     decode(input, length) {
@@ -1850,6 +1854,13 @@ exports.StepActionEvent = {
                     message.retryCount = reader.int32();
                     continue;
                 }
+                case 11: {
+                    if (tag !== 88) {
+                        break;
+                    }
+                    message.shouldNotRetry = reader.bool();
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -1872,6 +1883,9 @@ exports.StepActionEvent = {
             eventType: isSet(object.eventType) ? stepActionEventTypeFromJSON(object.eventType) : 0,
             eventPayload: isSet(object.eventPayload) ? globalThis.String(object.eventPayload) : '',
             retryCount: isSet(object.retryCount) ? globalThis.Number(object.retryCount) : undefined,
+            shouldNotRetry: isSet(object.shouldNotRetry)
+                ? globalThis.Boolean(object.shouldNotRetry)
+                : undefined,
         };
     },
     toJSON(message) {
@@ -1906,13 +1920,16 @@ exports.StepActionEvent = {
         if (message.retryCount !== undefined) {
             obj.retryCount = Math.round(message.retryCount);
         }
+        if (message.shouldNotRetry !== undefined) {
+            obj.shouldNotRetry = message.shouldNotRetry;
+        }
         return obj;
     },
     create(base) {
         return exports.StepActionEvent.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         const message = createBaseStepActionEvent();
         message.workerId = (_a = object.workerId) !== null && _a !== void 0 ? _a : '';
         message.jobId = (_b = object.jobId) !== null && _b !== void 0 ? _b : '';
@@ -1924,6 +1941,7 @@ exports.StepActionEvent = {
         message.eventType = (_h = object.eventType) !== null && _h !== void 0 ? _h : 0;
         message.eventPayload = (_j = object.eventPayload) !== null && _j !== void 0 ? _j : '';
         message.retryCount = (_k = object.retryCount) !== null && _k !== void 0 ? _k : undefined;
+        message.shouldNotRetry = (_l = object.shouldNotRetry) !== null && _l !== void 0 ? _l : undefined;
         return message;
     },
 };

package/protoc/events/events.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.6.1
+//   protoc-gen-ts_proto  v2.7.0
 //   protoc               v3.19.1
 // source: events/events.proto
 Object.defineProperty(exports, "__esModule", { value: true });

package/protoc/google/protobuf/timestamp.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.6.1
+//   protoc-gen-ts_proto  v2.7.0
 //   protoc               v3.19.1
 // source: google/protobuf/timestamp.proto
 Object.defineProperty(exports, "__esModule", { value: true });

package/protoc/v1/dispatcher.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.6.1
+//   protoc-gen-ts_proto  v2.7.0
 //   protoc               v3.19.1
 // source: v1/dispatcher.proto
 Object.defineProperty(exports, "__esModule", { value: true });

package/protoc/v1/shared/condition.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.6.1
+//   protoc-gen-ts_proto  v2.7.0
 //   protoc               v3.19.1
 // source: v1/shared/condition.proto
 Object.defineProperty(exports, "__esModule", { value: true });

package/protoc/v1/workflows.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.6.1
+//   protoc-gen-ts_proto  v2.7.0
 //   protoc               v3.19.1
 // source: v1/workflows.proto
 Object.defineProperty(exports, "__esModule", { value: true });

package/protoc/workflows/workflows.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.6.1
+//   protoc-gen-ts_proto  v2.7.0
 //   protoc               v3.19.1
 // source: workflows/workflows.proto
 Object.defineProperty(exports, "__esModule", { value: true });

package/step.js

@@ -47,6 +47,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DurableContext = exports.Context = exports.ContextWorker = exports.CreateStepSchema = exports.DesiredWorkerLabelSchema = exports.CreateRateLimitSchema = void 0;
 exports.mapRateLimit = mapRateLimit;
+/* eslint-disable no-underscore-dangle */
 /* eslint-disable max-classes-per-file */
 const hatchet_error_1 = __importDefault(require("./util/errors/hatchet-error"));
 const z = __importStar(require("zod"));
@@ -351,7 +352,9 @@ class Context {
      * @returns A list of workflow run references to the enqueued runs.
      */
     bulkRunNoWaitChildren(children) {
-        return this.spawnWorkflows(children);
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.spawnWorkflows(children);
+        });
     }
     /**
      * Runs multiple children workflows in parallel and waits for all results.
@@ -361,15 +364,7 @@ class Context {
     bulkRunChildren(children) {
         return __awaiter(this, void 0, void 0, function* () {
             const runs = yield this.bulkRunNoWaitChildren(children);
-            const res = runs.map((run, index) => __awaiter(this, void 0, void 0, function* () {
-                const wf = children[index].workflow;
-                if (wf instanceof declaration_1.TaskWorkflowDeclaration) {
-                    // eslint-disable-next-line no-underscore-dangle
-                    return (yield run.output)[wf._standalone_task_name];
-                }
-                return run.output;
-            }));
-            return Promise.all(res);
+            return Promise.all(runs.map((run) => run.output));
         });
     }
     /**
@@ -380,49 +375,60 @@ class Context {
      * @deprecated Use bulkRunNoWaitChildren or bulkRunChildren instead.
      */
     spawnWorkflows(workflows) {
-        const { workflowRunId, stepRunId } = this.action;
-        const workflowRuns = workflows.map(({ workflow, input, options }) => {
-            let workflowName;
-            if (typeof workflow === 'string') {
-                workflowName = workflow;
-            }
-            else {
-                workflowName = workflow.id;
-            }
-            const name = this.client.config.namespace + workflowName;
-            let key;
-            let sticky = false;
-            let metadata;
-            if (options) {
-                key = options.key;
-                sticky = options.sticky;
-                metadata = options.additionalMetadata;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { workflowRunId, stepRunId } = this.action;
+            const workflowRuns = workflows.map(({ workflow, input, options }) => {
+                let workflowName;
+                if (typeof workflow === 'string') {
+                    workflowName = workflow;
+                }
+                else {
+                    workflowName = workflow.id;
+                }
+                const name = this.client.config.namespace + workflowName;
+                let key;
+                let sticky = false;
+                let metadata;
+                if (options) {
+                    key = options.key;
+                    sticky = options.sticky;
+                    metadata = options.additionalMetadata;
+                }
+                if (sticky && !this.worker.hasWorkflow(name)) {
+                    throw new hatchet_error_1.default(`Cannot run with sticky: workflow ${name} is not registered on the worker`);
+                }
+                const resp = {
+                    workflowName: name,
+                    input,
+                    options: {
+                        parentId: workflowRunId,
+                        parentStepRunId: stepRunId,
+                        childKey: key,
+                        childIndex: this.spawnIndex,
+                        desiredWorkerId: sticky ? this.worker.id() : undefined,
+                        additionalMetadata: metadata,
+                    },
+                };
+                this.spawnIndex += 1;
+                return resp;
+            });
+            try {
+                const resp = yield this.client.admin.runWorkflows(workflowRuns);
+                const res = [];
+                resp.forEach((ref, index) => {
+                    const wf = workflows[index].workflow;
+                    if (wf instanceof declaration_1.TaskWorkflowDeclaration) {
+                        // eslint-disable-next-line no-param-reassign
+                        ref._standalone_task_name = wf._standalone_task_name;
+                    }
+                    res.push(ref);
+                });
+                return resp;
             }
-            if (sticky && !this.worker.hasWorkflow(name)) {
-                throw new hatchet_error_1.default(`Cannot run with sticky: workflow ${name} is not registered on the worker`);
+            catch (e) {
+                throw new hatchet_error_1.default(e.message);
             }
-            const resp = {
-                workflowName: name,
-                input,
-                options: {
-                    parentId: workflowRunId,
-                    parentStepRunId: stepRunId,
-                    childKey: key,
-                    childIndex: this.spawnIndex,
-                    desiredWorkerId: sticky ? this.worker.id() : undefined,
-                    additionalMetadata: metadata,
-                },
-            };
-            this.spawnIndex += 1;
-            return resp;
         });
-        try {
-            const resp = this.client.admin.runWorkflows(workflowRuns);
-            return resp;
-        }
-        catch (e) {
-            throw new hatchet_error_1.default(e.message);
-        }
     }
     /**
      * Runs a new workflow and waits for its result.
@@ -435,13 +441,6 @@ class Context {
     runChild(workflow, input, optionsOrKey) {
         return __awaiter(this, void 0, void 0, function* () {
             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 (yield run.output)[workflow._standalone_task_name];
-                }
-            }
             return run.output;
         });
     }
@@ -500,6 +499,9 @@ class Context {
                 additionalMetadata: metadata,
             });
             this.spawnIndex += 1;
+            if (workflow instanceof declaration_1.TaskWorkflowDeclaration) {
+                resp._standalone_task_name = workflow._standalone_task_name;
+            }
             return resp;
         }
         catch (e) {

package/util/workflow-run-ref.d.ts

@@ -11,6 +11,7 @@ export default class WorkflowRunRef<T> {
     parentWorkflowRunId?: string;
     private client;
     private runs;
+    _standalone_task_name?: string;
     constructor(workflowRunId: string | Promise<string> | Promise<{
         workflowRunId: string;
     }>, client: RunListenerClient, runsClient?: RunsClient, parentWorkflowRunId?: string);

package/util/workflow-run-ref.js

@@ -118,11 +118,19 @@ class WorkflowRunRef {
                                             outputs[readableStepName] = stepRun.output;
                                         }
                                     });
-                                    resolve(outputs);
+                                    if (!this._standalone_task_name) {
+                                        resolve(outputs);
+                                        return;
+                                    }
+                                    resolve(outputs[this._standalone_task_name]);
                                     return;
                                 }
                                 const result = event.results.reduce((acc, r) => (Object.assign(Object.assign({}, acc), { [r.stepReadableId]: JSON.parse(r.output || '{}') })), {});
-                                resolve(result);
+                                if (!this._standalone_task_name) {
+                                    resolve(result);
+                                    return;
+                                }
+                                resolve(result[this._standalone_task_name]);
                                 return;
                             }
                         }

package/v1/client/client.d.ts

@@ -12,7 +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';
+import { InputType, OutputType, UnknownInputType, StrictWorkflowOutputType } 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.
@@ -52,7 +52,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 WorkflowOutputType = {}>(options: CreateWorkflowOpts): WorkflowDeclaration<I, O>;
+    workflow<I extends InputType = UnknownInputType, O extends StrictWorkflowOutputType = {}>(options: CreateWorkflowOpts): WorkflowDeclaration<I, O>;
     /**
      * Creates a new task workflow.
      * Types can be explicitly specified as generics or inferred from the function signature.

package/v1/declaration.d.ts

@@ -171,7 +171,7 @@ export declare class BaseWorkflowDeclaration<I extends InputType = UnknownInputT
      * @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: I, options?: RunOpts): WorkflowRunRef<O>;
+    runNoWait(input: I, options?: RunOpts, _standaloneTaskName?: string): WorkflowRunRef<O>;
     /**
      * @alias run
      * Triggers a workflow run and waits for the result.
@@ -181,8 +181,8 @@ export declare class BaseWorkflowDeclaration<I extends InputType = UnknownInputT
      * @param options - Configuration options for the workflow run
      * @returns A promise that resolves with the workflow result
      */
-    runAndWait(input: I, options?: RunOpts): Promise<O>;
-    runAndWait(input: I[], options?: RunOpts): Promise<O[]>;
+    runAndWait(input: I, options?: RunOpts, _standaloneTaskName?: string): Promise<O>;
+    runAndWait(input: I[], options?: RunOpts, _standaloneTaskName?: string): Promise<O[]>;
     /**
      * Executes the workflow with the given input and awaits the results.
      * @param input The input data for the workflow.
@@ -190,8 +190,8 @@ export declare class BaseWorkflowDeclaration<I extends InputType = UnknownInputT
      * @returns A promise that resolves with the workflow result.
      * @throws Error if the workflow is not bound to a Hatchet client.
      */
-    run(input: I, options?: RunOpts): Promise<O>;
-    run(input: I[], options?: RunOpts): Promise<O[]>;
+    run(input: I, options?: RunOpts, _standaloneTaskName?: string): Promise<O>;
+    run(input: I[], options?: RunOpts, _standaloneTaskName?: string): 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.
@@ -302,6 +302,14 @@ export declare class TaskWorkflowDeclaration<I extends InputType = UnknownInputT
     constructor(options: CreateTaskWorkflowOpts<I, O>, client?: IHatchetClient);
     run(input: I, options?: RunOpts): Promise<O>;
     run(input: I[], options?: RunOpts): Promise<O[]>;
+    /**
+     * 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.
+     */
+    runNoWait(input: I, options?: RunOpts): WorkflowRunRef<O>;
     get taskDef(): CreateWorkflowTaskOpts<any, any>;
 }
 /**

package/v1/declaration.js

@@ -36,33 +36,40 @@ class BaseWorkflowDeclaration {
      * @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, options) {
+    runNoWait(input, options, _standaloneTaskName) {
         if (!this.client) {
             throw UNBOUND_ERR;
         }
-        return this.client._v0.admin.runWorkflow(this.name, input, options);
+        const res = this.client._v0.admin.runWorkflow(this.name, input, options);
+        if (_standaloneTaskName) {
+            res._standalone_task_name = _standaloneTaskName;
+        }
+        return res;
     }
-    runAndWait(input, options) {
+    runAndWait(input, options, _standaloneTaskName) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.client) {
                 throw UNBOUND_ERR;
             }
             if (Array.isArray(input)) {
-                return Promise.all(input.map((i) => this.runAndWait(i, options)));
+                return Promise.all(input.map((i) => this.runAndWait(i, options, _standaloneTaskName)));
             }
-            return this.run(input, options);
+            return this.run(input, options, _standaloneTaskName);
         });
     }
-    run(input, options) {
+    run(input, options, _standaloneTaskName) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.client) {
                 throw UNBOUND_ERR;
             }
             if (Array.isArray(input)) {
                 // FIXME use bulk endpoint?
-                return Promise.all(input.map((i) => this.run(i, options)));
+                return Promise.all(input.map((i) => this.run(i, options, _standaloneTaskName)));
             }
             const res = this.client._v0.admin.runWorkflow(this.definition.name, input, options);
+            if (_standaloneTaskName) {
+                res._standalone_task_name = _standaloneTaskName;
+            }
             return res.result();
         });
     }
@@ -288,13 +295,22 @@ class TaskWorkflowDeclaration extends BaseWorkflowDeclaration {
             run: { get: () => super.run }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            const res = (yield _super.run.call(this, input, options));
-            if (Array.isArray(res)) {
-                return res.map((r) => r[this._standalone_task_name]);
-            }
-            return res[this._standalone_task_name];
+            return (yield _super.run.call(this, input, options, this._standalone_task_name));
         });
     }
+    /**
+     * 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.
+     */
+    runNoWait(input, options) {
+        if (!this.client) {
+            throw UNBOUND_ERR;
+        }
+        return super.runNoWait(input, options, this._standalone_task_name);
+    }
     get taskDef() {
         return this.definition._tasks[0];
     }

package/v1/examples/dag/interface-workflow.d.ts

@@ -0,0 +1,12 @@
+import { WorkflowInputType, WorkflowOutputType } from '../..';
+interface DagInput extends WorkflowInputType {
+    Message: string;
+}
+interface DagOutput extends WorkflowOutputType {
+    reverse: {
+        Original: string;
+        Transformed: string;
+    };
+}
+export declare const dag: import("../..").WorkflowDeclaration<DagInput, DagOutput>;
+export {};

package/v1/examples/dag/interface-workflow.js

@@ -0,0 +1,40 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dag = void 0;
+const hatchet_client_1 = require("../hatchet-client");
+// ❓ Declaring a DAG Workflow
+// First, we declare the workflow
+exports.dag = hatchet_client_1.hatchet.workflow({
+    name: 'simple',
+});
+const reverse = exports.dag.task({
+    name: 'reverse',
+    fn: (input) => {
+        return {
+            Original: input.Message,
+            Transformed: input.Message.split('').reverse().join(''),
+        };
+    },
+});
+exports.dag.task({
+    name: 'to-lower',
+    parents: [reverse],
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const r = yield ctx.parentOutput(reverse);
+        return {
+            reverse: {
+                Original: r.Transformed,
+                Transformed: r.Transformed.toLowerCase(),
+            },
+        };
+    }),
+});

package/v1/examples/non_retryable/run.d.ts

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

package/v1/examples/non_retryable/run.js

@@ -0,0 +1,22 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield workflow_1.nonRetryableWorkflow.runNoWait({});
+        // eslint-disable-next-line no-console
+        console.log(res);
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/non_retryable/worker.d.ts

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

package/v1/examples/non_retryable/worker.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const hatchet_client_1 = require("../hatchet-client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('no-retry-worker', {
+            workflows: [workflow_1.nonRetryableWorkflow],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

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

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

package/v1/examples/non_retryable/workflow.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nonRetryableWorkflow = void 0;
+const task_1 = require("../../task");
+const hatchet_client_1 = require("../hatchet-client");
+exports.nonRetryableWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'no-retry-workflow',
+});
+// ❓ Non-retrying task
+const shouldNotRetry = exports.nonRetryableWorkflow.task({
+    name: 'should-not-retry',
+    fn: () => {
+        throw new task_1.NonRetryableError('This task should not retry');
+    },
+    retries: 1,
+});
+// !!
+// Create a task that should retry
+const shouldRetryWrongErrorType = exports.nonRetryableWorkflow.task({
+    name: 'should-retry-wrong-error-type',
+    fn: () => {
+        throw new Error('This task should not retry');
+    },
+    retries: 1,
+});
+const shouldNotRetrySuccessfulTask = exports.nonRetryableWorkflow.task({
+    name: 'should-not-retry-successful-task',
+    fn: () => { },
+});

package/v1/examples/simple/worker.js

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

package/v1/examples/simple/workflow-with-child.d.ts

@@ -0,0 +1,12 @@
+export type ChildInput = {
+    Message: string;
+};
+export type ParentInput = {
+    Message: string;
+};
+export declare const child: import("../..").TaskWorkflowDeclaration<ChildInput, {
+    TransformedMessage: string;
+}>;
+export declare const parent: import("../..").TaskWorkflowDeclaration<ParentInput, {
+    TransformedMessage: string;
+}>;

package/v1/examples/simple/workflow-with-child.js

@@ -0,0 +1,35 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parent = exports.child = void 0;
+// ❓ Declaring a Task
+const hatchet_client_1 = require("../hatchet-client");
+exports.child = hatchet_client_1.hatchet.task({
+    name: 'child',
+    fn: (input) => {
+        return {
+            TransformedMessage: input.Message.toLowerCase(),
+        };
+    },
+});
+exports.parent = hatchet_client_1.hatchet.task({
+    name: 'parent',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const c = yield ctx.runChild(exports.child, {
+            Message: input.Message,
+        });
+        return {
+            TransformedMessage: c.TransformedMessage,
+        };
+    }),
+});
+// !!
+// see ./worker.ts and ./run.ts for how to run the workflow

package/v1/task.d.ts

@@ -29,6 +29,9 @@ export type TaskConcurrency = {
      */
     limitStrategy?: ConcurrencyLimitStrategy;
 };
+export declare class NonRetryableError extends Error {
+    constructor(message?: string);
+}
 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>>;
 /**

package/v1/task.js

@@ -1,2 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonRetryableError = void 0;
+class NonRetryableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NonRetryableError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.NonRetryableError = NonRetryableError;

package/v1/types.d.ts

@@ -7,10 +7,15 @@ export type JsonObject = {
     [Key in string]?: JsonValue | undefined;
 };
 export type InputType = JsonObject;
+export interface WorkflowInputType extends InputType {
+}
 export type UnknownInputType = {};
 export type OutputType = JsonObject | void;
+export interface WorkflowOutputType {
+    [key: string]: JsonObject;
+}
 type IsValidWorkflowOutput<T> = T extends Record<string, JsonObject> ? true : false;
-export type WorkflowOutputType<T = any> = IsValidWorkflowOutput<T> extends true ? T : (Record<string, JsonObject> | void) & {
+export type StrictWorkflowOutputType<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;

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.0.6";
+export declare const HATCHET_VERSION = "1.1.0";

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.6';
+exports.HATCHET_VERSION = '1.1.0';