@hatchet-dev/typescript-sdk 0.2.0 → 0.3.0

package/clients/dispatcher/action-listener.d.ts

@@ -2,6 +2,10 @@ import { DispatcherClient as PbDispatcherClient, AssignedAction } from '../../pr
 import { ClientConfig } from '../hatchet-client/client-config';
 import { Logger } from '../../util/logger';
 import { DispatcherClient } from './dispatcher-client';
+declare enum ListenStrategy {
+    LISTEN_STRATEGY_V1 = 1,
+    LISTEN_STRATEGY_V2 = 2
+}
 export interface Action {
     tenantId: string;
     jobId: string;
@@ -26,9 +30,16 @@ export declare class ActionListener {
     retryInterval: number;
     retryCount: number;
     done: boolean;
+    listenStrategy: ListenStrategy;
+    heartbeatInterval: any;
     constructor(client: DispatcherClient, workerId: string, retryInterval?: number, retryCount?: number);
     actions: () => AsyncGenerator<Action, void, unknown>;
+    setListenStrategy(strategy: ListenStrategy): Promise<void>;
+    getListenStrategy(): Promise<ListenStrategy>;
     incrementRetries(): Promise<void>;
+    heartbeat(): Promise<void>;
+    closeHeartbeat(): void;
     getListenClient(): Promise<AsyncIterable<AssignedAction>>;
     unregister(): Promise<import("../../protoc/dispatcher").WorkerUnsubscribeResponse>;
 }
+export {};

package/clients/dispatcher/action-listener.js

@@ -39,6 +39,12 @@ const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error
 const logger_1 = require("../../util/logger");
 const DEFAULT_ACTION_LISTENER_RETRY_INTERVAL = 5000; // milliseconds
 const DEFAULT_ACTION_LISTENER_RETRY_COUNT = 5;
+// eslint-disable-next-line no-shadow
+var ListenStrategy;
+(function (ListenStrategy) {
+    ListenStrategy[ListenStrategy["LISTEN_STRATEGY_V1"] = 1] = "LISTEN_STRATEGY_V1";
+    ListenStrategy[ListenStrategy["LISTEN_STRATEGY_V2"] = 2] = "LISTEN_STRATEGY_V2";
+})(ListenStrategy || (ListenStrategy = {}));
 class ActionListener {
     constructor(client, workerId, retryInterval = DEFAULT_ACTION_LISTENER_RETRY_INTERVAL, retryCount = DEFAULT_ACTION_LISTENER_RETRY_COUNT) {
         this.lastConnectionAttempt = 0;
@@ -46,6 +52,7 @@ class ActionListener {
         this.retryInterval = DEFAULT_ACTION_LISTENER_RETRY_INTERVAL;
         this.retryCount = DEFAULT_ACTION_LISTENER_RETRY_COUNT;
         this.done = false;
+        this.listenStrategy = ListenStrategy.LISTEN_STRATEGY_V2;
         this.actions = () => (function gen(client) {
             return __asyncGenerator(this, arguments, function* gen_1() {
                 var _a, e_1, _b, _c;
@@ -79,6 +86,10 @@ class ActionListener {
                         if (e.code === nice_grpc_1.Status.CANCELLED) {
                             break;
                         }
+                        if ((yield __await(client.getListenStrategy())) === ListenStrategy.LISTEN_STRATEGY_V2 &&
+                            e.code === nice_grpc_1.Status.UNIMPLEMENTED) {
+                            client.setListenStrategy(ListenStrategy.LISTEN_STRATEGY_V1);
+                        }
                         client.incrementRetries();
                     }
                 }
@@ -91,11 +102,62 @@ class ActionListener {
         this.retryInterval = retryInterval;
         this.retryCount = retryCount;
     }
+    setListenStrategy(strategy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.listenStrategy = strategy;
+        });
+    }
+    getListenStrategy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.listenStrategy;
+        });
+    }
     incrementRetries() {
         return __awaiter(this, void 0, void 0, function* () {
             this.retries += 1;
         });
     }
+    heartbeat() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.heartbeatInterval) {
+                return;
+            }
+            // start with a heartbeat
+            try {
+                yield this.client.heartbeat({
+                    workerId: this.workerId,
+                    heartbeatAt: new Date(),
+                });
+            }
+            catch (e) {
+                this.logger.error(`Failed to send heartbeat: ${e.message}`);
+                if (e.code === nice_grpc_1.Status.UNIMPLEMENTED) {
+                    return;
+                }
+            }
+            this.heartbeatInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.client.heartbeat({
+                        workerId: this.workerId,
+                        heartbeatAt: new Date(),
+                    });
+                }
+                catch (e) {
+                    if (e.code === nice_grpc_1.Status.UNIMPLEMENTED) {
+                        // break out of interval
+                        this.closeHeartbeat();
+                        return;
+                    }
+                    this.logger.error(`Failed to send heartbeat: ${e.message}`);
+                }
+            }), 4000);
+        });
+    }
+    closeHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+    }
     getListenClient() {
         return __awaiter(this, void 0, void 0, function* () {
             const currentTime = Math.floor(Date.now());
@@ -112,9 +174,16 @@ class ActionListener {
                 yield (0, sleep_1.default)(DEFAULT_ACTION_LISTENER_RETRY_INTERVAL);
             }
             try {
-                return this.client.listen({
+                if (this.listenStrategy === ListenStrategy.LISTEN_STRATEGY_V1) {
+                    return this.client.listen({
+                        workerId: this.workerId,
+                    });
+                }
+                const res = this.client.listenV2({
                     workerId: this.workerId,
                 });
+                this.heartbeat();
+                return res;
             }
             catch (e) {
                 this.retries += 1;
@@ -126,6 +195,7 @@ class ActionListener {
     unregister() {
         return __awaiter(this, void 0, void 0, function* () {
             this.done = true;
+            this.closeHeartbeat();
             try {
                 return this.client.unsubscribe({
                     workerId: this.workerId,

package/clients/event/event-client.d.ts

@@ -15,4 +15,5 @@ export declare class EventClient {
     constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
     push<T>(type: string, input: T): Promise<import("../../protoc/events/events").Event>;
     putLog(stepRunId: string, log: string, level?: LogLevel): void;
+    putStream(stepRunId: string, data: string | Uint8Array): void;
 }

package/clients/event/event-client.js

@@ -65,5 +65,31 @@ class EventClient {
             this.logger.warn(`Could not put log: ${e.message}`);
         }
     }
+    putStream(stepRunId, data) {
+        const createdAt = new Date();
+        let dataBytes;
+        if (typeof data === 'string') {
+            dataBytes = new TextEncoder().encode(data);
+        }
+        else if (data instanceof Uint8Array) {
+            dataBytes = data;
+        }
+        else {
+            throw new Error('Invalid data type. Expected string or Uint8Array.');
+        }
+        try {
+            (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () {
+                return this.client.putStreamEvent({
+                    stepRunId,
+                    createdAt,
+                    message: dataBytes,
+                });
+            }), this.logger);
+        }
+        catch (e) {
+            // log a warning, but this is not a fatal error
+            this.logger.warn(`Could not put log: ${e.message}`);
+        }
+    }
 }
 exports.EventClient = EventClient;

package/clients/listener/listener-client.d.ts

@@ -11,6 +11,7 @@ export declare enum RunEventType {
     STEP_RUN_EVENT_TYPE_FAILED = "STEP_RUN_EVENT_TYPE_FAILED",
     STEP_RUN_EVENT_TYPE_CANCELLED = "STEP_RUN_EVENT_TYPE_CANCELLED",
     STEP_RUN_EVENT_TYPE_TIMED_OUT = "STEP_RUN_EVENT_TYPE_TIMED_OUT",
+    STEP_RUN_EVENT_TYPE_STREAM = "STEP_RUN_EVENT_TYPE_STREAM",
     WORKFLOW_RUN_EVENT_TYPE_STARTED = "WORKFLOW_RUN_EVENT_TYPE_STARTED",
     WORKFLOW_RUN_EVENT_TYPE_COMPLETED = "WORKFLOW_RUN_EVENT_TYPE_COMPLETED",
     WORKFLOW_RUN_EVENT_TYPE_FAILED = "WORKFLOW_RUN_EVENT_TYPE_FAILED",

package/clients/listener/listener-client.js

@@ -52,6 +52,7 @@ var RunEventType;
     RunEventType["STEP_RUN_EVENT_TYPE_FAILED"] = "STEP_RUN_EVENT_TYPE_FAILED";
     RunEventType["STEP_RUN_EVENT_TYPE_CANCELLED"] = "STEP_RUN_EVENT_TYPE_CANCELLED";
     RunEventType["STEP_RUN_EVENT_TYPE_TIMED_OUT"] = "STEP_RUN_EVENT_TYPE_TIMED_OUT";
+    RunEventType["STEP_RUN_EVENT_TYPE_STREAM"] = "STEP_RUN_EVENT_TYPE_STREAM";
     RunEventType["WORKFLOW_RUN_EVENT_TYPE_STARTED"] = "WORKFLOW_RUN_EVENT_TYPE_STARTED";
     RunEventType["WORKFLOW_RUN_EVENT_TYPE_COMPLETED"] = "WORKFLOW_RUN_EVENT_TYPE_COMPLETED";
     RunEventType["WORKFLOW_RUN_EVENT_TYPE_FAILED"] = "WORKFLOW_RUN_EVENT_TYPE_FAILED";
@@ -64,6 +65,7 @@ const stepEventTypeMap = {
     [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_FAILED]: RunEventType.STEP_RUN_EVENT_TYPE_FAILED,
     [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_CANCELLED]: RunEventType.STEP_RUN_EVENT_TYPE_CANCELLED,
     [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_TIMED_OUT]: RunEventType.STEP_RUN_EVENT_TYPE_TIMED_OUT,
+    [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_STREAM]: RunEventType.STEP_RUN_EVENT_TYPE_STREAM,
     [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_UNKNOWN]: undefined,
     [dispatcher_1.ResourceEventType.UNRECOGNIZED]: undefined,
 };
@@ -74,6 +76,7 @@ const workflowEventTypeMap = {
     [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_CANCELLED]: RunEventType.WORKFLOW_RUN_EVENT_TYPE_CANCELLED,
     [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_TIMED_OUT]: RunEventType.WORKFLOW_RUN_EVENT_TYPE_TIMED_OUT,
     [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_UNKNOWN]: undefined,
+    [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_STREAM]: undefined,
     [dispatcher_1.ResourceEventType.UNRECOGNIZED]: undefined,
 };
 const resourceTypeMap = {

package/package.json

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

package/protoc/dispatcher/dispatcher.d.ts

@@ -42,6 +42,7 @@ export declare enum ResourceEventType {
     RESOURCE_EVENT_TYPE_FAILED = 3,
     RESOURCE_EVENT_TYPE_CANCELLED = 4,
     RESOURCE_EVENT_TYPE_TIMED_OUT = 5,
+    RESOURCE_EVENT_TYPE_STREAM = 6,
     UNRECOGNIZED = -1
 }
 export declare function resourceEventTypeFromJSON(object: any): ResourceEventType;
@@ -178,6 +179,14 @@ export interface OverridesData {
 }
 export interface OverridesDataResponse {
 }
+export interface HeartbeatRequest {
+    /** the id of the worker */
+    workerId: string;
+    /** heartbeatAt is the time the worker sent the heartbeat */
+    heartbeatAt: Date | undefined;
+}
+export interface HeartbeatResponse {
+}
 export declare const WorkerRegisterRequest: {
     encode(message: WorkerRegisterRequest, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): WorkerRegisterRequest;
@@ -282,6 +291,22 @@ export declare const OverridesDataResponse: {
     create(base?: DeepPartial<OverridesDataResponse>): OverridesDataResponse;
     fromPartial(_: DeepPartial<OverridesDataResponse>): OverridesDataResponse;
 };
+export declare const HeartbeatRequest: {
+    encode(message: HeartbeatRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): HeartbeatRequest;
+    fromJSON(object: any): HeartbeatRequest;
+    toJSON(message: HeartbeatRequest): unknown;
+    create(base?: DeepPartial<HeartbeatRequest>): HeartbeatRequest;
+    fromPartial(object: DeepPartial<HeartbeatRequest>): HeartbeatRequest;
+};
+export declare const HeartbeatResponse: {
+    encode(_: HeartbeatResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): HeartbeatResponse;
+    fromJSON(_: any): HeartbeatResponse;
+    toJSON(_: HeartbeatResponse): unknown;
+    create(base?: DeepPartial<HeartbeatResponse>): HeartbeatResponse;
+    fromPartial(_: DeepPartial<HeartbeatResponse>): HeartbeatResponse;
+};
 export type DispatcherDefinition = typeof DispatcherDefinition;
 export declare const DispatcherDefinition: {
     readonly name: "Dispatcher";
@@ -331,6 +356,55 @@ export declare const DispatcherDefinition: {
             readonly responseStream: true;
             readonly options: {};
         };
+        /**
+         * ListenV2 is like listen, but implementation does not include heartbeats. This should only used by SDKs
+         * against engine version v0.18.1+
+         */
+        readonly listenV2: {
+            readonly name: "ListenV2";
+            readonly requestType: {
+                encode(message: WorkerListenRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): WorkerListenRequest;
+                fromJSON(object: any): WorkerListenRequest;
+                toJSON(message: WorkerListenRequest): unknown;
+                create(base?: DeepPartial<WorkerListenRequest>): WorkerListenRequest;
+                fromPartial(object: DeepPartial<WorkerListenRequest>): WorkerListenRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: AssignedAction, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): AssignedAction;
+                fromJSON(object: any): AssignedAction;
+                toJSON(message: AssignedAction): unknown;
+                create(base?: DeepPartial<AssignedAction>): AssignedAction;
+                fromPartial(object: DeepPartial<AssignedAction>): AssignedAction;
+            };
+            readonly responseStream: true;
+            readonly options: {};
+        };
+        /** Heartbeat is a method for workers to send heartbeats to the dispatcher */
+        readonly heartbeat: {
+            readonly name: "Heartbeat";
+            readonly requestType: {
+                encode(message: HeartbeatRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HeartbeatRequest;
+                fromJSON(object: any): HeartbeatRequest;
+                toJSON(message: HeartbeatRequest): unknown;
+                create(base?: DeepPartial<HeartbeatRequest>): HeartbeatRequest;
+                fromPartial(object: DeepPartial<HeartbeatRequest>): HeartbeatRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(_: HeartbeatResponse, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HeartbeatResponse;
+                fromJSON(_: any): HeartbeatResponse;
+                toJSON(_: HeartbeatResponse): unknown;
+                create(base?: DeepPartial<HeartbeatResponse>): HeartbeatResponse;
+                fromPartial(_: DeepPartial<HeartbeatResponse>): HeartbeatResponse;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
         readonly subscribeToWorkflowEvents: {
             readonly name: "SubscribeToWorkflowEvents";
             readonly requestType: {
@@ -446,6 +520,13 @@ export declare const DispatcherDefinition: {
 export interface DispatcherServiceImplementation<CallContextExt = {}> {
     register(request: WorkerRegisterRequest, context: CallContext & CallContextExt): Promise<DeepPartial<WorkerRegisterResponse>>;
     listen(request: WorkerListenRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<AssignedAction>>;
+    /**
+     * ListenV2 is like listen, but implementation does not include heartbeats. This should only used by SDKs
+     * against engine version v0.18.1+
+     */
+    listenV2(request: WorkerListenRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<AssignedAction>>;
+    /** Heartbeat is a method for workers to send heartbeats to the dispatcher */
+    heartbeat(request: HeartbeatRequest, context: CallContext & CallContextExt): Promise<DeepPartial<HeartbeatResponse>>;
     subscribeToWorkflowEvents(request: SubscribeToWorkflowEventsRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<WorkflowEvent>>;
     sendStepActionEvent(request: StepActionEvent, context: CallContext & CallContextExt): Promise<DeepPartial<ActionEventResponse>>;
     sendGroupKeyActionEvent(request: GroupKeyActionEvent, context: CallContext & CallContextExt): Promise<DeepPartial<ActionEventResponse>>;
@@ -455,6 +536,13 @@ export interface DispatcherServiceImplementation<CallContextExt = {}> {
 export interface DispatcherClient<CallOptionsExt = {}> {
     register(request: DeepPartial<WorkerRegisterRequest>, options?: CallOptions & CallOptionsExt): Promise<WorkerRegisterResponse>;
     listen(request: DeepPartial<WorkerListenRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<AssignedAction>;
+    /**
+     * ListenV2 is like listen, but implementation does not include heartbeats. This should only used by SDKs
+     * against engine version v0.18.1+
+     */
+    listenV2(request: DeepPartial<WorkerListenRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<AssignedAction>;
+    /** Heartbeat is a method for workers to send heartbeats to the dispatcher */
+    heartbeat(request: DeepPartial<HeartbeatRequest>, options?: CallOptions & CallOptionsExt): Promise<HeartbeatResponse>;
     subscribeToWorkflowEvents(request: DeepPartial<SubscribeToWorkflowEventsRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<WorkflowEvent>;
     sendStepActionEvent(request: DeepPartial<StepActionEvent>, options?: CallOptions & CallOptionsExt): Promise<ActionEventResponse>;
     sendGroupKeyActionEvent(request: DeepPartial<GroupKeyActionEvent>, options?: CallOptions & CallOptionsExt): Promise<ActionEventResponse>;

package/protoc/dispatcher/dispatcher.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DispatcherDefinition = exports.OverridesDataResponse = exports.OverridesData = exports.WorkflowEvent = exports.SubscribeToWorkflowEventsRequest = exports.ActionEventResponse = exports.StepActionEvent = exports.GroupKeyActionEvent = exports.WorkerUnsubscribeResponse = exports.WorkerUnsubscribeRequest = exports.WorkerListenRequest = exports.AssignedAction = exports.WorkerRegisterResponse = exports.WorkerRegisterRequest = exports.resourceEventTypeToJSON = exports.resourceEventTypeFromJSON = exports.ResourceEventType = exports.resourceTypeToJSON = exports.resourceTypeFromJSON = exports.ResourceType = exports.stepActionEventTypeToJSON = exports.stepActionEventTypeFromJSON = exports.StepActionEventType = exports.groupKeyActionEventTypeToJSON = exports.groupKeyActionEventTypeFromJSON = exports.GroupKeyActionEventType = exports.actionTypeToJSON = exports.actionTypeFromJSON = exports.ActionType = exports.protobufPackage = void 0;
+exports.DispatcherDefinition = exports.HeartbeatResponse = exports.HeartbeatRequest = exports.OverridesDataResponse = exports.OverridesData = exports.WorkflowEvent = exports.SubscribeToWorkflowEventsRequest = exports.ActionEventResponse = exports.StepActionEvent = exports.GroupKeyActionEvent = exports.WorkerUnsubscribeResponse = exports.WorkerUnsubscribeRequest = exports.WorkerListenRequest = exports.AssignedAction = exports.WorkerRegisterResponse = exports.WorkerRegisterRequest = exports.resourceEventTypeToJSON = exports.resourceEventTypeFromJSON = exports.ResourceEventType = exports.resourceTypeToJSON = exports.resourceTypeFromJSON = exports.ResourceType = exports.stepActionEventTypeToJSON = exports.stepActionEventTypeFromJSON = exports.StepActionEventType = exports.groupKeyActionEventTypeToJSON = exports.groupKeyActionEventTypeFromJSON = exports.GroupKeyActionEventType = exports.actionTypeToJSON = exports.actionTypeFromJSON = exports.ActionType = exports.protobufPackage = void 0;
 const _m0 = __importStar(require("protobufjs/minimal"));
 const timestamp_1 = require("../google/protobuf/timestamp");
 exports.protobufPackage = '';
@@ -203,6 +203,7 @@ var ResourceEventType;
     ResourceEventType[ResourceEventType["RESOURCE_EVENT_TYPE_FAILED"] = 3] = "RESOURCE_EVENT_TYPE_FAILED";
     ResourceEventType[ResourceEventType["RESOURCE_EVENT_TYPE_CANCELLED"] = 4] = "RESOURCE_EVENT_TYPE_CANCELLED";
     ResourceEventType[ResourceEventType["RESOURCE_EVENT_TYPE_TIMED_OUT"] = 5] = "RESOURCE_EVENT_TYPE_TIMED_OUT";
+    ResourceEventType[ResourceEventType["RESOURCE_EVENT_TYPE_STREAM"] = 6] = "RESOURCE_EVENT_TYPE_STREAM";
     ResourceEventType[ResourceEventType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(ResourceEventType || (exports.ResourceEventType = ResourceEventType = {}));
 function resourceEventTypeFromJSON(object) {
@@ -225,6 +226,9 @@ function resourceEventTypeFromJSON(object) {
         case 5:
         case 'RESOURCE_EVENT_TYPE_TIMED_OUT':
             return ResourceEventType.RESOURCE_EVENT_TYPE_TIMED_OUT;
+        case 6:
+        case 'RESOURCE_EVENT_TYPE_STREAM':
+            return ResourceEventType.RESOURCE_EVENT_TYPE_STREAM;
         case -1:
         case 'UNRECOGNIZED':
         default:
@@ -246,6 +250,8 @@ function resourceEventTypeToJSON(object) {
             return 'RESOURCE_EVENT_TYPE_CANCELLED';
         case ResourceEventType.RESOURCE_EVENT_TYPE_TIMED_OUT:
             return 'RESOURCE_EVENT_TYPE_TIMED_OUT';
+        case ResourceEventType.RESOURCE_EVENT_TYPE_STREAM:
+            return 'RESOURCE_EVENT_TYPE_STREAM';
         case ResourceEventType.UNRECOGNIZED:
         default:
             return 'UNRECOGNIZED';
@@ -1579,6 +1585,110 @@ exports.OverridesDataResponse = {
         return message;
     },
 };
+function createBaseHeartbeatRequest() {
+    return { workerId: '', heartbeatAt: undefined };
+}
+exports.HeartbeatRequest = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.workerId !== '') {
+            writer.uint32(10).string(message.workerId);
+        }
+        if (message.heartbeatAt !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.heartbeatAt), writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseHeartbeatRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.workerId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.heartbeatAt = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            workerId: isSet(object.workerId) ? globalThis.String(object.workerId) : '',
+            heartbeatAt: isSet(object.heartbeatAt) ? fromJsonTimestamp(object.heartbeatAt) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.workerId !== '') {
+            obj.workerId = message.workerId;
+        }
+        if (message.heartbeatAt !== undefined) {
+            obj.heartbeatAt = message.heartbeatAt.toISOString();
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.HeartbeatRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBaseHeartbeatRequest();
+        message.workerId = (_a = object.workerId) !== null && _a !== void 0 ? _a : '';
+        message.heartbeatAt = (_b = object.heartbeatAt) !== null && _b !== void 0 ? _b : undefined;
+        return message;
+    },
+};
+function createBaseHeartbeatResponse() {
+    return {};
+}
+exports.HeartbeatResponse = {
+    encode(_, writer = _m0.Writer.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseHeartbeatResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(_) {
+        return {};
+    },
+    toJSON(_) {
+        const obj = {};
+        return obj;
+    },
+    create(base) {
+        return exports.HeartbeatResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(_) {
+        const message = createBaseHeartbeatResponse();
+        return message;
+    },
+};
 exports.DispatcherDefinition = {
     name: 'Dispatcher',
     fullName: 'Dispatcher',
@@ -1599,6 +1709,27 @@ exports.DispatcherDefinition = {
             responseStream: true,
             options: {},
         },
+        /**
+         * ListenV2 is like listen, but implementation does not include heartbeats. This should only used by SDKs
+         * against engine version v0.18.1+
+         */
+        listenV2: {
+            name: 'ListenV2',
+            requestType: exports.WorkerListenRequest,
+            requestStream: false,
+            responseType: exports.AssignedAction,
+            responseStream: true,
+            options: {},
+        },
+        /** Heartbeat is a method for workers to send heartbeats to the dispatcher */
+        heartbeat: {
+            name: 'Heartbeat',
+            requestType: exports.HeartbeatRequest,
+            requestStream: false,
+            responseType: exports.HeartbeatResponse,
+            responseStream: false,
+            options: {},
+        },
         subscribeToWorkflowEvents: {
             name: 'SubscribeToWorkflowEvents',
             requestType: exports.SubscribeToWorkflowEventsRequest,

package/protoc/events/events.d.ts

@@ -27,6 +27,18 @@ export interface PutLogRequest {
 }
 export interface PutLogResponse {
 }
+export interface PutStreamEventRequest {
+    /** the step run id for the request */
+    stepRunId: string;
+    /** when the stream event was created */
+    createdAt: Date | undefined;
+    /** the stream event message */
+    message: Uint8Array;
+    /** associated stream event metadata */
+    metadata: string;
+}
+export interface PutStreamEventResponse {
+}
 export interface PushEventRequest {
     /** the key for the event */
     key: string;
@@ -63,6 +75,22 @@ export declare const PutLogResponse: {
     create(base?: DeepPartial<PutLogResponse>): PutLogResponse;
     fromPartial(_: DeepPartial<PutLogResponse>): PutLogResponse;
 };
+export declare const PutStreamEventRequest: {
+    encode(message: PutStreamEventRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PutStreamEventRequest;
+    fromJSON(object: any): PutStreamEventRequest;
+    toJSON(message: PutStreamEventRequest): unknown;
+    create(base?: DeepPartial<PutStreamEventRequest>): PutStreamEventRequest;
+    fromPartial(object: DeepPartial<PutStreamEventRequest>): PutStreamEventRequest;
+};
+export declare const PutStreamEventResponse: {
+    encode(_: PutStreamEventResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PutStreamEventResponse;
+    fromJSON(_: any): PutStreamEventResponse;
+    toJSON(_: PutStreamEventResponse): unknown;
+    create(base?: DeepPartial<PutStreamEventResponse>): PutStreamEventResponse;
+    fromPartial(_: DeepPartial<PutStreamEventResponse>): PutStreamEventResponse;
+};
 export declare const PushEventRequest: {
     encode(message: PushEventRequest, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): PushEventRequest;
@@ -150,17 +178,41 @@ export declare const EventsServiceDefinition: {
             readonly responseStream: false;
             readonly options: {};
         };
+        readonly putStreamEvent: {
+            readonly name: "PutStreamEvent";
+            readonly requestType: {
+                encode(message: PutStreamEventRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): PutStreamEventRequest;
+                fromJSON(object: any): PutStreamEventRequest;
+                toJSON(message: PutStreamEventRequest): unknown;
+                create(base?: DeepPartial<PutStreamEventRequest>): PutStreamEventRequest;
+                fromPartial(object: DeepPartial<PutStreamEventRequest>): PutStreamEventRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(_: PutStreamEventResponse, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): PutStreamEventResponse;
+                fromJSON(_: any): PutStreamEventResponse;
+                toJSON(_: PutStreamEventResponse): unknown;
+                create(base?: DeepPartial<PutStreamEventResponse>): PutStreamEventResponse;
+                fromPartial(_: DeepPartial<PutStreamEventResponse>): PutStreamEventResponse;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
     };
 };
 export interface EventsServiceImplementation<CallContextExt = {}> {
     push(request: PushEventRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Event>>;
     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>;
     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>;
 }
 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 {} ? {

package/protoc/events/events.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventsServiceDefinition = exports.ReplayEventRequest = exports.PushEventRequest = exports.PutLogResponse = exports.PutLogRequest = exports.Event = exports.protobufPackage = void 0;
+exports.EventsServiceDefinition = exports.ReplayEventRequest = exports.PushEventRequest = exports.PutStreamEventResponse = exports.PutStreamEventRequest = exports.PutLogResponse = exports.PutLogRequest = exports.Event = exports.protobufPackage = void 0;
 const _m0 = __importStar(require("protobufjs/minimal"));
 const timestamp_1 = require("../google/protobuf/timestamp");
 exports.protobufPackage = '';
@@ -284,6 +284,138 @@ exports.PutLogResponse = {
         return message;
     },
 };
+function createBasePutStreamEventRequest() {
+    return { stepRunId: '', createdAt: undefined, message: new Uint8Array(0), metadata: '' };
+}
+exports.PutStreamEventRequest = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.stepRunId !== '') {
+            writer.uint32(10).string(message.stepRunId);
+        }
+        if (message.createdAt !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.createdAt), writer.uint32(18).fork()).ldelim();
+        }
+        if (message.message.length !== 0) {
+            writer.uint32(26).bytes(message.message);
+        }
+        if (message.metadata !== '') {
+            writer.uint32(42).string(message.metadata);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePutStreamEventRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.stepRunId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.createdAt = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.message = reader.bytes();
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.metadata = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            stepRunId: isSet(object.stepRunId) ? globalThis.String(object.stepRunId) : '',
+            createdAt: isSet(object.createdAt) ? fromJsonTimestamp(object.createdAt) : undefined,
+            message: isSet(object.message) ? bytesFromBase64(object.message) : new Uint8Array(0),
+            metadata: isSet(object.metadata) ? globalThis.String(object.metadata) : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.stepRunId !== '') {
+            obj.stepRunId = message.stepRunId;
+        }
+        if (message.createdAt !== undefined) {
+            obj.createdAt = message.createdAt.toISOString();
+        }
+        if (message.message.length !== 0) {
+            obj.message = base64FromBytes(message.message);
+        }
+        if (message.metadata !== '') {
+            obj.metadata = message.metadata;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.PutStreamEventRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c, _d;
+        const message = createBasePutStreamEventRequest();
+        message.stepRunId = (_a = object.stepRunId) !== null && _a !== void 0 ? _a : '';
+        message.createdAt = (_b = object.createdAt) !== null && _b !== void 0 ? _b : undefined;
+        message.message = (_c = object.message) !== null && _c !== void 0 ? _c : new Uint8Array(0);
+        message.metadata = (_d = object.metadata) !== null && _d !== void 0 ? _d : '';
+        return message;
+    },
+};
+function createBasePutStreamEventResponse() {
+    return {};
+}
+exports.PutStreamEventResponse = {
+    encode(_, writer = _m0.Writer.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePutStreamEventResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(_) {
+        return {};
+    },
+    toJSON(_) {
+        const obj = {};
+        return obj;
+    },
+    create(base) {
+        return exports.PutStreamEventResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(_) {
+        const message = createBasePutStreamEventResponse();
+        return message;
+    },
+};
 function createBasePushEventRequest() {
     return { key: '', payload: '', eventTimestamp: undefined };
 }
@@ -446,8 +578,41 @@ exports.EventsServiceDefinition = {
             responseStream: false,
             options: {},
         },
+        putStreamEvent: {
+            name: 'PutStreamEvent',
+            requestType: exports.PutStreamEventRequest,
+            requestStream: false,
+            responseType: exports.PutStreamEventResponse,
+            responseStream: false,
+            options: {},
+        },
     },
 };
+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 toTimestamp(date) {
     const seconds = Math.trunc(date.getTime() / 1000);
     const nanos = (date.getTime() % 1000) * 1000000;

package/step.d.ts

@@ -59,6 +59,7 @@ export declare class Context<T, K> {
     workflowRunId(): string;
     playground(name: string, defaultValue?: string): string;
     log(message: string, level?: LogLevel): void;
+    putStream(data: string | Uint8Array): Promise<void>;
     spawnWorkflow<P = unknown>(workflowName: string, input: T, key?: string): ChildWorkflowRef<P>;
 }
 export type StepRunFunction<T, K> = (ctx: Context<T, K>) => Promise<NextStep> | NextStep | void;

package/step.js

@@ -182,6 +182,17 @@ class Context {
         }
         this.client.event.putLog(stepRunId, message, level);
     }
+    putStream(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { stepRunId } = this.action;
+            if (!stepRunId) {
+                // log a warning
+                this.logger.warn('cannot log from context without stepRunId');
+                return;
+            }
+            yield this.client.event.putStream(stepRunId, data);
+        });
+    }
     spawnWorkflow(workflowName, input, key) {
         const { workflowRunId, stepRunId } = this.action;
         const childWorkflowRunIdPromise = this.client.admin.run_workflow(workflowName, input, {