@hatchet-dev/typescript-sdk 0.13.0 → 0.14.0

package/package.json

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

package/protoc/events/events.d.ts

@@ -15,6 +15,9 @@ export interface Event {
     /** the payload for the event */
     additionalMetadata?: string | undefined;
 }
+export interface Events {
+    events: Event[];
+}
 export interface PutLogRequest {
     /** the step run id for the request */
     stepRunId: string;
@@ -41,6 +44,9 @@ export interface PutStreamEventRequest {
 }
 export interface PutStreamEventResponse {
 }
+export interface BulkPushEventRequest {
+    events: PushEventRequest[];
+}
 export interface PushEventRequest {
     /** the key for the event */
     key: string;
@@ -56,10 +62,12 @@ export interface ReplayEventRequest {
     eventId: string;
 }
 export declare const Event: MessageFns<Event>;
+export declare const Events: MessageFns<Events>;
 export declare const PutLogRequest: MessageFns<PutLogRequest>;
 export declare const PutLogResponse: MessageFns<PutLogResponse>;
 export declare const PutStreamEventRequest: MessageFns<PutStreamEventRequest>;
 export declare const PutStreamEventResponse: MessageFns<PutStreamEventResponse>;
+export declare const BulkPushEventRequest: MessageFns<BulkPushEventRequest>;
 export declare const PushEventRequest: MessageFns<PushEventRequest>;
 export declare const ReplayEventRequest: MessageFns<ReplayEventRequest>;
 export type EventsServiceDefinition = typeof EventsServiceDefinition;
@@ -75,6 +83,14 @@ export declare const EventsServiceDefinition: {
             readonly responseStream: false;
             readonly options: {};
         };
+        readonly bulkPush: {
+            readonly name: "BulkPush";
+            readonly requestType: MessageFns<BulkPushEventRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<Events>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
         readonly replaySingleEvent: {
             readonly name: "ReplaySingleEvent";
             readonly requestType: MessageFns<ReplayEventRequest>;
@@ -103,12 +119,14 @@ export declare const EventsServiceDefinition: {
 };
 export interface EventsServiceImplementation<CallContextExt = {}> {
     push(request: PushEventRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Event>>;
+    bulkPush(request: BulkPushEventRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Events>>;
     replaySingleEvent(request: ReplayEventRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Event>>;
     putLog(request: PutLogRequest, context: CallContext & CallContextExt): Promise<DeepPartial<PutLogResponse>>;
     putStreamEvent(request: PutStreamEventRequest, context: CallContext & CallContextExt): Promise<DeepPartial<PutStreamEventResponse>>;
 }
 export interface EventsServiceClient<CallOptionsExt = {}> {
     push(request: DeepPartial<PushEventRequest>, options?: CallOptions & CallOptionsExt): Promise<Event>;
+    bulkPush(request: DeepPartial<BulkPushEventRequest>, options?: CallOptions & CallOptionsExt): Promise<Events>;
     replaySingleEvent(request: DeepPartial<ReplayEventRequest>, options?: CallOptions & CallOptionsExt): Promise<Event>;
     putLog(request: DeepPartial<PutLogRequest>, options?: CallOptions & CallOptionsExt): Promise<PutLogResponse>;
     putStreamEvent(request: DeepPartial<PutStreamEventRequest>, options?: CallOptions & CallOptionsExt): Promise<PutStreamEventResponse>;

package/protoc/events/events.js

@@ -5,7 +5,7 @@
 //   protoc               v3.19.1
 // source: events/events.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventsServiceDefinition = exports.ReplayEventRequest = exports.PushEventRequest = exports.PutStreamEventResponse = exports.PutStreamEventRequest = exports.PutLogResponse = exports.PutLogRequest = exports.Event = exports.protobufPackage = void 0;
+exports.EventsServiceDefinition = exports.ReplayEventRequest = exports.PushEventRequest = exports.BulkPushEventRequest = exports.PutStreamEventResponse = exports.PutStreamEventRequest = exports.PutLogResponse = exports.PutLogRequest = exports.Events = exports.Event = exports.protobufPackage = void 0;
 /* eslint-disable */
 const wire_1 = require("@bufbuild/protobuf/wire");
 const timestamp_1 = require("../google/protobuf/timestamp");
@@ -144,6 +144,62 @@ exports.Event = {
         return message;
     },
 };
+function createBaseEvents() {
+    return { events: [] };
+}
+exports.Events = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        for (const v of message.events) {
+            exports.Event.encode(v, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseEvents();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.events.push(exports.Event.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            events: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.events)
+                ? object.events.map((e) => exports.Event.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        var _a;
+        const obj = {};
+        if ((_a = message.events) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.events = message.events.map((e) => exports.Event.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.Events.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseEvents();
+        message.events = ((_a = object.events) === null || _a === void 0 ? void 0 : _a.map((e) => exports.Event.fromPartial(e))) || [];
+        return message;
+    },
+};
 function createBasePutLogRequest() {
     return { stepRunId: '', createdAt: undefined, message: '', level: undefined, metadata: '' };
 }
@@ -422,6 +478,62 @@ exports.PutStreamEventResponse = {
         return message;
     },
 };
+function createBaseBulkPushEventRequest() {
+    return { events: [] };
+}
+exports.BulkPushEventRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        for (const v of message.events) {
+            exports.PushEventRequest.encode(v, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBulkPushEventRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.events.push(exports.PushEventRequest.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            events: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.events)
+                ? object.events.map((e) => exports.PushEventRequest.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        var _a;
+        const obj = {};
+        if ((_a = message.events) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.events = message.events.map((e) => exports.PushEventRequest.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.BulkPushEventRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseBulkPushEventRequest();
+        message.events = ((_a = object.events) === null || _a === void 0 ? void 0 : _a.map((e) => exports.PushEventRequest.fromPartial(e))) || [];
+        return message;
+    },
+};
 function createBasePushEventRequest() {
     return { key: '', payload: '', eventTimestamp: undefined, additionalMetadata: undefined };
 }
@@ -584,6 +696,14 @@ exports.EventsServiceDefinition = {
             responseStream: false,
             options: {},
         },
+        bulkPush: {
+            name: 'BulkPush',
+            requestType: exports.BulkPushEventRequest,
+            requestStream: false,
+            responseType: exports.Events,
+            responseStream: false,
+            options: {},
+        },
         replaySingleEvent: {
             name: 'ReplaySingleEvent',
             requestType: exports.ReplayEventRequest,

package/protoc/workflows/workflows.d.ts

@@ -153,8 +153,16 @@ export interface CreateWorkflowStepOpts_WorkerLabelsEntry {
 export interface CreateStepRateLimit {
     /** (required) the key for the rate limit */
     key: string;
-    /** (required) the number of units this step consumes */
-    units: number;
+    /** (optional) the number of units this step consumes */
+    units?: number | undefined;
+    /** (optional) a CEL expression for determining the rate limit key */
+    keyExpr?: string | undefined;
+    /** (optional) a CEL expression for determining the number of units consumed */
+    unitsExpr?: string | undefined;
+    /** (optional) a CEL expression for determining the total amount of rate limit units */
+    limitValuesExpr?: string | undefined;
+    /** (optional) the default rate limit window to use for dynamic rate limits */
+    duration?: RateLimitDuration | undefined;
 }
 /** ListWorkflowsRequest is the request for ListWorkflows. */
 export interface ListWorkflowsRequest {

package/protoc/workflows/workflows.js

@@ -1143,16 +1143,35 @@ exports.CreateWorkflowStepOpts_WorkerLabelsEntry = {
     },
 };
 function createBaseCreateStepRateLimit() {
-    return { key: '', units: 0 };
+    return {
+        key: '',
+        units: undefined,
+        keyExpr: undefined,
+        unitsExpr: undefined,
+        limitValuesExpr: undefined,
+        duration: undefined,
+    };
 }
 exports.CreateStepRateLimit = {
     encode(message, writer = new wire_1.BinaryWriter()) {
         if (message.key !== '') {
             writer.uint32(10).string(message.key);
         }
-        if (message.units !== 0) {
+        if (message.units !== undefined) {
             writer.uint32(16).int32(message.units);
         }
+        if (message.keyExpr !== undefined) {
+            writer.uint32(26).string(message.keyExpr);
+        }
+        if (message.unitsExpr !== undefined) {
+            writer.uint32(34).string(message.unitsExpr);
+        }
+        if (message.limitValuesExpr !== undefined) {
+            writer.uint32(42).string(message.limitValuesExpr);
+        }
+        if (message.duration !== undefined) {
+            writer.uint32(48).int32(message.duration);
+        }
         return writer;
     },
     decode(input, length) {
@@ -1174,6 +1193,30 @@ exports.CreateStepRateLimit = {
                     }
                     message.units = reader.int32();
                     continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.keyExpr = reader.string();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.unitsExpr = reader.string();
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.limitValuesExpr = reader.string();
+                    continue;
+                case 6:
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.duration = reader.int32();
+                    continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -1185,7 +1228,13 @@ exports.CreateStepRateLimit = {
     fromJSON(object) {
         return {
             key: isSet(object.key) ? globalThis.String(object.key) : '',
-            units: isSet(object.units) ? globalThis.Number(object.units) : 0,
+            units: isSet(object.units) ? globalThis.Number(object.units) : undefined,
+            keyExpr: isSet(object.keyExpr) ? globalThis.String(object.keyExpr) : undefined,
+            unitsExpr: isSet(object.unitsExpr) ? globalThis.String(object.unitsExpr) : undefined,
+            limitValuesExpr: isSet(object.limitValuesExpr)
+                ? globalThis.String(object.limitValuesExpr)
+                : undefined,
+            duration: isSet(object.duration) ? rateLimitDurationFromJSON(object.duration) : undefined,
         };
     },
     toJSON(message) {
@@ -1193,19 +1242,35 @@ exports.CreateStepRateLimit = {
         if (message.key !== '') {
             obj.key = message.key;
         }
-        if (message.units !== 0) {
+        if (message.units !== undefined) {
             obj.units = Math.round(message.units);
         }
+        if (message.keyExpr !== undefined) {
+            obj.keyExpr = message.keyExpr;
+        }
+        if (message.unitsExpr !== undefined) {
+            obj.unitsExpr = message.unitsExpr;
+        }
+        if (message.limitValuesExpr !== undefined) {
+            obj.limitValuesExpr = message.limitValuesExpr;
+        }
+        if (message.duration !== undefined) {
+            obj.duration = rateLimitDurationToJSON(message.duration);
+        }
         return obj;
     },
     create(base) {
         return exports.CreateStepRateLimit.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e, _f;
         const message = createBaseCreateStepRateLimit();
         message.key = (_a = object.key) !== null && _a !== void 0 ? _a : '';
-        message.units = (_b = object.units) !== null && _b !== void 0 ? _b : 0;
+        message.units = (_b = object.units) !== null && _b !== void 0 ? _b : undefined;
+        message.keyExpr = (_c = object.keyExpr) !== null && _c !== void 0 ? _c : undefined;
+        message.unitsExpr = (_d = object.unitsExpr) !== null && _d !== void 0 ? _d : undefined;
+        message.limitValuesExpr = (_e = object.limitValuesExpr) !== null && _e !== void 0 ? _e : undefined;
+        message.duration = (_f = object.duration) !== null && _f !== void 0 ? _f : undefined;
         return message;
     },
 };

package/step.d.ts

@@ -7,16 +7,28 @@ import { HatchetClient } from './clients/hatchet-client';
 import WorkflowRunRef from './util/workflow-run-ref';
 import { Worker } from './clients/worker';
 import { WorkerLabels } from './clients/dispatcher/dispatcher-client';
-import { WorkerLabelComparator } from './protoc/workflows';
+import { CreateStepRateLimit, RateLimitDuration, WorkerLabelComparator } from './protoc/workflows';
 export declare const CreateRateLimitSchema: z.ZodObject<{
-    key: z.ZodString;
-    units: z.ZodNumber;
+    key: z.ZodOptional<z.ZodString>;
+    staticKey: z.ZodOptional<z.ZodString>;
+    dynamicKey: z.ZodOptional<z.ZodString>;
+    units: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
+    limit: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+    duration: z.ZodOptional<z.ZodNativeEnum<typeof RateLimitDuration>>;
 }, "strip", z.ZodTypeAny, {
-    key: string;
-    units: number;
+    units: string | number;
+    key?: string | undefined;
+    duration?: RateLimitDuration | undefined;
+    limit?: string | number | undefined;
+    staticKey?: string | undefined;
+    dynamicKey?: string | undefined;
 }, {
-    key: string;
-    units: number;
+    units: string | number;
+    key?: string | undefined;
+    duration?: RateLimitDuration | undefined;
+    limit?: string | number | undefined;
+    staticKey?: string | undefined;
+    dynamicKey?: string | undefined;
 }>;
 export declare const DesiredWorkerLabelSchema: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodObject<{
     value: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
@@ -40,14 +52,26 @@ export declare const CreateStepSchema: z.ZodObject<{
     timeout: z.ZodOptional<z.ZodString>;
     retries: z.ZodOptional<z.ZodNumber>;
     rate_limits: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        units: z.ZodNumber;
+        key: z.ZodOptional<z.ZodString>;
+        staticKey: z.ZodOptional<z.ZodString>;
+        dynamicKey: z.ZodOptional<z.ZodString>;
+        units: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
+        limit: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+        duration: z.ZodOptional<z.ZodNativeEnum<typeof RateLimitDuration>>;
     }, "strip", z.ZodTypeAny, {
-        key: string;
-        units: number;
+        units: string | number;
+        key?: string | undefined;
+        duration?: RateLimitDuration | undefined;
+        limit?: string | number | undefined;
+        staticKey?: string | undefined;
+        dynamicKey?: string | undefined;
     }, {
-        key: string;
-        units: number;
+        units: string | number;
+        key?: string | undefined;
+        duration?: RateLimitDuration | undefined;
+        limit?: string | number | undefined;
+        staticKey?: string | undefined;
+        dynamicKey?: string | undefined;
     }>, "many">>;
     worker_labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodLazy<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodObject<{
         value: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
@@ -71,8 +95,12 @@ export declare const CreateStepSchema: z.ZodObject<{
     parents?: string[] | undefined;
     retries?: number | undefined;
     rate_limits?: {
-        key: string;
-        units: number;
+        units: string | number;
+        key?: string | undefined;
+        duration?: RateLimitDuration | undefined;
+        limit?: string | number | undefined;
+        staticKey?: string | undefined;
+        dynamicKey?: string | undefined;
     }[] | undefined;
     worker_labels?: Record<string, string | number | {
         value: string | number;
@@ -86,8 +114,12 @@ export declare const CreateStepSchema: z.ZodObject<{
     parents?: string[] | undefined;
     retries?: number | undefined;
     rate_limits?: {
-        key: string;
-        units: number;
+        units: string | number;
+        key?: string | undefined;
+        duration?: RateLimitDuration | undefined;
+        limit?: string | number | undefined;
+        staticKey?: string | undefined;
+        dynamicKey?: string | undefined;
     }[] | undefined;
     worker_labels?: Record<string, string | number | {
         value: string | number;
@@ -178,4 +210,5 @@ export type StepRunFunction<T, K> = (ctx: Context<T, K>) => Promise<NextStep | v
 export interface CreateStep<T, K> extends z.infer<typeof CreateStepSchema> {
     run: StepRunFunction<T, K>;
 }
+export declare function mapRateLimit(limits: CreateStep<any, any>['rate_limits']): CreateStepRateLimit[];
 export {};

package/step.js

@@ -36,6 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = exports.ContextWorker = exports.CreateStepSchema = exports.DesiredWorkerLabelSchema = exports.CreateRateLimitSchema = void 0;
+exports.mapRateLimit = mapRateLimit;
 /* eslint-disable max-classes-per-file */
 const hatchet_error_1 = __importDefault(require("./util/errors/hatchet-error"));
 const z = __importStar(require("zod"));
@@ -44,8 +45,12 @@ const logger_1 = require("./util/logger");
 const parse_1 = require("./util/parse");
 const workflows_1 = require("./protoc/workflows");
 exports.CreateRateLimitSchema = z.object({
-    key: z.string(),
-    units: z.number().min(1),
+    key: z.string().optional(),
+    staticKey: z.string().optional(),
+    dynamicKey: z.string().optional(),
+    units: z.union([z.number().min(1), z.string()]),
+    limit: z.union([z.number().min(1), z.string()]).optional(),
+    duration: z.nativeEnum(workflows_1.RateLimitDuration).optional(),
 });
 exports.DesiredWorkerLabelSchema = z
     .union([
@@ -273,3 +278,68 @@ class Context {
     }
 }
 exports.Context = Context;
+function mapRateLimit(limits) {
+    if (!limits)
+        return [];
+    return limits.map((l) => {
+        let key = l.staticKey;
+        const keyExpression = l.dynamicKey;
+        if (l.key !== undefined) {
+            // eslint-disable-next-line no-console
+            console.warn('key is deprecated and will be removed in a future release, please use staticKey instead');
+            key = l.key;
+        }
+        if (keyExpression !== undefined) {
+            if (key !== undefined) {
+                throw new Error('Cannot have both static key and dynamic key set');
+            }
+            key = keyExpression;
+            if (!validateCelExpression(keyExpression)) {
+                throw new Error(`Invalid CEL expression: ${keyExpression}`);
+            }
+        }
+        if (key === undefined) {
+            throw new Error(`Invalid key`);
+        }
+        let units;
+        let unitsExpression;
+        if (typeof l.units === 'number') {
+            units = l.units;
+        }
+        else {
+            if (!validateCelExpression(l.units)) {
+                throw new Error(`Invalid CEL expression: ${l.units}`);
+            }
+            unitsExpression = l.units;
+        }
+        let limitExpression;
+        if (l.limit !== undefined) {
+            if (typeof l.limit === 'number') {
+                limitExpression = `${l.limit}`;
+            }
+            else {
+                if (!validateCelExpression(l.limit)) {
+                    throw new Error(`Invalid CEL expression: ${l.limit}`);
+                }
+                limitExpression = l.limit;
+            }
+        }
+        if (keyExpression !== undefined && limitExpression === undefined) {
+            throw new Error('CEL based keys requires limit to be set');
+        }
+        return {
+            key,
+            keyExpr: keyExpression,
+            units,
+            unitsExpr: unitsExpression,
+            limitValuesExpr: limitExpression,
+            duration: l.duration,
+        };
+    });
+}
+// Helper function to validate CEL expressions
+function validateCelExpression(expr) {
+    // This is a placeholder. In a real implementation, you'd need to use a CEL parser or validator.
+    // For now, we'll just return true to mimic the behavior.
+    return true;
+}

package/util/workflow-run-ref.js

@@ -73,16 +73,39 @@ class WorkflowRunRef {
             return new Promise((resolve, reject) => {
                 (() => __awaiter(this, void 0, void 0, function* () {
                     var _a, e_1, _b, _c;
+                    var _d, _e;
                     try {
-                        for (var _d = true, _e = __asyncValues(streamable.stream()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                            _c = _f.value;
-                            _d = false;
+                        for (var _f = true, _g = __asyncValues(streamable.stream()), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
+                            _c = _h.value;
+                            _f = false;
                             const event = _c;
                             if (event.eventType === dispatcher_1.WorkflowRunEventType.WORKFLOW_RUN_EVENT_TYPE_FINISHED) {
                                 if (event.results.some((r) => !!r.error)) {
                                     reject(event.results);
                                     return;
                                 }
+                                if (event.results.length === 0) {
+                                    const data = yield this.client.api.workflowRunGetShape(this.client.config.tenant_id, event.workflowRunId);
+                                    const mostRecentJobRun = (_d = data.data.jobRuns) === null || _d === void 0 ? void 0 : _d[0];
+                                    if (!mostRecentJobRun) {
+                                        reject(new Error('No job runs found'));
+                                        return;
+                                    }
+                                    const outputs = {};
+                                    (_e = mostRecentJobRun.stepRuns) === null || _e === void 0 ? void 0 : _e.forEach((stepRun) => {
+                                        var _a, _b;
+                                        const readable = (_b = (_a = mostRecentJobRun.job) === null || _a === void 0 ? void 0 : _a.steps) === null || _b === void 0 ? void 0 : _b.find((step) => step.metadata.id === stepRun.stepId);
+                                        const readableStepName = `${readable === null || readable === void 0 ? void 0 : readable.readableId}`;
+                                        try {
+                                            outputs[readableStepName] = JSON.parse(stepRun.output || '{}');
+                                        }
+                                        catch (error) {
+                                            outputs[readableStepName] = stepRun.output;
+                                        }
+                                    });
+                                    resolve(outputs);
+                                    return;
+                                }
                                 const result = event.results.reduce((acc, r) => (Object.assign(Object.assign({}, acc), { [r.stepReadableId]: JSON.parse(r.output || '{}') })), {});
                                 resolve(result);
                                 return;
@@ -92,7 +115,7 @@ class WorkflowRunRef {
                     catch (e_1_1) { e_1 = { error: e_1_1 }; }
                     finally {
                         try {
-                            if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                            if (!_f && !_a && (_b = _g.return)) yield _b.call(_g);
                         }
                         finally { if (e_1) throw e_1.error; }
                     }