@proompteng/temporal-bun-sdk 0.2.0 → 0.3.0

package/dist/src/worker/runtime.js

@@ -18,9 +18,10 @@ import { CommandType } from '../proto/temporal/api/enums/v1/command_type_pb';
 import { WorkerVersioningMode } from '../proto/temporal/api/enums/v1/deployment_pb';
 import { EventType } from '../proto/temporal/api/enums/v1/event_type_pb';
 import { WorkflowTaskFailedCause } from '../proto/temporal/api/enums/v1/failed_cause_pb';
+import { QueryResultType } from '../proto/temporal/api/enums/v1/query_pb';
 import { HistoryEventFilterType, TimeoutType, VersioningBehavior } from '../proto/temporal/api/enums/v1/workflow_pb';
 import { StickyExecutionAttributesSchema, TaskQueueSchema, } from '../proto/temporal/api/taskqueue/v1/message_pb';
-import { GetWorkflowExecutionHistoryRequestSchema, PollActivityTaskQueueRequestSchema, PollWorkflowTaskQueueRequestSchema, RespondActivityTaskCanceledRequestSchema, RespondActivityTaskCompletedRequestSchema, RespondActivityTaskFailedRequestSchema, RespondWorkflowTaskCompletedRequestSchema, RespondWorkflowTaskFailedRequestSchema, } from '../proto/temporal/api/workflowservice/v1/request_response_pb';
+import { GetWorkflowExecutionHistoryRequestSchema, PollActivityTaskQueueRequestSchema, PollWorkflowTaskQueueRequestSchema, RespondActivityTaskCanceledRequestSchema, RespondActivityTaskCompletedRequestSchema, RespondActivityTaskFailedRequestSchema, RespondQueryTaskCompletedRequestSchema, RespondWorkflowTaskCompletedRequestSchema, RespondWorkflowTaskFailedRequestSchema, } from '../proto/temporal/api/workflowservice/v1/request_response_pb';
 import { WorkflowService } from '../proto/temporal/api/workflowservice/v1/service_pb';
 import { WorkflowNondeterminismError } from '../workflow/errors';
 import { WorkflowExecutor } from '../workflow/executor';
@@ -30,6 +31,24 @@ import { runWithActivityContext } from './activity-context';
 import { checkWorkerVersioningCapability, registerWorkerBuildIdCompatibility } from './build-id';
 import { makeWorkerScheduler, } from './concurrency';
 import { makeStickyCache, } from './sticky-cache';
+import { buildUpdateProtocolMessages, collectWorkflowUpdates } from './update-protocol';
+const mergeUpdateInvocations = (historyInvocations, messageInvocations) => {
+    const merged = [];
+    const seen = new Set();
+    for (const invocation of historyInvocations ?? []) {
+        if (!seen.has(invocation.updateId)) {
+            merged.push(invocation);
+            seen.add(invocation.updateId);
+        }
+    }
+    for (const invocation of messageInvocations ?? []) {
+        if (!seen.has(invocation.updateId)) {
+            merged.push(invocation);
+            seen.add(invocation.updateId);
+        }
+    }
+    return merged;
+};
 const POLL_TIMEOUT_MS = 60_000;
 const RESPOND_TIMEOUT_MS = 15_000;
 const HISTORY_FETCH_TIMEOUT_MS = 60_000;
@@ -98,6 +117,12 @@ export class WorkerRuntime {
             activityConcurrency,
             hooks: options.schedulerHooks,
             logger,
+            metrics: {
+                workflowTaskStarted: runtimeMetrics.workflowTaskStarted,
+                workflowTaskCompleted: runtimeMetrics.workflowTaskCompleted,
+                activityTaskStarted: runtimeMetrics.activityTaskStarted,
+                activityTaskCompleted: runtimeMetrics.activityTaskCompleted,
+            },
         }));
         const stickyCacheCandidate = options.stickyCache;
         const hasStickyCacheInstance = WorkerRuntime.#isStickyCacheInstance(stickyCacheCandidate);
@@ -267,7 +292,11 @@ export class WorkerRuntime {
         if (!state) {
             return false;
         }
-        return state.commandHistory.length > 0 || state.randomValues.length > 0 || state.timeValues.length > 0;
+        return (state.commandHistory.length > 0 ||
+            state.randomValues.length > 0 ||
+            state.timeValues.length > 0 ||
+            (state.signals?.length ?? 0) > 0 ||
+            (state.queries?.length ?? 0) > 0);
     }
     #resolvePreviousHistoryEventId(response) {
         const previous = response.previousStartedEventId;
@@ -320,6 +349,10 @@ export class WorkerRuntime {
             heartbeatFailures: await makeCounter('temporal_worker_heartbeat_failures_total', 'Activity heartbeat failures'),
             activityFailures: await makeCounter('temporal_worker_activity_failures_total', 'Activity failures delivered to Temporal'),
             workflowFailures: await makeCounter('temporal_worker_workflow_failures_total', 'Workflow failure responses sent to Temporal'),
+            workflowTaskStarted: await makeCounter('temporal_worker_workflow_tasks_started_total', 'Workflow tasks dispatched to the scheduler'),
+            workflowTaskCompleted: await makeCounter('temporal_worker_workflow_tasks_completed_total', 'Workflow tasks completed by the scheduler'),
+            activityTaskStarted: await makeCounter('temporal_worker_activity_tasks_started_total', 'Activity tasks dispatched to the scheduler'),
+            activityTaskCompleted: await makeCounter('temporal_worker_activity_tasks_completed_total', 'Activity tasks completed by the scheduler'),
         };
     }
     async run() {
@@ -519,15 +552,45 @@ export class WorkerRuntime {
         const workflowType = this.#resolveWorkflowType(response, historyEvents);
         const args = await this.#decodeWorkflowArgs(historyEvents);
         const workflowInfo = this.#buildWorkflowInfo(workflowType, execution);
-        const stickyKey = this.#buildStickyKey(execution.workflowId, execution.runId);
-        const stickyEntry = stickyKey ? await this.#getStickyEntry(stickyKey) : undefined;
-        const historyReplay = await this.#ingestDeterminismState(workflowInfo, historyEvents);
-        const hasHistorySnapshot = this.#isValidDeterminismSnapshot(historyReplay?.determinismState);
+        const collectedUpdates = await collectWorkflowUpdates({
+            messages: response.messages ?? [],
+            dataConverter: this.#dataConverter,
+            log: (level, message, fields) => this.#log(level, message, fields),
+        });
         const baseLogFields = this.#workflowLogFields(execution, workflowType, {
             workflowTaskAttempt,
             stickyScheduling: this.#stickySchedulingEnabled,
             nondeterminismRetry,
         });
+        const signalDeliveries = await this.#extractSignalDeliveries(historyEvents);
+        if (signalDeliveries.length > 0) {
+            this.#log('debug', 'workflow signal deliveries buffered', {
+                ...baseLogFields,
+                signalCount: signalDeliveries.length,
+            });
+        }
+        const queryRequests = await this.#extractWorkflowQueryRequests(response);
+        const hasQueryRequests = queryRequests.length > 0;
+        const hasMultiQueries = queryRequests.some((request) => request.source === 'multi');
+        const hasLegacyQueries = queryRequests.some((request) => request.source === 'legacy');
+        if (hasQueryRequests) {
+            this.#log('debug', 'workflow queries pending evaluation', {
+                ...baseLogFields,
+                queryCount: queryRequests.length,
+            });
+        }
+        this.#log('info', 'debug: workflow task metadata', {
+            ...baseLogFields,
+            taskTokenBytes: response.taskToken?.length ?? 0,
+            queryCount: queryRequests.length,
+            historyEventCount: response.history?.events?.length ?? 0,
+        });
+        const stickyKey = this.#buildStickyKey(execution.workflowId, execution.runId);
+        const stickyEntry = stickyKey ? await this.#getStickyEntry(stickyKey) : undefined;
+        const historyReplay = await this.#ingestDeterminismState(workflowInfo, historyEvents, {
+            queryRequests,
+        });
+        const hasHistorySnapshot = this.#isValidDeterminismSnapshot(historyReplay?.determinismState);
         let previousState;
         if (stickyEntry && this.#isValidDeterminismSnapshot(stickyEntry.determinismState)) {
             const historyBaselineEventId = this.#resolvePreviousHistoryEventId(response) ?? historyReplay?.lastEventId ?? null;
@@ -575,6 +638,8 @@ export class WorkerRuntime {
         const expectedDeterminismState = previousState;
         try {
             const activityResults = await this.#extractActivityResolutions(historyEvents);
+            const replayUpdates = historyReplay?.updates ?? [];
+            const mergedUpdates = mergeUpdateInvocations(replayUpdates, collectedUpdates.invocations);
             const output = await this.#executor.execute({
                 workflowType,
                 workflowId: execution.workflowId,
@@ -584,10 +649,49 @@ export class WorkerRuntime {
                 arguments: args,
                 determinismState: previousState,
                 activityResults,
+                signalDeliveries,
+                queryRequests,
+                updates: mergedUpdates,
+            });
+            this.#log('debug', 'workflow query evaluation summary', {
+                ...baseLogFields,
+                queryResultCount: output.queryResults.length,
+            });
+            this.#log('debug', 'workflow query results raw', {
+                ...baseLogFields,
+                queryResults: output.queryResults.map((entry) => ({
+                    name: entry.request.name,
+                    source: entry.request.source,
+                    id: entry.request.id ?? null,
+                })),
             });
+            const multiQueryResults = {};
+            let legacyQueryResult;
+            for (const entry of output.queryResults) {
+                this.#log('debug', 'workflow query evaluation completed', {
+                    ...baseLogFields,
+                    querySource: entry.request.source,
+                    queryName: entry.request.name,
+                    queryId: entry.request.id ?? null,
+                });
+                if (entry.request.source === 'multi' && entry.request.id) {
+                    multiQueryResults[entry.request.id] = entry.result;
+                }
+                else if (entry.request.source === 'legacy') {
+                    legacyQueryResult = entry;
+                }
+            }
             const cacheBaselineEventId = this.#resolveCurrentStartedEventId(response) ?? historyReplay?.lastEventId ?? null;
             const shouldRecordMarker = output.completion === 'pending';
             let commandsForResponse = output.commands;
+            const dispatchesForNewMessages = (output.updateDispatches ?? []).filter((dispatch) => collectedUpdates.requestsByUpdateId.has(dispatch.updateId));
+            const updateProtocolMessages = await buildUpdateProtocolMessages({
+                dispatches: dispatchesForNewMessages,
+                collected: collectedUpdates,
+                dataConverter: this.#dataConverter,
+                defaultIdentity: this.#identity,
+                log: (level, message, fields) => this.#log(level, message, fields),
+            });
             if (stickyKey) {
                 if (output.completion === 'pending') {
                     await this.#upsertStickyEntry(stickyKey, output.determinismState, cacheBaselineEventId, workflowType);
@@ -614,24 +718,36 @@ export class WorkerRuntime {
                 const markerCommand = this.#buildDeterminismMarkerCommand(markerDetails);
                 commandsForResponse = this.#injectDeterminismMarker(commandsForResponse, markerCommand);
             }
-            const completion = create(RespondWorkflowTaskCompletedRequestSchema, {
-                taskToken: response.taskToken,
-                commands: commandsForResponse,
-                identity: this.#identity,
-                namespace: this.#namespace,
-                deploymentOptions: this.#deploymentOptions,
-                ...(this.#stickySchedulingEnabled ? { stickyAttributes: this.#stickyAttributes } : {}),
-                ...(this.#versioningBehavior !== null ? { versioningBehavior: this.#versioningBehavior } : {}),
-            });
-            try {
-                await this.#workflowService.respondWorkflowTaskCompleted(completion, { timeoutMs: RESPOND_TIMEOUT_MS });
-            }
-            catch (rpcError) {
-                if (this.#isTaskNotFoundError(rpcError)) {
-                    this.#logWorkflowTaskNotFound('respondWorkflowTaskCompleted', execution);
-                    return;
+            const shouldRespondWorkflowTask = hasMultiQueries || !hasLegacyQueries;
+            if (shouldRespondWorkflowTask) {
+                const completion = create(RespondWorkflowTaskCompletedRequestSchema, {
+                    taskToken: response.taskToken,
+                    commands: commandsForResponse,
+                    identity: this.#identity,
+                    namespace: this.#namespace,
+                    deploymentOptions: this.#deploymentOptions,
+                    queryResults: multiQueryResults,
+                    ...(this.#stickySchedulingEnabled && !hasLegacyQueries ? { stickyAttributes: this.#stickyAttributes } : {}),
+                    ...(this.#versioningBehavior !== null ? { versioningBehavior: this.#versioningBehavior } : {}),
+                    ...(updateProtocolMessages.length > 0 ? { messages: updateProtocolMessages } : {}),
+                });
+                try {
+                    await this.#workflowService.respondWorkflowTaskCompleted(completion, { timeoutMs: RESPOND_TIMEOUT_MS });
                 }
-                throw rpcError;
+                catch (rpcError) {
+                    this.#log('error', 'debug: respondWorkflowTaskCompleted failed', {
+                        ...baseLogFields,
+                        error: rpcError instanceof Error ? rpcError.message : String(rpcError),
+                    });
+                    if (this.#isTaskNotFoundError(rpcError)) {
+                        this.#logWorkflowTaskNotFound('respondWorkflowTaskCompleted', execution);
+                        return;
+                    }
+                    throw rpcError;
+                }
+            }
+            if (legacyQueryResult) {
+                await this.#respondLegacyQueryTask(response, legacyQueryResult);
             }
         }
         catch (error) {
@@ -693,7 +809,7 @@ export class WorkerRuntime {
             runId,
         };
     }
-    async #ingestDeterminismState(workflowInfo, historyEvents) {
+    async #ingestDeterminismState(workflowInfo, historyEvents, options) {
         if (historyEvents.length === 0) {
             return undefined;
         }
@@ -701,6 +817,7 @@ export class WorkerRuntime {
             info: workflowInfo,
             history: historyEvents,
             dataConverter: this.#dataConverter,
+            queries: options?.queryRequests,
         }));
     }
     async #collectWorkflowHistory(execution, _response) {
@@ -817,6 +934,107 @@ export class WorkerRuntime {
         }
         return resolutions;
     }
+    async #extractSignalDeliveries(events) {
+        const deliveries = [];
+        const normalizeEventId = (value) => {
+            if (value === undefined || value === null) {
+                return null;
+            }
+            if (typeof value === 'string') {
+                return value;
+            }
+            return value.toString();
+        };
+        for (const event of events) {
+            if (event.eventType !== EventType.WORKFLOW_EXECUTION_SIGNALED) {
+                continue;
+            }
+            if (event.attributes?.case !== 'workflowExecutionSignaledEventAttributes') {
+                continue;
+            }
+            const attrs = event.attributes.value;
+            const args = await decodePayloadsToValues(this.#dataConverter, attrs.input?.payloads ?? []);
+            const workflowTaskCompletedEventId = 'workflowTaskCompletedEventId' in attrs
+                ? normalizeEventId(attrs
+                    .workflowTaskCompletedEventId)
+                : null;
+            deliveries.push({
+                name: attrs.signalName ?? 'unknown',
+                args,
+                metadata: {
+                    eventId: normalizeEventId(event.eventId),
+                    workflowTaskCompletedEventId,
+                    identity: attrs.identity ?? null,
+                },
+            });
+        }
+        return deliveries;
+    }
+    async #extractWorkflowQueryRequests(response) {
+        const requests = [];
+        const map = response.queries ?? {};
+        this.#log('info', 'debug: workflow query payloads detected', {
+            namespace: this.#namespace,
+            taskQueue: this.#taskQueue,
+            workflowId: response.workflowExecution?.workflowId,
+            runId: response.workflowExecution?.runId,
+            queryMapSize: Object.keys(map).length,
+            hasLegacyQuery: Boolean(response.query),
+        });
+        for (const [id, query] of Object.entries(map)) {
+            const args = await decodePayloadsToValues(this.#dataConverter, query.queryArgs?.payloads ?? []);
+            const header = await this.#decodeQueryHeader(query);
+            requests.push({
+                id,
+                name: query.queryType ?? 'query',
+                args,
+                metadata: header ? { header } : undefined,
+                source: 'multi',
+            });
+        }
+        if (response.query) {
+            const args = await decodePayloadsToValues(this.#dataConverter, response.query.queryArgs?.payloads ?? []);
+            const header = await this.#decodeQueryHeader(response.query);
+            requests.push({
+                name: response.query.queryType ?? 'query',
+                args,
+                metadata: header ? { header } : undefined,
+                source: 'legacy',
+            });
+        }
+        return requests;
+    }
+    async #decodeQueryHeader(query) {
+        const fields = query?.header?.fields;
+        if (!fields || Object.keys(fields).length === 0) {
+            return undefined;
+        }
+        const decoded = {};
+        for (const [key, payload] of Object.entries(fields)) {
+            const values = await decodePayloadsToValues(this.#dataConverter, payload ? [payload] : []);
+            decoded[key] = values.length === 0 ? undefined : values.length === 1 ? values[0] : Object.freeze([...values]);
+        }
+        return Object.keys(decoded).length > 0 ? decoded : undefined;
+    }
+    async #respondLegacyQueryTask(response, entry) {
+        const queryResult = entry.result;
+        this.#log('debug', 'responding to legacy workflow query', {
+            namespace: this.#namespace,
+            workflowId: response.workflowExecution?.workflowId,
+            runId: response.workflowExecution?.runId,
+            queryName: entry.request.name,
+        });
+        const request = create(RespondQueryTaskCompletedRequestSchema, {
+            taskToken: response.taskToken ?? new Uint8Array(),
+            completedType: queryResult.resultType ?? QueryResultType.ANSWERED,
+            queryResult: queryResult.answer,
+            errorMessage: queryResult.errorMessage ?? '',
+            namespace: this.#namespace,
+            failure: queryResult.failure,
+            cause: WorkflowTaskFailedCause.UNSPECIFIED,
+        });
+        await this.#workflowService.respondQueryTaskCompleted(request, { timeoutMs: RESPOND_TIMEOUT_MS });
+    }
     async #fetchWorkflowHistoryPage(execution, nextPageToken) {
         if (!execution.workflowId || !execution.runId) {
             return { events: [], nextPageToken: new Uint8Array() };
@@ -931,11 +1149,13 @@ export class WorkerRuntime {
         };
     }
     async #computeNondeterminismMismatches(error, expectedState) {
-        const baseline = expectedState ?? {
-            commandHistory: [],
-            randomValues: [],
-            timeValues: [],
-            failureMetadata: undefined,
+        const baseline = {
+            commandHistory: expectedState?.commandHistory ?? [],
+            randomValues: expectedState?.randomValues ?? [],
+            timeValues: expectedState?.timeValues ?? [],
+            failureMetadata: expectedState?.failureMetadata,
+            signals: expectedState?.signals ?? [],
+            queries: expectedState?.queries ?? [],
         };
         const hint = error.details?.hint;
         if (!hint) {
@@ -944,6 +1164,8 @@ export class WorkerRuntime {
         const commandIndex = this.#parseIndexFromHint(hint, 'commandIndex');
         const randomIndex = this.#parseIndexFromHint(hint, 'randomIndex');
         const timeIndex = this.#parseIndexFromHint(hint, 'timeIndex');
+        const signalIndex = this.#parseIndexFromHint(hint, 'signalIndex');
+        const queryIndex = this.#parseIndexFromHint(hint, 'queryIndex');
         const mutableActual = {
             commandHistory: baseline.commandHistory.map((entry) => ({
                 intent: entry.intent,
@@ -952,6 +1174,8 @@ export class WorkerRuntime {
             randomValues: [...baseline.randomValues],
             timeValues: [...baseline.timeValues],
             failureMetadata: baseline.failureMetadata ? { ...baseline.failureMetadata } : undefined,
+            signals: baseline.signals.map((record) => ({ ...record })),
+            queries: baseline.queries.map((record) => ({ ...record })),
         };
         let mutated = false;
         if (commandIndex !== null) {
@@ -980,6 +1204,36 @@ export class WorkerRuntime {
             mutableActual.timeValues[timeIndex] = Number.NaN;
             mutated = true;
         }
+        if (signalIndex !== null) {
+            const receivedSignal = this.#asSignalRecord(error.details?.received);
+            if (receivedSignal) {
+                if (signalIndex < mutableActual.signals.length) {
+                    mutableActual.signals = mutableActual.signals.map((record, idx) => idx === signalIndex ? receivedSignal : record);
+                }
+                else {
+                    mutableActual.signals = [...mutableActual.signals, receivedSignal];
+                }
+            }
+            else if (signalIndex < mutableActual.signals.length) {
+                mutableActual.signals = mutableActual.signals.filter((_, idx) => idx !== signalIndex);
+            }
+            mutated = true;
+        }
+        if (queryIndex !== null) {
+            const receivedQuery = this.#asQueryRecord(error.details?.received);
+            if (receivedQuery) {
+                if (queryIndex < mutableActual.queries.length) {
+                    mutableActual.queries = mutableActual.queries.map((record, idx) => idx === queryIndex ? receivedQuery : record);
+                }
+                else {
+                    mutableActual.queries = [...mutableActual.queries, receivedQuery];
+                }
+            }
+            else if (queryIndex < mutableActual.queries.length) {
+                mutableActual.queries = mutableActual.queries.filter((_, idx) => idx !== queryIndex);
+            }
+            mutated = true;
+        }
         if (!mutated) {
             return [];
         }
@@ -988,6 +1242,8 @@ export class WorkerRuntime {
             randomValues: mutableActual.randomValues,
             timeValues: mutableActual.timeValues,
             failureMetadata: mutableActual.failureMetadata,
+            signals: mutableActual.signals,
+            queries: mutableActual.queries,
         };
         const diff = await Effect.runPromise(diffDeterminismState(baseline, actualState));
         return diff.mismatches;
@@ -1030,6 +1286,24 @@ export class WorkerRuntime {
             array.push(Number.NaN);
         }
     }
+    #asSignalRecord(value) {
+        if (!value || typeof value !== 'object') {
+            return undefined;
+        }
+        if ('signalName' in value && 'payloadHash' in value) {
+            return value;
+        }
+        return undefined;
+    }
+    #asQueryRecord(value) {
+        if (!value || typeof value !== 'object') {
+            return undefined;
+        }
+        if ('queryName' in value && 'requestHash' in value) {
+            return value;
+        }
+        return undefined;
+    }
     static #isStickyCacheInstance(value) {
         if (!value || typeof value !== 'object') {
             return false;