@proompteng/temporal-bun-sdk 0.2.0 → 0.4.0

package/dist/src/client.js

@@ -5,16 +5,19 @@ import { Context, Effect } from 'effect';
 import * as Option from 'effect/Option';
 import { createDefaultHeaders, mergeHeaders, normalizeMetadataHeaders } from './client/headers';
 import { makeDefaultInterceptorBuilder } from './client/interceptors';
-import { withTemporalRetry } from './client/retries';
-import { buildCancelRequest, buildQueryRequest, buildSignalRequest, buildSignalWithStartRequest, buildStartWorkflowRequest, buildTerminateRequest, computeSignalRequestId, createSignalRequestEntropy, decodeMemoAttributes, decodeSearchAttributes, encodeMemoAttributes, encodeSearchAttributes, } from './client/serialization';
+import { buildCancelRequest, buildPollWorkflowUpdateRequest, buildQueryRequest, buildSignalRequest, buildSignalWithStartRequest, buildStartWorkflowRequest, buildTerminateRequest, buildUpdateWorkflowRequest, computeSignalRequestId, createSignalRequestEntropy, createUpdateRequestId, decodeMemoAttributes, decodeSearchAttributes, decodeUpdateOutcome, encodeMemoAttributes, encodeSearchAttributes, } from './client/serialization';
 import { buildTransportOptions, normalizeTemporalAddress } from './client/transport';
 import { createWorkflowHandle, } from './client/types';
-import { createDefaultDataConverter, decodePayloadsToValues } from './common/payloads';
+import { buildCodecsFromConfig, createDefaultDataConverter, decodePayloadsToValues, } from './common/payloads';
 import { loadTemporalConfig } from './config';
+import { makeDefaultClientInterceptors, runClientInterceptors, } from './interceptors/client';
 import { createObservabilityServices } from './observability';
-import { DescribeNamespaceRequestSchema, DescribeNamespaceResponseSchema, } from './proto/temporal/api/workflowservice/v1/request_response_pb';
+import { WorkflowExecutionSchema, } from './proto/temporal/api/common/v1/message_pb';
+import { UpdateWorkflowExecutionLifecycleStage } from './proto/temporal/api/enums/v1/update_pb';
+import { HistoryEventFilterType } from './proto/temporal/api/enums/v1/workflow_pb';
+import { DescribeNamespaceRequestSchema, DescribeNamespaceResponseSchema, GetWorkflowExecutionHistoryRequestSchema, } from './proto/temporal/api/workflowservice/v1/request_response_pb';
 import { WorkflowService } from './proto/temporal/api/workflowservice/v1/service_pb';
-import { LoggerService, MetricsExporterService, MetricsService, TemporalConfigService, WorkflowServiceClientService, } from './runtime/effect-layers';
+import { DataConverterService, LoggerService, MetricsExporterService, MetricsService, TemporalConfigService, WorkflowServiceClientService, } from './runtime/effect-layers';
 export const temporalCallOptions = (options) => {
     const copy = { ...options };
     Object.defineProperty(copy, CALL_OPTIONS_MARKER, {
@@ -53,6 +56,38 @@ const describeError = (error) => {
 };
 const TLS_ERROR_CODE_PREFIXES = ['ERR_TLS_', 'ERR_SSL_'];
 const TLS_ERROR_MESSAGE_HINTS = [/handshake/i, /certificate/i, /secure tls/i, /ssl/i];
+const isAbortLikeError = (error) => (error instanceof Error && error.name === 'AbortError') ||
+    (error instanceof ConnectError && error.code === Code.Canceled);
+const normalizeUnknownError = (error) => {
+    const unwrap = (value) => {
+        if (!value || typeof value !== 'object') {
+            return value;
+        }
+        if (value instanceof TemporalTlsHandshakeError || value instanceof ConnectError) {
+            return value;
+        }
+        const candidate = value;
+        if (candidate.cause !== undefined) {
+            return unwrap(candidate.cause);
+        }
+        if (candidate.error !== undefined) {
+            return unwrap(candidate.error);
+        }
+        if (candidate._tag === 'UnknownException') {
+            return unwrap(candidate.cause ?? candidate.error ?? value);
+        }
+        const symbols = Object.getOwnPropertySymbols(value);
+        for (const symbol of symbols) {
+            const inner = value[symbol];
+            const unwrapped = unwrap(inner);
+            if (unwrapped !== inner) {
+                return unwrapped;
+            }
+        }
+        return value;
+    };
+    return unwrap(error);
+};
 const isCallOptionsCandidate = (value) => {
     if (!value || typeof value !== 'object') {
         return false;
@@ -131,6 +166,12 @@ export const createTemporalClient = async (options = {}) => {
     if (!workflowService) {
         throw new Error('Temporal workflow service is not available');
     }
+    const dataConverter = options.dataConverter ??
+        createDefaultDataConverter({
+            payloadCodecs: buildCodecsFromConfig(config.payloadCodecs),
+            logger,
+            metricsRegistry,
+        });
     const effect = makeTemporalClientEffect({
         ...options,
         config,
@@ -139,9 +180,10 @@ export const createTemporalClient = async (options = {}) => {
         metricsExporter,
         workflowService,
         transport,
+        dataConverter,
     });
     try {
-        return await Effect.runPromise(effect.pipe(Effect.provideService(TemporalConfigService, config), Effect.provideService(LoggerService, logger), Effect.provideService(MetricsService, metricsRegistry), Effect.provideService(MetricsExporterService, metricsExporter), Effect.provideService(WorkflowServiceClientService, workflowService)));
+        return await Effect.runPromise(effect.pipe(Effect.provideService(TemporalConfigService, config), Effect.provideService(LoggerService, logger), Effect.provideService(MetricsService, metricsRegistry), Effect.provideService(MetricsExporterService, metricsExporter), Effect.provideService(WorkflowServiceClientService, workflowService), Effect.provideService(DataConverterService, dataConverter)));
     }
     catch (error) {
         await createdTransport?.close?.();
@@ -153,11 +195,33 @@ export const makeTemporalClientEffect = (options = {}) => Effect.gen(function* (
     const namespace = options.namespace ?? config.namespace;
     const identity = options.identity ?? config.workerIdentity;
     const taskQueue = options.taskQueue ?? config.taskQueue;
-    const dataConverter = options.dataConverter ?? createDefaultDataConverter();
-    const initialHeaders = createDefaultHeaders(config.apiKey);
     const logger = options.logger ?? (yield* LoggerService);
     const metricsRegistry = options.metrics ?? (yield* MetricsService);
     const metricsExporter = options.metricsExporter ?? (yield* MetricsExporterService);
+    const contextualDataConverter = yield* Effect.contextWith((context) => Context.getOption(context, DataConverterService));
+    const dataConverter = options.dataConverter ??
+        Option.getOrUndefined(contextualDataConverter) ??
+        createDefaultDataConverter({
+            payloadCodecs: buildCodecsFromConfig(config.payloadCodecs),
+            logger,
+            metricsRegistry,
+        });
+    const initialHeaders = createDefaultHeaders(config.apiKey);
+    const tracingEnabled = options.tracingEnabled ?? config.tracingInterceptorsEnabled ?? false;
+    const clientInterceptorBuilder = options.clientInterceptorBuilder ?? {
+        build: (input) => makeDefaultClientInterceptors(input),
+    };
+    const defaultClientInterceptors = yield* clientInterceptorBuilder.build({
+        namespace,
+        taskQueue,
+        identity,
+        logger,
+        metricsRegistry,
+        metricsExporter,
+        retryPolicy: config.rpcRetryPolicy,
+        tracingEnabled,
+    });
+    const clientInterceptors = [...defaultClientInterceptors, ...(options.clientInterceptors ?? [])];
     const workflowServiceFromContext = yield* Effect.contextWith((context) => Context.getOption(context, WorkflowServiceClientService));
     let workflowService = options.workflowService ?? Option.getOrUndefined(workflowServiceFromContext);
     let transport = options.transport;
@@ -198,6 +262,7 @@ export const makeTemporalClientEffect = (options = {}) => Effect.gen(function* (
         logger,
         metrics: clientMetrics,
         metricsExporter,
+        clientInterceptors,
     });
     return { client, config };
 });
@@ -215,6 +280,9 @@ class TemporalClientImpl {
     #logger;
     #clientMetrics;
     #metricsExporter;
+    #clientInterceptors;
+    #pendingUpdateControllers = new Map();
+    #abortedUpdates = new Set();
     closed = false;
     headers;
     static async initMetrics(registry) {
@@ -238,6 +306,7 @@ class TemporalClientImpl {
         this.#logger = handles.logger;
         this.#clientMetrics = handles.metrics;
         this.#metricsExporter = handles.metricsExporter;
+        this.#clientInterceptors = handles.clientInterceptors;
         this.memo = {
             encode: (input) => encodeMemoAttributes(this.dataConverter, input),
             decode: (memo) => decodeMemoAttributes(this.dataConverter, memo),
@@ -253,12 +322,17 @@ class TemporalClientImpl {
             terminate: (handle, options, callOptions) => this.terminateWorkflow(handle, options, callOptions),
             cancel: (handle, callOptions) => this.cancelWorkflow(handle, callOptions),
             signalWithStart: (options, callOptions) => this.signalWithStart(options, callOptions),
+            update: (workflowHandle, updateOptions, callOptions) => this.updateWorkflow(workflowHandle, updateOptions, callOptions),
+            awaitUpdate: (updateHandle, options, callOptions) => this.awaitWorkflowUpdate(updateHandle, options, callOptions),
+            cancelUpdate: (updateHandle) => this.cancelWorkflowUpdate(updateHandle),
+            getUpdateHandle: (workflowHandle, updateId, firstExecutionRunId) => this.getWorkflowUpdateHandle(workflowHandle, updateId, firstExecutionRunId),
+            result: (handle, callOptions) => this.getWorkflowResult(handle, callOptions),
         };
     }
     async startWorkflow(options, callOptions) {
-        return this.#instrumentOperation('startWorkflow', async () => {
+        const parsedOptions = sanitizeStartWorkflowOptions(options);
+        return this.#instrumentOperation('workflow.start', async () => {
             this.ensureOpen();
-            const parsedOptions = sanitizeStartWorkflowOptions(options);
             const request = await buildStartWorkflowRequest({
                 options: parsedOptions,
                 defaults: {
@@ -273,12 +347,15 @@ class TemporalClientImpl {
                 namespace: request.namespace,
                 firstExecutionRunId: response.started ? response.runId : undefined,
             });
+        }, {
+            workflowId: parsedOptions.workflowId,
+            taskQueue: options.taskQueue ?? this.defaultTaskQueue,
         });
     }
     async signalWorkflow(handle, signalName, ...rawArgs) {
-        return this.#instrumentOperation('signalWorkflow', async () => {
+        const resolvedHandle = resolveHandle(this.namespace, handle);
+        return this.#instrumentOperation('workflow.signal', async () => {
             this.ensureOpen();
-            const resolvedHandle = resolveHandle(this.namespace, handle);
             const normalizedSignalName = ensureNonEmptyString(signalName, 'signalName');
             const { values, callOptions } = this.#splitArgsAndOptions(rawArgs);
             const identity = this.defaultIdentity;
@@ -300,39 +377,101 @@ class TemporalClientImpl {
                 requestId,
             }, this.dataConverter);
             await this.executeRpc('signalWorkflow', (rpcOptions) => this.workflowService.signalWorkflowExecution(request, rpcOptions), callOptions);
-        });
+        }, { workflowId: resolvedHandle.workflowId, runId: resolvedHandle.runId, taskQueue: this.defaultTaskQueue });
     }
     async queryWorkflow(handle, queryName, ...rawArgs) {
-        return this.#instrumentOperation('queryWorkflow', async () => {
+        const resolvedHandle = resolveHandle(this.namespace, handle);
+        return this.#instrumentOperation('workflow.query', async () => {
             this.ensureOpen();
-            const resolvedHandle = resolveHandle(this.namespace, handle);
             const { values, callOptions } = this.#splitArgsAndOptions(rawArgs);
-            const request = await buildQueryRequest(resolvedHandle, queryName, values, this.dataConverter);
+            const request = await buildQueryRequest(resolvedHandle, queryName, values, this.dataConverter, {
+                rejectCondition: callOptions?.queryRejectCondition,
+            });
             const response = await this.executeRpc('queryWorkflow', (rpcOptions) => this.workflowService.queryWorkflow(request, rpcOptions), callOptions);
             return this.parseQueryResult(response);
-        });
+        }, { workflowId: resolvedHandle.workflowId, runId: resolvedHandle.runId });
     }
     async terminateWorkflow(handle, options = {}, callOptions) {
-        return this.#instrumentOperation('terminateWorkflow', async () => {
+        return this.#instrumentOperation('workflow.terminate', async () => {
             this.ensureOpen();
             const resolvedHandle = resolveHandle(this.namespace, handle);
             const parsedOptions = sanitizeTerminateWorkflowOptions(options);
             const request = await buildTerminateRequest(resolvedHandle, parsedOptions, this.dataConverter, this.defaultIdentity);
             await this.executeRpc('terminateWorkflow', (rpcOptions) => this.workflowService.terminateWorkflowExecution(request, rpcOptions), callOptions);
-        });
+        }, { workflowId: handle.workflowId, runId: handle.runId });
     }
     async cancelWorkflow(handle, callOptions) {
-        return this.#instrumentOperation('cancelWorkflow', async () => {
+        const resolvedHandle = resolveHandle(this.namespace, handle);
+        return this.#instrumentOperation('workflow.cancel', async () => {
             this.ensureOpen();
-            const resolvedHandle = resolveHandle(this.namespace, handle);
             const request = buildCancelRequest(resolvedHandle, this.defaultIdentity);
             await this.executeRpc('cancelWorkflow', (rpcOptions) => this.workflowService.requestCancelWorkflowExecution(request, rpcOptions), callOptions);
-        });
+        }, { workflowId: resolvedHandle.workflowId, runId: resolvedHandle.runId });
+    }
+    async getWorkflowResult(handle, callOptions) {
+        let resolvedHandle = resolveHandle(this.namespace, handle);
+        return this.#instrumentOperation('workflow.result', async () => {
+            this.ensureOpen();
+            while (true) {
+                const execution = create(WorkflowExecutionSchema, {
+                    workflowId: resolvedHandle.workflowId,
+                    ...(resolvedHandle.runId ? { runId: resolvedHandle.runId } : {}),
+                });
+                const request = create(GetWorkflowExecutionHistoryRequestSchema, {
+                    namespace: resolvedHandle.namespace ?? this.namespace,
+                    execution,
+                    maximumPageSize: 1,
+                    historyEventFilterType: HistoryEventFilterType.CLOSE_EVENT,
+                    waitNewEvent: true,
+                    skipArchival: true,
+                });
+                const response = await this.executeRpc('getWorkflowExecutionHistory', (rpcOptions) => this.workflowService.getWorkflowExecutionHistory(request, rpcOptions), callOptions);
+                const closeEvent = this.#extractCloseEvent(response);
+                if (!closeEvent || !closeEvent.attributes) {
+                    throw new Error('Workflow close event not found');
+                }
+                const attributes = closeEvent.attributes;
+                switch (attributes.case) {
+                    case 'workflowExecutionContinuedAsNewEventAttributes': {
+                        const nextRunId = attributes.value.newExecutionRunId;
+                        if (!nextRunId) {
+                            throw new Error('Continue-as-new event missing newExecutionRunId');
+                        }
+                        resolvedHandle = { ...resolvedHandle, runId: nextRunId };
+                        continue;
+                    }
+                    case 'workflowExecutionCompletedEventAttributes': {
+                        const payloads = attributes.value.result?.payloads ?? [];
+                        const decoded = await this.dataConverter.fromPayloads(payloads);
+                        return (decoded.length <= 1 ? decoded[0] : decoded) ?? undefined;
+                    }
+                    case 'workflowExecutionFailedEventAttributes': {
+                        const failure = await this.dataConverter.decodeFailurePayloads(attributes.value.failure);
+                        const error = await this.dataConverter.failureToError(failure);
+                        throw error ?? new Error('Workflow failed');
+                    }
+                    case 'workflowExecutionTimedOutEventAttributes':
+                        throw new Error('Workflow timed out');
+                    case 'workflowExecutionCanceledEventAttributes': {
+                        const details = attributes.value.details?.payloads ?? [];
+                        const decoded = await this.dataConverter.fromPayloads(details);
+                        const detail = decoded.length <= 1 ? decoded[0] : decoded;
+                        throw new Error(detail ? `Workflow canceled: ${JSON.stringify(detail)}` : 'Workflow canceled without details');
+                    }
+                    case 'workflowExecutionTerminatedEventAttributes': {
+                        const reason = attributes.value.reason;
+                        throw new Error(reason ? `Workflow terminated: ${reason}` : 'Workflow terminated');
+                    }
+                    default:
+                        throw new Error(`Unsupported workflow close event type: ${attributes.case}`);
+                }
+            }
+        }, { workflowId: resolvedHandle.workflowId, runId: resolvedHandle.runId });
     }
     async signalWithStart(options, callOptions) {
-        return this.#instrumentOperation('signalWithStart', async () => {
+        const startOptions = sanitizeStartWorkflowOptions(options);
+        return this.#instrumentOperation('workflow.signalWithStart', async () => {
             this.ensureOpen();
-            const startOptions = sanitizeStartWorkflowOptions(options);
             const signalName = ensureNonEmptyString(options.signalName, 'signalName');
             const signalArgs = options.signalArgs ?? [];
             if (!Array.isArray(signalArgs)) {
@@ -356,17 +495,144 @@ class TemporalClientImpl {
                 namespace: request.namespace,
                 firstExecutionRunId: response.started ? response.runId : undefined,
             });
+        }, { workflowId: startOptions.workflowId });
+    }
+    async updateWorkflow(handle, options, callOptions) {
+        this.ensureOpen();
+        const resolvedHandle = resolveHandle(this.namespace, handle);
+        const parsedOptions = sanitizeWorkflowUpdateOptions(options);
+        const updateId = parsedOptions.updateId ?? createUpdateRequestId();
+        const waitStage = this.#stageToProto(parsedOptions.waitForStage);
+        return this.#instrumentOperation('workflow.update', async () => {
+            const updateKey = this.#makeUpdateKey(resolvedHandle, updateId);
+            const { options: mergedCallOptions, controller, cleanup, } = this.#prepareUpdateCallOptions(updateKey, callOptions);
+            try {
+                const request = await buildUpdateWorkflowRequest({
+                    handle: resolvedHandle,
+                    namespace: this.namespace,
+                    identity: this.defaultIdentity,
+                    updateId,
+                    updateName: parsedOptions.updateName,
+                    args: parsedOptions.args,
+                    headers: parsedOptions.headers,
+                    waitStage,
+                    firstExecutionRunId: parsedOptions.firstExecutionRunId,
+                }, this.dataConverter);
+                let response = await this.executeRpc('updateWorkflowExecution', (rpcOptions) => this.workflowService.updateWorkflowExecution(request, rpcOptions), mergedCallOptions);
+                while ((response.stage ?? UpdateWorkflowExecutionLifecycleStage.UNSPECIFIED) < waitStage) {
+                    response = await this.executeRpc('updateWorkflowExecution', (rpcOptions) => this.workflowService.updateWorkflowExecution(request, rpcOptions), mergedCallOptions);
+                }
+                const runId = response.updateRef?.workflowExecution?.runId || resolvedHandle.runId;
+                const updateHandle = this.#createWorkflowUpdateHandle(resolvedHandle, {
+                    updateId,
+                    runId,
+                    firstExecutionRunId: parsedOptions.firstExecutionRunId,
+                });
+                const stage = this.#stageFromProto(response.stage);
+                const outcome = await decodeUpdateOutcome(this.dataConverter, response.outcome);
+                return {
+                    handle: updateHandle,
+                    stage,
+                    outcome,
+                };
+            }
+            finally {
+                this.#releaseUpdateController(updateKey, controller);
+                cleanup?.();
+            }
+        }, { workflowId: resolvedHandle.workflowId, runId: resolvedHandle.runId, updateId });
+    }
+    async awaitWorkflowUpdate(handle, options = {}, callOptions) {
+        this.ensureOpen();
+        const resolvedHandle = resolveHandle(this.namespace, handle);
+        const updateId = ensureNonEmptyString(handle.updateId, 'updateId');
+        const waitStage = this.#stageToProto(options.waitForStage ?? 'completed');
+        const firstExecutionRunIdOverride = ensureOptionalTrimmedString(options.firstExecutionRunId, 'firstExecutionRunId', 1);
+        const pollHandle = {
+            workflowId: resolvedHandle.workflowId,
+            namespace: resolvedHandle.namespace,
+            runId: resolvedHandle.runId,
+            firstExecutionRunId: firstExecutionRunIdOverride ?? resolvedHandle.firstExecutionRunId,
+        };
+        return this.#instrumentOperation('workflow.awaitUpdate', async () => {
+            const request = buildPollWorkflowUpdateRequest({
+                handle: pollHandle,
+                namespace: this.namespace,
+                identity: this.defaultIdentity,
+                updateId,
+                waitStage,
+            });
+            const updateKey = this.#makeUpdateKey(resolvedHandle, updateId);
+            const { options: mergedCallOptions, controller, cleanup, } = this.#prepareUpdateCallOptions(updateKey, callOptions);
+            const throwIfAborted = () => {
+                if (controller.signal.aborted || this.#abortedUpdates.has(updateKey)) {
+                    this.#abortedUpdates.delete(updateKey);
+                    const abortError = new Error('Workflow update polling aborted');
+                    abortError.name = 'AbortError';
+                    throw abortError;
+                }
+            };
+            throwIfAborted();
+            try {
+                const response = await this.executeRpc('pollWorkflowExecutionUpdate', (rpcOptions) => this.workflowService.pollWorkflowExecutionUpdate(request, rpcOptions), mergedCallOptions);
+                const stage = this.#stageFromProto(response.stage);
+                const runId = response.updateRef?.workflowExecution?.runId || resolvedHandle.runId;
+                const updateHandle = this.#createWorkflowUpdateHandle(resolvedHandle, {
+                    updateId,
+                    runId,
+                    firstExecutionRunId: pollHandle.firstExecutionRunId,
+                });
+                const outcome = await decodeUpdateOutcome(this.dataConverter, response.outcome);
+                return {
+                    handle: updateHandle,
+                    stage,
+                    outcome,
+                };
+            }
+            catch (error) {
+                throwIfAborted();
+                throw error;
+            }
+            finally {
+                this.#abortedUpdates.delete(updateKey);
+                this.#releaseUpdateController(updateKey, controller);
+                cleanup?.();
+            }
+        }, { workflowId: resolvedHandle.workflowId, runId: resolvedHandle.runId, updateId });
+    }
+    getWorkflowUpdateHandle(handle, updateId, firstExecutionRunId) {
+        const resolvedHandle = resolveHandle(this.namespace, handle);
+        const normalizedUpdateId = ensureNonEmptyString(updateId, 'updateId');
+        const normalizedFirstExecution = ensureOptionalTrimmedString(firstExecutionRunId, 'firstExecutionRunId', 1);
+        return this.#createWorkflowUpdateHandle(resolvedHandle, {
+            updateId: normalizedUpdateId,
+            firstExecutionRunId: normalizedFirstExecution,
         });
     }
+    async cancelWorkflowUpdate(handle) {
+        return this.#instrumentOperation('workflow.update', async () => {
+            this.ensureOpen();
+            const resolvedHandle = resolveHandle(this.namespace, handle);
+            const updateId = ensureNonEmptyString(handle.updateId, 'updateId');
+            const updateKey = this.#makeUpdateKey(resolvedHandle, updateId);
+            const aborted = this.#abortUpdateControllers(updateKey);
+            if (!aborted) {
+                this.#log('debug', 'no pending workflow update operation to cancel', {
+                    workflowId: resolvedHandle.workflowId,
+                    updateId,
+                });
+            }
+        }, { workflowId: handle.workflowId, runId: handle.runId, updateId: handle.updateId });
+    }
     async describeNamespace(targetNamespace, callOptions) {
-        return this.#instrumentOperation('describeNamespace', async () => {
+        return this.#instrumentOperation('workflow.describe', async () => {
             this.ensureOpen();
             const request = create(DescribeNamespaceRequestSchema, {
                 namespace: targetNamespace ?? this.namespace,
             });
             const response = await this.executeRpc('describeNamespace', (rpcOptions) => this.workflowService.describeNamespace(request, rpcOptions), callOptions);
             return toBinary(DescribeNamespaceResponseSchema, response);
-        });
+        }, { namespace: targetNamespace ?? this.namespace });
     }
     async updateHeaders(headers) {
         if (this.closed) {
@@ -404,24 +670,66 @@ class TemporalClientImpl {
             void Effect.runPromise(this.#clientMetrics.operationErrors.inc());
         }
     }
-    async #instrumentOperation(operation, action) {
+    async #instrumentOperation(operation, action, metadata = {}) {
+        const context = {
+            kind: operation,
+            namespace: this.namespace,
+            taskQueue: metadata.taskQueue ?? this.defaultTaskQueue,
+            identity: this.defaultIdentity,
+            workflowId: metadata.workflowId,
+            runId: metadata.runId,
+            updateId: metadata.updateId,
+            metadata,
+        };
         const start = Date.now();
+        const effect = runClientInterceptors(this.#clientInterceptors, context, () => Effect.tryPromise(action));
         try {
-            const result = await action();
+            const result = await Effect.runPromise(effect);
             this.#log('debug', `temporal client ${operation} succeeded`, {
                 operation,
                 namespace: this.namespace,
+                ...metadata,
             });
             this.#recordMetrics(Date.now() - start, false);
             return result;
         }
         catch (error) {
+            const normalized = normalizeUnknownError(error);
+            const finalError = normalized instanceof Error &&
+                normalized.message.toLowerCase().includes('unknown error occurred in effect.trypromise')
+                ? (normalized.cause ??
+                    normalized.error ??
+                    normalized)
+                : normalized;
+            const message = finalError instanceof Error ? finalError.message.toLowerCase() : '';
+            const isUnknownPollAbort = operation === 'workflow.awaitUpdate' && message.includes('unknown error occurred in effect.trypromise');
+            if (isAbortLikeError(normalized)) {
+                this.#log('warn', `temporal client ${operation} aborted`, {
+                    operation,
+                    error: describeError(normalized),
+                    ...metadata,
+                });
+                this.#recordMetrics(Date.now() - start, true);
+                throw finalError;
+            }
+            if (isUnknownPollAbort) {
+                const abortError = new Error('Workflow update polling aborted');
+                abortError.name = 'AbortError';
+                this.#log('warn', `temporal client ${operation} aborted`, {
+                    operation,
+                    error: describeError(abortError),
+                    ...metadata,
+                });
+                this.#recordMetrics(Date.now() - start, true);
+                throw abortError;
+            }
             this.#log('error', `temporal client ${operation} failed`, {
                 operation,
-                error: describeError(error),
+                error: describeError(finalError),
+                ...metadata,
             });
             this.#recordMetrics(Date.now() - start, true);
-            throw error;
+            throw finalError;
         }
     }
     #log(level, message, fields) {
@@ -447,6 +755,89 @@ class TemporalClientImpl {
         }
         return { values: args };
     }
+    #prepareUpdateCallOptions(key, callOptions) {
+        const controller = new AbortController();
+        let cleanup;
+        if (callOptions?.signal) {
+            if (callOptions.signal.aborted) {
+                controller.abort();
+            }
+            else {
+                const onAbort = () => controller.abort();
+                callOptions.signal.addEventListener('abort', onAbort, { once: true });
+                cleanup = () => callOptions.signal?.removeEventListener('abort', onAbort);
+            }
+        }
+        this.#registerUpdateController(key, controller);
+        const overrides = {
+            ...(callOptions ? { ...callOptions } : {}),
+            signal: controller.signal,
+        };
+        return { options: overrides, controller, cleanup };
+    }
+    #registerUpdateController(key, controller) {
+        this.#abortedUpdates.delete(key);
+        const current = this.#pendingUpdateControllers.get(key);
+        if (current) {
+            current.add(controller);
+            return;
+        }
+        this.#pendingUpdateControllers.set(key, new Set([controller]));
+    }
+    #releaseUpdateController(key, controller) {
+        const current = this.#pendingUpdateControllers.get(key);
+        if (!current) {
+            return;
+        }
+        current.delete(controller);
+        if (current.size === 0) {
+            this.#pendingUpdateControllers.delete(key);
+        }
+    }
+    #abortUpdateControllers(key) {
+        const current = this.#pendingUpdateControllers.get(key);
+        if (!current || current.size === 0) {
+            this.#abortedUpdates.add(key);
+            return false;
+        }
+        for (const controller of current) {
+            controller.abort();
+        }
+        this.#pendingUpdateControllers.delete(key);
+        this.#abortedUpdates.add(key);
+        return true;
+    }
+    #makeUpdateKey(handle, updateId) {
+        const namespace = handle.namespace ?? this.namespace;
+        const runId = handle.runId ?? '';
+        return `${namespace}::${handle.workflowId}::${runId}::${updateId}`;
+    }
+    #createWorkflowUpdateHandle(handle, overrides) {
+        return {
+            workflowId: handle.workflowId,
+            namespace: handle.namespace,
+            runId: overrides.runId ?? handle.runId,
+            firstExecutionRunId: overrides.firstExecutionRunId ?? handle.firstExecutionRunId,
+            updateId: overrides.updateId,
+        };
+    }
+    #stageToProto(stage, minimum = UpdateWorkflowExecutionLifecycleStage.ADMITTED) {
+        const normalized = ensureWorkflowUpdateStage(stage);
+        const protoStage = WORKFLOW_UPDATE_STAGE_TO_PROTO[normalized];
+        return protoStage >= minimum ? protoStage : minimum;
+    }
+    #stageFromProto(stage) {
+        if (stage === UpdateWorkflowExecutionLifecycleStage.ADMITTED) {
+            return 'admitted';
+        }
+        if (stage === UpdateWorkflowExecutionLifecycleStage.ACCEPTED) {
+            return 'accepted';
+        }
+        if (stage === UpdateWorkflowExecutionLifecycleStage.COMPLETED) {
+            return 'completed';
+        }
+        return 'unspecified';
+    }
     #mergeRetryPolicy(overrides) {
         const base = this.config.rpcRetryPolicy;
         if (!overrides) {
@@ -490,6 +881,13 @@ class TemporalClientImpl {
             retryableStatusCodes,
         };
     }
+    #extractCloseEvent(response) {
+        const events = response?.history?.events ?? [];
+        if (events.length === 0) {
+            return undefined;
+        }
+        return events[events.length - 1];
+    }
     #buildCallContext(overrides) {
         const userHeaders = overrides?.headers ? normalizeMetadataHeaders(overrides.headers) : undefined;
         const mergedHeaders = userHeaders ? mergeHeaders(this.headers, userHeaders) : { ...this.headers };
@@ -502,29 +900,37 @@ class TemporalClientImpl {
                 signal,
             }),
             retryPolicy: this.#mergeRetryPolicy(overrides?.retryPolicy),
+            headers: mergedHeaders,
         };
     }
     async executeRpc(operation, rpc, overrides) {
-        const { create, retryPolicy } = this.#buildCallContext(overrides);
-        let attempt = 0;
-        const effect = Effect.tryPromise({
+        const { create, retryPolicy, headers } = this.#buildCallContext(overrides);
+        const interceptorContext = {
+            kind: 'rpc',
+            namespace: this.namespace,
+            taskQueue: this.defaultTaskQueue,
+            identity: this.defaultIdentity,
+            headers,
+            metadata: { retryPolicy },
+        };
+        const baseEffect = () => Effect.tryPromise({
             try: () => {
-                attempt += 1;
+                interceptorContext.attempt = (interceptorContext.attempt ?? 0) + 1;
                 return rpc(create());
             },
             catch: (error) => wrapRpcError(error),
         }).pipe(Effect.tapError((error) => Effect.sync(() => {
             this.#log('warn', `temporal rpc ${operation} attempt failed`, {
                 operation,
-                attempt,
+                attempt: interceptorContext.attempt,
                 error: describeError(error),
             });
         })));
-        const result = await Effect.runPromise(withTemporalRetry(effect, retryPolicy));
-        if (attempt > 1) {
-            this.#log('info', `temporal rpc ${operation} succeeded after ${attempt} attempts`, {
+        const result = await Effect.runPromise(runClientInterceptors(this.#clientInterceptors, interceptorContext, baseEffect));
+        if ((interceptorContext.attempt ?? 1) > 1) {
+            this.#log('info', `temporal rpc ${operation} succeeded after ${interceptorContext.attempt} attempts`, {
                 operation,
-                attempts: attempt,
+                attempts: interceptorContext.attempt,
             });
         }
         return result;
@@ -650,6 +1056,49 @@ const sanitizeTerminateWorkflowOptions = (options = {}) => {
         firstExecutionRunId: ensureOptionalTrimmedString(options.firstExecutionRunId, 'firstExecutionRunId', 1),
     };
 };
+const sanitizeWorkflowUpdateOptions = (options) => {
+    if (!options || typeof options !== 'object') {
+        throw new Error('Workflow update options must be provided');
+    }
+    const updateName = ensureNonEmptyString(options.updateName, 'updateName');
+    const args = options.args ?? [];
+    if (!Array.isArray(args)) {
+        throw new Error('update args must be an array when provided');
+    }
+    const waitForStage = ensureWorkflowUpdateStage(options.waitForStage);
+    const updateId = ensureOptionalTrimmedString(options.updateId, 'updateId', 1);
+    const firstExecutionRunId = ensureOptionalTrimmedString(options.firstExecutionRunId, 'firstExecutionRunId', 1);
+    return {
+        updateName,
+        args,
+        headers: options.headers,
+        updateId,
+        waitForStage,
+        firstExecutionRunId,
+    };
+};
+const WORKFLOW_UPDATE_STAGE_VALUES = new Set([
+    'unspecified',
+    'admitted',
+    'accepted',
+    'completed',
+]);
+const DEFAULT_WORKFLOW_UPDATE_STAGE = 'accepted';
+const WORKFLOW_UPDATE_STAGE_TO_PROTO = {
+    unspecified: UpdateWorkflowExecutionLifecycleStage.UNSPECIFIED,
+    admitted: UpdateWorkflowExecutionLifecycleStage.ADMITTED,
+    accepted: UpdateWorkflowExecutionLifecycleStage.ACCEPTED,
+    completed: UpdateWorkflowExecutionLifecycleStage.COMPLETED,
+};
+const ensureWorkflowUpdateStage = (stage) => {
+    if (!stage) {
+        return DEFAULT_WORKFLOW_UPDATE_STAGE;
+    }
+    if (!WORKFLOW_UPDATE_STAGE_VALUES.has(stage)) {
+        throw new Error('waitForStage must be one of unspecified, admitted, accepted, or completed');
+    }
+    return stage;
+};
 const resolveHandle = (defaultNamespace, handle) => {
     const workflowId = ensureNonEmptyString(handle.workflowId, 'workflowId');
     const namespace = ensureOptionalTrimmedString(handle.namespace, 'namespace', 1) ?? defaultNamespace;