@hatchet-dev/typescript-sdk 1.25.0 → 1.26.0

package/package.json

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

package/protoc/google/protobuf/any.d.ts

@@ -0,0 +1,133 @@
+import { BinaryReader, BinaryWriter } from '@bufbuild/protobuf/wire';
+export declare const protobufPackage = "google.protobuf";
+/**
+ * `Any` contains an arbitrary serialized protocol buffer message along with a
+ * URL that describes the type of the serialized message.
+ *
+ * Protobuf library provides support to pack/unpack Any values in the form
+ * of utility functions or additional generated methods of the Any type.
+ *
+ * Example 1: Pack and unpack a message in C++.
+ *
+ *     Foo foo = ...;
+ *     Any any;
+ *     any.PackFrom(foo);
+ *     ...
+ *     if (any.UnpackTo(&foo)) {
+ *       ...
+ *     }
+ *
+ * Example 2: Pack and unpack a message in Java.
+ *
+ *     Foo foo = ...;
+ *     Any any = Any.pack(foo);
+ *     ...
+ *     if (any.is(Foo.class)) {
+ *       foo = any.unpack(Foo.class);
+ *     }
+ *
+ *  Example 3: Pack and unpack a message in Python.
+ *
+ *     foo = Foo(...)
+ *     any = Any()
+ *     any.Pack(foo)
+ *     ...
+ *     if any.Is(Foo.DESCRIPTOR):
+ *       any.Unpack(foo)
+ *       ...
+ *
+ *  Example 4: Pack and unpack a message in Go
+ *
+ *      foo := &pb.Foo{...}
+ *      any, err := anypb.New(foo)
+ *      if err != nil {
+ *        ...
+ *      }
+ *      ...
+ *      foo := &pb.Foo{}
+ *      if err := any.UnmarshalTo(foo); err != nil {
+ *        ...
+ *      }
+ *
+ * The pack methods provided by protobuf library will by default use
+ * 'type.googleapis.com/full.type.name' as the type URL and the unpack
+ * methods only use the fully qualified type name after the last '/'
+ * in the type URL, for example "foo.bar.com/x/y.z" will yield type
+ * name "y.z".
+ *
+ * JSON
+ * ====
+ * The JSON representation of an `Any` value uses the regular
+ * representation of the deserialized, embedded message, with an
+ * additional field `@type` which contains the type URL. Example:
+ *
+ *     package google.profile;
+ *     message Person {
+ *       string first_name = 1;
+ *       string last_name = 2;
+ *     }
+ *
+ *     {
+ *       "@type": "type.googleapis.com/google.profile.Person",
+ *       "firstName": <string>,
+ *       "lastName": <string>
+ *     }
+ *
+ * If the embedded message type is well-known and has a custom JSON
+ * representation, that representation will be embedded adding a field
+ * `value` which holds the custom JSON in addition to the `@type`
+ * field. Example (for message [google.protobuf.Duration][]):
+ *
+ *     {
+ *       "@type": "type.googleapis.com/google.protobuf.Duration",
+ *       "value": "1.212s"
+ *     }
+ */
+export interface Any {
+    /**
+     * A URL/resource name that uniquely identifies the type of the serialized
+     * protocol buffer message. This string must contain at least
+     * one "/" character. The last segment of the URL's path must represent
+     * the fully qualified name of the type (as in
+     * `path/google.protobuf.Duration`). The name should be in a canonical form
+     * (e.g., leading "." is not accepted).
+     *
+     * In practice, teams usually precompile into the binary all types that they
+     * expect it to use in the context of Any. However, for URLs which use the
+     * scheme `http`, `https`, or no scheme, one can optionally set up a type
+     * server that maps type URLs to message definitions as follows:
+     *
+     * * If no scheme is provided, `https` is assumed.
+     * * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+     *   value in binary format, or produce an error.
+     * * Applications are allowed to cache lookup results based on the
+     *   URL, or have them precompiled into a binary to avoid any
+     *   lookup. Therefore, binary compatibility needs to be preserved
+     *   on changes to types. (Use versioned type names to manage
+     *   breaking changes.)
+     *
+     * Note: this functionality is not currently available in the official
+     * protobuf release, and it is not used for type URLs beginning with
+     * type.googleapis.com.
+     *
+     * Schemes other than `http`, `https` (or the empty scheme) might be
+     * used with implementation specific semantics.
+     */
+    typeUrl: string;
+    /** Must be a valid serialized protocol buffer of the above specified type. */
+    value: Uint8Array;
+}
+export declare const Any: MessageFns<Any>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create(base?: DeepPartial<T>): T;
+    fromPartial(object: DeepPartial<T>): T;
+}
+export {};

package/protoc/google/protobuf/any.js

@@ -0,0 +1,112 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.6
+//   protoc               v3.19.1
+// source: google/protobuf/any.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Any = exports.protobufPackage = void 0;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+exports.protobufPackage = 'google.protobuf';
+function createBaseAny() {
+    return { typeUrl: '', value: new Uint8Array(0) };
+}
+exports.Any = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.typeUrl !== '') {
+            writer.uint32(10).string(message.typeUrl);
+        }
+        if (message.value.length !== 0) {
+            writer.uint32(18).bytes(message.value);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAny();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.typeUrl = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value = reader.bytes();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            typeUrl: isSet(object.typeUrl)
+                ? globalThis.String(object.typeUrl)
+                : isSet(object.type_url)
+                    ? globalThis.String(object.type_url)
+                    : '',
+            value: isSet(object.value) ? bytesFromBase64(object.value) : new Uint8Array(0),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.typeUrl !== '') {
+            obj.typeUrl = message.typeUrl;
+        }
+        if (message.value.length !== 0) {
+            obj.value = base64FromBytes(message.value);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.Any.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBaseAny();
+        message.typeUrl = (_a = object.typeUrl) !== null && _a !== void 0 ? _a : '';
+        message.value = (_b = object.value) !== null && _b !== void 0 ? _b : new Uint8Array(0);
+        return message;
+    },
+};
+function bytesFromBase64(b64) {
+    if (globalThis.Buffer) {
+        return Uint8Array.from(globalThis.Buffer.from(b64, 'base64'));
+    }
+    else {
+        const bin = globalThis.atob(b64);
+        const arr = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; ++i) {
+            arr[i] = bin.charCodeAt(i);
+        }
+        return arr;
+    }
+}
+function base64FromBytes(arr) {
+    if (globalThis.Buffer) {
+        return globalThis.Buffer.from(arr).toString('base64');
+    }
+    else {
+        const bin = [];
+        arr.forEach((byte) => {
+            bin.push(globalThis.String.fromCharCode(byte));
+        });
+        return globalThis.btoa(bin.join(''));
+    }
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/protoc/google/rpc/status.d.ts

@@ -0,0 +1,45 @@
+import { BinaryReader, BinaryWriter } from '@bufbuild/protobuf/wire';
+import { Any } from '../protobuf/any';
+export declare const protobufPackage = "google.rpc";
+/**
+ * The `Status` type defines a logical error model that is suitable for
+ * different programming environments, including REST APIs and RPC APIs. It is
+ * used by [gRPC](https://github.com/grpc). Each `Status` message contains
+ * three pieces of data: error code, error message, and error details.
+ *
+ * You can find out more about this error model and how to work with it in the
+ * [API Design Guide](https://cloud.google.com/apis/design/errors).
+ */
+export interface Status {
+    /**
+     * The status code, which should be an enum value of
+     * [google.rpc.Code][google.rpc.Code].
+     */
+    code: number;
+    /**
+     * A developer-facing error message, which should be in English. Any
+     * user-facing error message should be localized and sent in the
+     * [google.rpc.Status.details][google.rpc.Status.details] field, or localized
+     * by the client.
+     */
+    message: string;
+    /**
+     * A list of messages that carry the error details.  There is a common set of
+     * message types for APIs to use.
+     */
+    details: Any[];
+}
+export declare const Status: MessageFns<Status>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create(base?: DeepPartial<T>): T;
+    fromPartial(object: DeepPartial<T>): T;
+}
+export {};

package/protoc/google/rpc/status.js

@@ -0,0 +1,102 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.6
+//   protoc               v3.19.1
+// source: google/rpc/status.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Status = exports.protobufPackage = void 0;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+const any_1 = require("../protobuf/any");
+exports.protobufPackage = 'google.rpc';
+function createBaseStatus() {
+    return { code: 0, message: '', details: [] };
+}
+exports.Status = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.code !== 0) {
+            writer.uint32(8).int32(message.code);
+        }
+        if (message.message !== '') {
+            writer.uint32(18).string(message.message);
+        }
+        for (const v of message.details) {
+            any_1.Any.encode(v, writer.uint32(26).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseStatus();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.code = reader.int32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.message = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.details.push(any_1.Any.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            code: isSet(object.code) ? globalThis.Number(object.code) : 0,
+            message: isSet(object.message) ? globalThis.String(object.message) : '',
+            details: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.details)
+                ? object.details.map((e) => any_1.Any.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        var _a;
+        const obj = {};
+        if (message.code !== 0) {
+            obj.code = Math.round(message.code);
+        }
+        if (message.message !== '') {
+            obj.message = message.message;
+        }
+        if ((_a = message.details) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.details = message.details.map((e) => any_1.Any.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.Status.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = createBaseStatus();
+        message.code = (_a = object.code) !== null && _a !== void 0 ? _a : 0;
+        message.message = (_b = object.message) !== null && _b !== void 0 ? _b : '';
+        message.details = ((_c = object.details) === null || _c === void 0 ? void 0 : _c.map((e) => any_1.Any.fromPartial(e))) || [];
+        return message;
+    },
+};
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/protoc/v1/workflows.d.ts

@@ -130,6 +130,24 @@ export interface CreateWorkflowVersionRequest {
     defaultFilters: DefaultFilter[];
     /** (optional) the JSON schema for the workflow input */
     inputJsonSchema?: Uint8Array | undefined;
+    /** (optional) idempotency configuration for the workflow */
+    idempotency?: IdempotencyConfig | undefined;
+}
+export interface IdempotencyConfig {
+    /** a CEL expression for determining the idempotency key for workflow runs */
+    expression: string;
+    /** time-to-live for idempotency keys in milliseconds */
+    ttlMs: number;
+}
+export interface IdempotencyCollisionError {
+    /** the external ID of the existing workflow run that caused the collision */
+    existingRunExternalId: string;
+}
+export interface BulkTriggerIdempotencyCollisionError {
+    /** the external IDs of the successfully triggered workflow runs */
+    successfulWorkflowRunExternalIds: string[];
+    /** the idempotency collision errors */
+    collisions: IdempotencyCollisionError[];
 }
 export interface DefaultFilter {
     /** (required) the CEL expression for the filter */
@@ -260,6 +278,9 @@ export declare const TriggerWorkflowRunResponse: MessageFns<TriggerWorkflowRunRe
 export declare const BranchDurableTaskRequest: MessageFns<BranchDurableTaskRequest>;
 export declare const BranchDurableTaskResponse: MessageFns<BranchDurableTaskResponse>;
 export declare const CreateWorkflowVersionRequest: MessageFns<CreateWorkflowVersionRequest>;
+export declare const IdempotencyConfig: MessageFns<IdempotencyConfig>;
+export declare const IdempotencyCollisionError: MessageFns<IdempotencyCollisionError>;
+export declare const BulkTriggerIdempotencyCollisionError: MessageFns<BulkTriggerIdempotencyCollisionError>;
 export declare const DefaultFilter: MessageFns<DefaultFilter>;
 export declare const Concurrency: MessageFns<Concurrency>;
 export declare const CreateTaskOpts: MessageFns<CreateTaskOpts>;

package/protoc/v1/workflows.js

@@ -5,7 +5,7 @@
 //   protoc               v3.19.1
 // source: v1/workflows.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdminServiceDefinition = exports.GetRunDetailsResponse_TaskRunsEntry = exports.GetRunDetailsResponse = exports.TaskRunDetail = exports.GetRunDetailsRequest = exports.CreateWorkflowVersionResponse = exports.CreateTaskRateLimit = exports.CreateTaskOpts_SlotRequestsEntry = exports.CreateTaskOpts_WorkerLabelsEntry = exports.CreateTaskOpts = exports.Concurrency = exports.DefaultFilter = exports.CreateWorkflowVersionRequest = exports.BranchDurableTaskResponse = exports.BranchDurableTaskRequest = exports.TriggerWorkflowRunResponse = exports.TriggerWorkflowRunRequest_DesiredWorkerLabelsEntry = exports.TriggerWorkflowRunRequest = exports.ReplayTasksResponse = exports.CancelTasksResponse = exports.TasksFilter = exports.ReplayTasksRequest = exports.CancelTasksRequest = exports.ConcurrencyLimitStrategy = exports.RunStatus = exports.RateLimitDuration = exports.StickyStrategy = exports.protobufPackage = void 0;
+exports.AdminServiceDefinition = exports.GetRunDetailsResponse_TaskRunsEntry = exports.GetRunDetailsResponse = exports.TaskRunDetail = exports.GetRunDetailsRequest = exports.CreateWorkflowVersionResponse = exports.CreateTaskRateLimit = exports.CreateTaskOpts_SlotRequestsEntry = exports.CreateTaskOpts_WorkerLabelsEntry = exports.CreateTaskOpts = exports.Concurrency = exports.DefaultFilter = exports.BulkTriggerIdempotencyCollisionError = exports.IdempotencyCollisionError = exports.IdempotencyConfig = exports.CreateWorkflowVersionRequest = exports.BranchDurableTaskResponse = exports.BranchDurableTaskRequest = exports.TriggerWorkflowRunResponse = exports.TriggerWorkflowRunRequest_DesiredWorkerLabelsEntry = exports.TriggerWorkflowRunRequest = exports.ReplayTasksResponse = exports.CancelTasksResponse = exports.TasksFilter = exports.ReplayTasksRequest = exports.CancelTasksRequest = exports.ConcurrencyLimitStrategy = exports.RunStatus = exports.RateLimitDuration = exports.StickyStrategy = exports.protobufPackage = void 0;
 exports.stickyStrategyFromJSON = stickyStrategyFromJSON;
 exports.stickyStrategyToJSON = stickyStrategyToJSON;
 exports.rateLimitDurationFromJSON = rateLimitDurationFromJSON;
@@ -1111,6 +1111,7 @@ function createBaseCreateWorkflowVersionRequest() {
         concurrencyArr: [],
         defaultFilters: [],
         inputJsonSchema: undefined,
+        idempotency: undefined,
     };
 }
 exports.CreateWorkflowVersionRequest = {
@@ -1157,6 +1158,9 @@ exports.CreateWorkflowVersionRequest = {
         if (message.inputJsonSchema !== undefined) {
             writer.uint32(114).bytes(message.inputJsonSchema);
         }
+        if (message.idempotency !== undefined) {
+            exports.IdempotencyConfig.encode(message.idempotency, writer.uint32(122).fork()).join();
+        }
         return writer;
     },
     decode(input, length) {
@@ -1264,6 +1268,13 @@ exports.CreateWorkflowVersionRequest = {
                     message.inputJsonSchema = reader.bytes();
                     continue;
                 }
+                case 15: {
+                    if (tag !== 122) {
+                        break;
+                    }
+                    message.idempotency = exports.IdempotencyConfig.decode(reader, reader.uint32());
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -1322,6 +1333,9 @@ exports.CreateWorkflowVersionRequest = {
                 : isSet(object.input_json_schema)
                     ? bytesFromBase64(object.input_json_schema)
                     : undefined,
+            idempotency: isSet(object.idempotency)
+                ? exports.IdempotencyConfig.fromJSON(object.idempotency)
+                : undefined,
         };
     },
     toJSON(message) {
@@ -1369,6 +1383,9 @@ exports.CreateWorkflowVersionRequest = {
         if (message.inputJsonSchema !== undefined) {
             obj.inputJsonSchema = base64FromBytes(message.inputJsonSchema);
         }
+        if (message.idempotency !== undefined) {
+            obj.idempotency = exports.IdempotencyConfig.toJSON(message.idempotency);
+        }
         return obj;
     },
     create(base) {
@@ -1397,6 +1414,219 @@ exports.CreateWorkflowVersionRequest = {
         message.concurrencyArr = ((_k = object.concurrencyArr) === null || _k === void 0 ? void 0 : _k.map((e) => exports.Concurrency.fromPartial(e))) || [];
         message.defaultFilters = ((_l = object.defaultFilters) === null || _l === void 0 ? void 0 : _l.map((e) => exports.DefaultFilter.fromPartial(e))) || [];
         message.inputJsonSchema = (_m = object.inputJsonSchema) !== null && _m !== void 0 ? _m : undefined;
+        message.idempotency =
+            object.idempotency !== undefined && object.idempotency !== null
+                ? exports.IdempotencyConfig.fromPartial(object.idempotency)
+                : undefined;
+        return message;
+    },
+};
+function createBaseIdempotencyConfig() {
+    return { expression: '', ttlMs: 0 };
+}
+exports.IdempotencyConfig = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.expression !== '') {
+            writer.uint32(10).string(message.expression);
+        }
+        if (message.ttlMs !== 0) {
+            writer.uint32(16).int64(message.ttlMs);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseIdempotencyConfig();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.expression = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.ttlMs = longToNumber(reader.int64());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            expression: isSet(object.expression) ? globalThis.String(object.expression) : '',
+            ttlMs: isSet(object.ttlMs)
+                ? globalThis.Number(object.ttlMs)
+                : isSet(object.ttl_ms)
+                    ? globalThis.Number(object.ttl_ms)
+                    : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.expression !== '') {
+            obj.expression = message.expression;
+        }
+        if (message.ttlMs !== 0) {
+            obj.ttlMs = Math.round(message.ttlMs);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.IdempotencyConfig.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBaseIdempotencyConfig();
+        message.expression = (_a = object.expression) !== null && _a !== void 0 ? _a : '';
+        message.ttlMs = (_b = object.ttlMs) !== null && _b !== void 0 ? _b : 0;
+        return message;
+    },
+};
+function createBaseIdempotencyCollisionError() {
+    return { existingRunExternalId: '' };
+}
+exports.IdempotencyCollisionError = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.existingRunExternalId !== '') {
+            writer.uint32(10).string(message.existingRunExternalId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseIdempotencyCollisionError();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.existingRunExternalId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            existingRunExternalId: isSet(object.existingRunExternalId)
+                ? globalThis.String(object.existingRunExternalId)
+                : isSet(object.existing_run_external_id)
+                    ? globalThis.String(object.existing_run_external_id)
+                    : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.existingRunExternalId !== '') {
+            obj.existingRunExternalId = message.existingRunExternalId;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.IdempotencyCollisionError.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseIdempotencyCollisionError();
+        message.existingRunExternalId = (_a = object.existingRunExternalId) !== null && _a !== void 0 ? _a : '';
+        return message;
+    },
+};
+function createBaseBulkTriggerIdempotencyCollisionError() {
+    return { successfulWorkflowRunExternalIds: [], collisions: [] };
+}
+exports.BulkTriggerIdempotencyCollisionError = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        for (const v of message.successfulWorkflowRunExternalIds) {
+            writer.uint32(10).string(v);
+        }
+        for (const v of message.collisions) {
+            exports.IdempotencyCollisionError.encode(v, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBulkTriggerIdempotencyCollisionError();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.successfulWorkflowRunExternalIds.push(reader.string());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.collisions.push(exports.IdempotencyCollisionError.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            successfulWorkflowRunExternalIds: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.successfulWorkflowRunExternalIds)
+                ? object.successfulWorkflowRunExternalIds.map((e) => globalThis.String(e))
+                : globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.successful_workflow_run_external_ids)
+                    ? object.successful_workflow_run_external_ids.map((e) => globalThis.String(e))
+                    : [],
+            collisions: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.collisions)
+                ? object.collisions.map((e) => exports.IdempotencyCollisionError.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        var _a, _b;
+        const obj = {};
+        if ((_a = message.successfulWorkflowRunExternalIds) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.successfulWorkflowRunExternalIds = message.successfulWorkflowRunExternalIds;
+        }
+        if ((_b = message.collisions) === null || _b === void 0 ? void 0 : _b.length) {
+            obj.collisions = message.collisions.map((e) => exports.IdempotencyCollisionError.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.BulkTriggerIdempotencyCollisionError.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c, _d;
+        const message = createBaseBulkTriggerIdempotencyCollisionError();
+        message.successfulWorkflowRunExternalIds =
+            (_b = (_a = object.successfulWorkflowRunExternalIds) === null || _a === void 0 ? void 0 : _a.map((e) => e)) !== null && _b !== void 0 ? _b : [];
+        message.collisions =
+            (_d = (_c = object.collisions) === null || _c === void 0 ? void 0 : _c.map((e) => exports.IdempotencyCollisionError.fromPartial(e))) !== null && _d !== void 0 ? _d : [];
         return message;
     },
 };

package/util/errors/bulk-trigger-idempotency-collision-error.d.ts

@@ -0,0 +1,6 @@
+import { IdempotencyCollisionError } from './idempotency-collision-error';
+export declare class BulkTriggerIdempotencyCollisionError extends Error {
+    successfulWorkflowRunExternalIds: string[];
+    collisions: IdempotencyCollisionError[];
+    constructor(successfulWorkflowRunExternalIds: string[], collisions: IdempotencyCollisionError[]);
+}

package/util/errors/bulk-trigger-idempotency-collision-error.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkTriggerIdempotencyCollisionError = void 0;
+class BulkTriggerIdempotencyCollisionError extends Error {
+    constructor(successfulWorkflowRunExternalIds, collisions) {
+        super('idempotency key collision in bulk trigger');
+        this.name = 'BulkTriggerIdempotencyCollisionError';
+        this.successfulWorkflowRunExternalIds = successfulWorkflowRunExternalIds;
+        this.collisions = collisions;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.BulkTriggerIdempotencyCollisionError = BulkTriggerIdempotencyCollisionError;

package/util/errors/idempotency-collision-error.d.ts

@@ -0,0 +1,5 @@
+import HatchetError from './hatchet-error';
+export declare class IdempotencyCollisionError extends HatchetError {
+    existingRunExternalId: string;
+    constructor(existingRunExternalId: string);
+}

package/util/errors/idempotency-collision-error.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdempotencyCollisionError = void 0;
+const hatchet_error_1 = __importDefault(require("./hatchet-error"));
+class IdempotencyCollisionError extends hatchet_error_1.default {
+    constructor(existingRunExternalId) {
+        super(`idempotency key collision: existing run ${existingRunExternalId} already exists`);
+        this.name = 'IdempotencyCollisionError';
+        this.existingRunExternalId = existingRunExternalId;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.IdempotencyCollisionError = IdempotencyCollisionError;

package/util/retrier.d.ts

@@ -1,2 +1,2 @@
 import { Logger } from './logger';
-export declare function retrier<T>(fn: () => Promise<T>, logger: Logger, retries?: number, interval?: number): Promise<T>;
+export declare function retrier<T>(fn: () => Promise<T>, logger: Logger, retries?: number, interval?: number, shouldRetry?: (e: unknown) => boolean): Promise<T>;

package/util/retrier.js

@@ -18,13 +18,16 @@ const DEFAULT_RETRY_INTERVAL = 0.1; // seconds
 const DEFAULT_RETRY_COUNT = 8;
 const MAX_JITTER = 100; // milliseconds
 function retrier(fn_1, logger_1) {
-    return __awaiter(this, arguments, void 0, function* (fn, logger, retries = DEFAULT_RETRY_COUNT, interval = DEFAULT_RETRY_INTERVAL) {
+    return __awaiter(this, arguments, void 0, function* (fn, logger, retries = DEFAULT_RETRY_COUNT, interval = DEFAULT_RETRY_INTERVAL, shouldRetry = () => true) {
         let lastError;
         for (let i = 0; i < retries; i++) {
             try {
                 return yield fn();
             }
             catch (e) {
+                if (!shouldRetry(e)) {
+                    throw e;
+                }
                 lastError = e instanceof Error ? e : new Error(String(e));
                 logger.error(`Error: ${lastError.message}`);
                 // Calculate exponential backoff with random jitter

package/v1/client/admin.js

@@ -25,14 +25,99 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdminClient = void 0;
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
+const idempotency_collision_error_1 = require("../../util/errors/idempotency-collision-error");
+const bulk_trigger_idempotency_collision_error_1 = require("../../util/errors/bulk-trigger-idempotency-collision-error");
 const workflow_run_ref_1 = __importDefault(require("../../util/workflow-run-ref"));
+const grpc_js_1 = require("@grpc/grpc-js");
+const status_1 = require("../../protoc/google/rpc/status");
+const workflows_1 = require("../../protoc/v1/workflows");
+const nice_grpc_common_1 = require("nice-grpc-common");
 const grpc_helpers_1 = require("../../util/grpc-helpers");
 const child_listener_client_1 = require("../../clients/listeners/run-listener/child-listener-client");
-const workflows_1 = require("../../protoc/workflows");
-const workflows_2 = require("../../protoc/v1/workflows");
+const workflows_2 = require("../../protoc/workflows");
+const workflows_3 = require("../../protoc/v1/workflows");
 const retrier_1 = require("../../util/retrier");
 const batch_1 = require("../../util/batch");
 const apply_namespace_1 = require("../../util/apply-namespace");
+function isGrpcServiceError(e) {
+    return e instanceof Error && 'code' in e && 'metadata' in e;
+}
+function extractExistingRunIdFromGrpcError(e) {
+    var _a;
+    try {
+        const [binData] = e.metadata.get('grpc-status-details-bin');
+        if (!binData)
+            return '';
+        const status = status_1.Status.decode(binData instanceof Buffer ? binData : Buffer.from(binData));
+        for (const detail of status.details) {
+            if (detail.typeUrl.includes('IdempotencyCollisionError')) {
+                return (_a = workflows_1.IdempotencyCollisionError.decode(detail.value).existingRunExternalId) !== null && _a !== void 0 ? _a : '';
+            }
+        }
+    }
+    catch (_b) {
+        // ignore decoding errors
+    }
+    return '';
+}
+function isNiceGrpcAlreadyExists(e) {
+    return e instanceof nice_grpc_common_1.ClientError && e.code === nice_grpc_common_1.Status.ALREADY_EXISTS;
+}
+function decodeBulkTriggerCollision(status) {
+    for (const detail of status.details) {
+        if (detail.typeUrl.includes('BulkTriggerIdempotencyCollisionError')) {
+            const proto = workflows_1.BulkTriggerIdempotencyCollisionError.decode(detail.value);
+            return new bulk_trigger_idempotency_collision_error_1.BulkTriggerIdempotencyCollisionError(proto.successfulWorkflowRunExternalIds, proto.collisions.map((c) => new idempotency_collision_error_1.IdempotencyCollisionError(c.existingRunExternalId)));
+        }
+    }
+    return null;
+}
+function extractBulkTriggerCollisionFromGrpcError(e) {
+    try {
+        const [binData] = e.metadata.get('grpc-status-details-bin');
+        if (!binData)
+            return null;
+        const status = status_1.Status.decode(binData instanceof Buffer ? binData : Buffer.from(binData));
+        return decodeBulkTriggerCollision(status);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function extractBulkTriggerCollisionFromNiceGrpcMetadata(metadata) {
+    if (!metadata)
+        return null;
+    try {
+        const binData = metadata.get('grpc-status-details-bin');
+        if (!binData)
+            return null;
+        const status = status_1.Status.decode(binData);
+        return decodeBulkTriggerCollision(status);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function extractRunIdFromNiceGrpcMetadata(metadata) {
+    var _a;
+    if (!metadata)
+        return '';
+    try {
+        const binData = metadata.get('grpc-status-details-bin');
+        if (!binData)
+            return '';
+        const status = status_1.Status.decode(binData);
+        for (const detail of status.details) {
+            if (detail.typeUrl.includes('IdempotencyCollisionError')) {
+                return (_a = workflows_1.IdempotencyCollisionError.decode(detail.value).existingRunExternalId) !== null && _a !== void 0 ? _a : '';
+            }
+        }
+    }
+    catch (_b) {
+        // ignore decoding errors
+    }
+    return '';
+}
 function convertDesiredWorkerLabels(labels) {
     return Object.fromEntries(Object.entries(labels).map(([key, label]) => [
         key,
@@ -49,9 +134,9 @@ class AdminClient {
     constructor(config, api, runs) {
         this.config = config;
         this.logger = config.logger(`Admin`, config.log_level);
-        const { client, channel, factory } = (0, grpc_helpers_1.createGrpcClient)(config, workflows_1.WorkflowServiceDefinition);
+        const { client, channel, factory } = (0, grpc_helpers_1.createGrpcClient)(config, workflows_2.WorkflowServiceDefinition);
         this.workflowsGrpc = client;
-        this.adminGrpc = factory.create(workflows_2.AdminServiceDefinition, channel);
+        this.adminGrpc = factory.create(workflows_3.AdminServiceDefinition, channel);
         this.listenerClient = new child_listener_client_1.RunListenerClient(config, channel, factory, api);
         this.runs = runs;
     }
@@ -82,6 +167,7 @@ class AdminClient {
      */
     runWorkflow(workflowName, input, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            let trailerMetadata;
             try {
                 const computedName = (0, apply_namespace_1.applyNamespace)(workflowName, this.config.namespace).toLowerCase();
                 const inputStr = JSON.stringify(input);
@@ -92,14 +178,26 @@ class AdminClient {
                     parentTaskRunExternalId: parentTaskRunExternalId !== null && parentTaskRunExternalId !== void 0 ? parentTaskRunExternalId : parentStepRunId, additionalMetadata: additionalMetadata ? JSON.stringify(additionalMetadata) : undefined, priority: opts.priority, desiredWorkerLabels: desiredWorkerLabels
                         ? convertDesiredWorkerLabels(desiredWorkerLabels)
                         : {} });
-                const resp = yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.workflowsGrpc.triggerWorkflow(request); }), this.logger);
+                const resp = yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () {
+                    return this.workflowsGrpc.triggerWorkflow(request, {
+                        onTrailer: (trailer) => {
+                            trailerMetadata = trailer;
+                        },
+                    });
+                }), this.logger, undefined, undefined, (e) => !isNiceGrpcAlreadyExists(e));
                 const id = resp.workflowRunId;
                 const ref = new workflow_run_ref_1.default(id, this.listenerClient, this.runs, options === null || options === void 0 ? void 0 : options.parentId, options === null || options === void 0 ? void 0 : options._standaloneTaskName);
                 yield ref.getWorkflowRunId();
                 return ref;
             }
             catch (e) {
-                throw new hatchet_error_1.default(e.message);
+                if (isGrpcServiceError(e) && e.code === grpc_js_1.status.ALREADY_EXISTS) {
+                    throw new idempotency_collision_error_1.IdempotencyCollisionError(extractExistingRunIdFromGrpcError(e));
+                }
+                if (isNiceGrpcAlreadyExists(e)) {
+                    throw new idempotency_collision_error_1.IdempotencyCollisionError(extractRunIdFromNiceGrpcMetadata(trailerMetadata));
+                }
+                throw new hatchet_error_1.default(e instanceof Error ? e.message : String(e));
             }
         });
     }
@@ -129,15 +227,23 @@ class AdminClient {
             });
             const batches = (0, batch_1.batch)(workflowRequests, batchSize, (_a = this.config.grpc_max_send_message_length) !== null && _a !== void 0 ? _a : 4 * 1024 * 1024);
             this.logger.debug(`batching ${batches.length} batches`);
+            let bulkTrailerMetadata;
             try {
                 const results = [];
                 // for loop to ensure serial execution of batches
                 for (const { payloads, originalIndices, batchIndex } of batches) {
-                    const request = workflows_1.BulkTriggerWorkflowRequest.create({
+                    const request = workflows_2.BulkTriggerWorkflowRequest.create({
                         workflows: payloads,
                     });
                     // Call the bulk trigger workflow method for this batch
-                    const bulkTriggerWorkflowResponse = yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.workflowsGrpc.bulkTriggerWorkflow(request); }), this.logger);
+                    const bulkTriggerWorkflowResponse = yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () {
+                        return this.workflowsGrpc.bulkTriggerWorkflow(request, {
+                            onTrailer: (trailer) => {
+                                bulkTrailerMetadata = trailer;
+                            },
+                        });
+                    }), this.logger, undefined, undefined, (e) => !isNiceGrpcAlreadyExists(e) &&
+                        !(isGrpcServiceError(e) && e.code === grpc_js_1.status.ALREADY_EXISTS));
                     this.logger.debug(`batch ${batchIndex + 1} of ${batches.length}`);
                     // Map the results back to their original indices
                     const batchResults = bulkTriggerWorkflowResponse.workflowRunIds.map((resp, index) => {
@@ -150,7 +256,17 @@ class AdminClient {
                 return results;
             }
             catch (e) {
-                throw new hatchet_error_1.default(e.message);
+                if (isGrpcServiceError(e) && e.code === grpc_js_1.status.ALREADY_EXISTS) {
+                    const collision = extractBulkTriggerCollisionFromGrpcError(e);
+                    if (collision)
+                        throw collision;
+                }
+                if (isNiceGrpcAlreadyExists(e)) {
+                    const collision = extractBulkTriggerCollisionFromNiceGrpcMetadata(bulkTrailerMetadata);
+                    if (collision)
+                        throw collision;
+                }
+                throw new hatchet_error_1.default(e instanceof Error ? e.message : String(e));
             }
         });
     }

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

@@ -335,6 +335,12 @@ class InternalWorker {
                         expression: f.expression,
                         payload: f.payload ? new TextEncoder().encode(JSON.stringify(f.payload)) : undefined,
                     }))) !== null && _w !== void 0 ? _w : [],
+                    idempotency: workflow.idempotency
+                        ? {
+                            expression: workflow.idempotency.expression,
+                            ttlMs: workflow.idempotency.ttlMs,
+                        }
+                        : undefined,
                 });
                 this.registeredWorkflowPromises.push(registeredWorkflow);
                 yield registeredWorkflow;

package/v1/declaration.d.ts

@@ -9,7 +9,7 @@ import WorkflowRunRef from '../util/workflow-run-ref';
 import { CronWorkflows, ScheduledWorkflows, V1CreateFilterRequest } from '../clients/rest/generated/data-contracts';
 import * as z from 'zod/v4';
 import { IHatchetClient } from './client/client.interface';
-import { CreateWorkflowTaskOpts, CreateOnFailureTaskOpts, TaskFn, CreateWorkflowDurableTaskOpts, CreateBaseTaskOpts, CreateOnSuccessTaskOpts, Concurrency, DurableTaskFn, WorkerLabelComparator } from './task';
+import { CreateWorkflowTaskOpts, CreateOnFailureTaskOpts, TaskFn, CreateWorkflowDurableTaskOpts, CreateBaseTaskOpts, CreateOnSuccessTaskOpts, Concurrency, DurableTaskFn, WorkerLabelComparator, IdempotencyConfig } from './task';
 import { Duration } from './client/duration';
 import { MetricsClient } from './client/features/metrics';
 import { InputType, OutputType, UnknownInputType, JsonObject, Resolved } from './types';
@@ -152,6 +152,11 @@ export type CreateBaseWorkflowOpts = {
      * can be used on the dashboard for autocomplete.
      */
     inputValidator?: z.ZodType<any>;
+    /**
+     * (optional) idempotency configuration for the workflow.
+     * Prevents more than one run from occurring for a given key within the TTL window.
+     */
+    idempotency?: IdempotencyConfig;
 };
 export type CreateTaskWorkflowOpts<I extends InputType = UnknownInputType, O extends OutputType = void> = CreateBaseWorkflowOpts & CreateBaseTaskOpts<I, O, TaskFn<I, O>>;
 export type CreateDurableTaskWorkflowOpts<I extends InputType = UnknownInputType, O extends OutputType = void> = CreateBaseWorkflowOpts & CreateBaseTaskOpts<I, O, DurableTaskFn<I, O>> & {

package/v1/examples/e2e-worker.js

@@ -32,17 +32,18 @@ const workflow_11 = require("./durable_sleep/workflow");
 const workflow_12 = require("./logger/workflow");
 const workflow_13 = require("./non_retryable/workflow");
 const workflow_14 = require("./on_failure/workflow");
-const workflow_15 = require("./on_event/workflow");
-const workflow_16 = require("./return_exceptions/workflow");
-const workflow_17 = require("./run_details/workflow");
+const workflow_15 = require("./idempotency/workflow");
+const workflow_16 = require("./on_event/workflow");
+const workflow_17 = require("./return_exceptions/workflow");
+const workflow_18 = require("./run_details/workflow");
 const e2e_workflows_1 = require("./simple/e2e-workflows");
-const workflow_18 = require("./streaming/workflow");
-const workflow_19 = require("./timeout/workflow");
-const workflow_20 = require("./webhooks/workflow");
-const workflow_21 = require("./child_index/workflow");
-const workflow_22 = require("./support_agent/workflow");
-const workflow_23 = require("./welcome_email/workflow");
-const workflow_24 = require("./pdf_pipeline/workflow");
+const workflow_19 = require("./streaming/workflow");
+const workflow_20 = require("./timeout/workflow");
+const workflow_21 = require("./webhooks/workflow");
+const workflow_22 = require("./child_index/workflow");
+const workflow_23 = require("./support_agent/workflow");
+const workflow_24 = require("./welcome_email/workflow");
+const workflow_25 = require("./pdf_pipeline/workflow");
 const workflows = [
     workflow_1.bulkChild,
     workflow_1.bulkParentWorkflow,
@@ -86,25 +87,27 @@ const workflows = [
     (0, workflow_12.createLoggingWorkflow)(hatchet_client_1.hatchet),
     workflow_13.nonRetryableWorkflow,
     workflow_14.failureWorkflow,
-    workflow_15.lower,
-    workflow_16.returnExceptionsTask,
-    workflow_17.runDetailTestWorkflow,
+    workflow_15.idempotentTask,
+    workflow_15.idempotentTaskShortWindow,
+    workflow_16.lower,
+    workflow_17.returnExceptionsTask,
+    workflow_18.runDetailTestWorkflow,
     e2e_workflows_1.helloWorld,
     e2e_workflows_1.helloWorldDurable,
-    workflow_18.streamingTask,
-    workflow_19.timeoutTask,
-    workflow_19.refreshTimeoutTask,
-    workflow_20.webhookWorkflow,
-    workflow_21.childIndexChild,
-    workflow_21.childIndexParent,
-    workflow_21.scenarioTask,
-    workflow_21.orchestratorTask,
-    workflow_22.supportAgent,
-    workflow_22.triageTicket,
-    workflow_22.generateReply,
-    workflow_22.escalateTicket,
-    workflow_23.welcomeEmail,
-    workflow_24.pdfPipeline,
+    workflow_19.streamingTask,
+    workflow_20.timeoutTask,
+    workflow_20.refreshTimeoutTask,
+    workflow_21.webhookWorkflow,
+    workflow_22.childIndexChild,
+    workflow_22.childIndexParent,
+    workflow_22.scenarioTask,
+    workflow_22.orchestratorTask,
+    workflow_23.supportAgent,
+    workflow_23.triageTicket,
+    workflow_23.generateReply,
+    workflow_23.escalateTicket,
+    workflow_24.welcomeEmail,
+    workflow_25.pdfPipeline,
 ];
 function main() {
     return __awaiter(this, void 0, void 0, function* () {

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

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

package/v1/examples/idempotency/run.js

@@ -0,0 +1,37 @@
+"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 v1_1 = require("../..");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // > trigger
+        const ref1 = yield workflow_1.idempotentTask.runNoWait({ id: '123' });
+        let runId2;
+        try {
+            const ref2 = yield workflow_1.idempotentTask.runNoWait({ id: '123' });
+            runId2 = yield ref2.getWorkflowRunId();
+        }
+        catch (e) {
+            if (e instanceof v1_1.IdempotencyCollisionError) {
+                console.log(`Run with external ID ${e.existingRunExternalId} already exists for this idempotency key`);
+                runId2 = e.existingRunExternalId;
+            }
+            else {
+                throw e;
+            }
+        }
+        const res1 = yield ref1.result();
+        console.log(`Result: ${JSON.stringify(res1)}, run ID: ${runId2}`);
+        // !!
+    });
+}
+main().catch(console.error);

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

@@ -0,0 +1,10 @@
+export declare const EVENT_KEY = "ts-e2e:idempotency-example";
+export type IdempotencyInput = {
+    id: string;
+};
+export declare const idempotentTask: import("../..").TaskWorkflowDeclaration<IdempotencyInput, {
+    result: string;
+}, {}, {}, {}, {}>;
+export declare const idempotentTaskShortWindow: import("../..").TaskWorkflowDeclaration<IdempotencyInput, {
+    result: string;
+}, {}, {}, {}, {}>;

package/v1/examples/idempotency/workflow.js

@@ -0,0 +1,39 @@
+"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.idempotentTaskShortWindow = exports.idempotentTask = exports.EVENT_KEY = void 0;
+const hatchet_client_1 = require("../hatchet-client");
+exports.EVENT_KEY = 'ts-e2e:idempotency-example';
+// > idempotency
+exports.idempotentTask = hatchet_client_1.hatchet.task({
+    name: 'ts-e2e-idempotent-task',
+    idempotency: {
+        strategy: 'ttl',
+        expression: 'input.id',
+        ttlMs: 60000,
+    },
+    onEvents: [exports.EVENT_KEY],
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        return { result: `Hello, world from task ${input.id}` };
+    }),
+});
+// !!
+exports.idempotentTaskShortWindow = hatchet_client_1.hatchet.task({
+    name: 'ts-e2e-idempotent-task-short-window',
+    idempotency: {
+        strategy: 'ttl',
+        expression: 'input.id',
+        ttlMs: 2000,
+    },
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        return { result: `Hello, world from task ${input.id}` };
+    }),
+});

package/v1/index.d.ts

@@ -12,6 +12,8 @@ export * from './slot-types';
 export * from '../legacy/legacy-transformer';
 export { NonDeterminismError } from '../util/errors/non-determinism-error';
 export { EvictionNotSupportedError } from '../util/errors/eviction-not-supported-error';
+export { IdempotencyCollisionError } from '../util/errors/idempotency-collision-error';
+export { BulkTriggerIdempotencyCollisionError } from '../util/errors/bulk-trigger-idempotency-collision-error';
 export { EvictionPolicy, DEFAULT_DURABLE_TASK_EVICTION_POLICY, } from './client/worker/eviction/eviction-policy';
 export { DurableEvictionConfig } from './client/worker/eviction/eviction-manager';
 export { MinEngineVersion, supportsEviction } from './client/worker/engine-version';

package/v1/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.supportsEviction = exports.MinEngineVersion = exports.DEFAULT_DURABLE_TASK_EVICTION_POLICY = exports.EvictionNotSupportedError = exports.NonDeterminismError = void 0;
+exports.supportsEviction = exports.MinEngineVersion = exports.DEFAULT_DURABLE_TASK_EVICTION_POLICY = exports.BulkTriggerIdempotencyCollisionError = exports.IdempotencyCollisionError = exports.EvictionNotSupportedError = exports.NonDeterminismError = void 0;
 __exportStar(require("./client/client"), exports);
 __exportStar(require("./client/features"), exports);
 __exportStar(require("./client/worker/worker"), exports);
@@ -30,6 +30,10 @@ var non_determinism_error_1 = require("../util/errors/non-determinism-error");
 Object.defineProperty(exports, "NonDeterminismError", { enumerable: true, get: function () { return non_determinism_error_1.NonDeterminismError; } });
 var eviction_not_supported_error_1 = require("../util/errors/eviction-not-supported-error");
 Object.defineProperty(exports, "EvictionNotSupportedError", { enumerable: true, get: function () { return eviction_not_supported_error_1.EvictionNotSupportedError; } });
+var idempotency_collision_error_1 = require("../util/errors/idempotency-collision-error");
+Object.defineProperty(exports, "IdempotencyCollisionError", { enumerable: true, get: function () { return idempotency_collision_error_1.IdempotencyCollisionError; } });
+var bulk_trigger_idempotency_collision_error_1 = require("../util/errors/bulk-trigger-idempotency-collision-error");
+Object.defineProperty(exports, "BulkTriggerIdempotencyCollisionError", { enumerable: true, get: function () { return bulk_trigger_idempotency_collision_error_1.BulkTriggerIdempotencyCollisionError; } });
 var eviction_policy_1 = require("./client/worker/eviction/eviction-policy");
 Object.defineProperty(exports, "DEFAULT_DURABLE_TASK_EVICTION_POLICY", { enumerable: true, get: function () { return eviction_policy_1.DEFAULT_DURABLE_TASK_EVICTION_POLICY; } });
 var engine_version_1 = require("./client/worker/engine-version");

package/v1/task.d.ts

@@ -36,6 +36,30 @@ export type Concurrency = {
  * @deprecated use Concurrency instead
  */
 export type TaskConcurrency = Concurrency;
+/**
+ * Base type for idempotency configurations.
+ */
+export type BaseIdempotencyConfig = {
+    /**
+     * CEL expression to create an idempotency key from input and metadata.
+     * @example "input.id" // use the 'id' field from input as the key
+     */
+    expression: string;
+};
+/**
+ * TTL-based idempotency: prevents duplicate runs within a sliding time window.
+ */
+export type TTLBasedIdempotencyConfig = BaseIdempotencyConfig & {
+    strategy: 'ttl';
+    /**
+     * How long the idempotency key should live (in milliseconds).
+     */
+    ttlMs: number;
+};
+/**
+ * Union of all supported idempotency configurations.
+ */
+export type IdempotencyConfig = TTLBasedIdempotencyConfig;
 export declare class NonRetryableError extends Error {
     constructor(message?: string);
 }

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.25.0";
+export declare const HATCHET_VERSION = "1.26.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.25.0';
+exports.HATCHET_VERSION = '1.26.0';