@proompteng/temporal-bun-sdk 0.3.0 → 0.5.0

package/dist/src/client.js

@@ -5,17 +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, 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 { WorkflowExecutionSchema, } from './proto/temporal/api/common/v1/message_pb';
 import { UpdateWorkflowExecutionLifecycleStage } from './proto/temporal/api/enums/v1/update_pb';
-import { DescribeNamespaceRequestSchema, DescribeNamespaceResponseSchema, } from './proto/temporal/api/workflowservice/v1/request_response_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, {
@@ -54,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;
@@ -132,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,
@@ -140,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?.();
@@ -154,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;
@@ -199,6 +262,7 @@ export const makeTemporalClientEffect = (options = {}) => Effect.gen(function* (
         logger,
         metrics: clientMetrics,
         metricsExporter,
+        clientInterceptors,
     });
     return { client, config };
 });
@@ -216,7 +280,9 @@ class TemporalClientImpl {
     #logger;
     #clientMetrics;
     #metricsExporter;
+    #clientInterceptors;
     #pendingUpdateControllers = new Map();
+    #abortedUpdates = new Set();
     closed = false;
     headers;
     static async initMetrics(registry) {
@@ -240,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),
@@ -259,12 +326,13 @@ class TemporalClientImpl {
             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: {
@@ -279,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;
@@ -306,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)) {
@@ -362,17 +495,17 @@ class TemporalClientImpl {
                 namespace: request.namespace,
                 firstExecutionRunId: response.started ? response.runId : undefined,
             });
-        });
+        }, { workflowId: startOptions.workflowId });
     }
     async updateWorkflow(handle, options, callOptions) {
-        return this.#instrumentOperation('updateWorkflow', async () => {
-            this.ensureOpen();
-            const resolvedHandle = resolveHandle(this.namespace, handle);
-            const parsedOptions = sanitizeWorkflowUpdateOptions(options);
-            const updateId = parsedOptions.updateId ?? createUpdateRequestId();
-            const waitStage = this.#stageToProto(parsedOptions.waitForStage);
+        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);
+            const { options: mergedCallOptions, controller, cleanup, } = this.#prepareUpdateCallOptions(updateKey, callOptions);
             try {
                 const request = await buildUpdateWorkflowRequest({
                     handle: resolvedHandle,
@@ -407,21 +540,21 @@ class TemporalClientImpl {
                 this.#releaseUpdateController(updateKey, controller);
                 cleanup?.();
             }
-        });
+        }, { workflowId: resolvedHandle.workflowId, runId: resolvedHandle.runId, updateId });
     }
     async awaitWorkflowUpdate(handle, options = {}, callOptions) {
-        return this.#instrumentOperation('awaitWorkflowUpdate', async () => {
-            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,
-            };
+        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,
@@ -430,7 +563,16 @@ class TemporalClientImpl {
                 waitStage,
             });
             const updateKey = this.#makeUpdateKey(resolvedHandle, updateId);
-            const { options: mergedCallOptions, controller, cleanup } = this.#prepareUpdateCallOptions(updateKey, callOptions);
+            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);
@@ -447,11 +589,16 @@ class TemporalClientImpl {
                     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);
@@ -463,7 +610,7 @@ class TemporalClientImpl {
         });
     }
     async cancelWorkflowUpdate(handle) {
-        return this.#instrumentOperation('cancelWorkflowUpdate', async () => {
+        return this.#instrumentOperation('workflow.update', async () => {
             this.ensureOpen();
             const resolvedHandle = resolveHandle(this.namespace, handle);
             const updateId = ensureNonEmptyString(handle.updateId, 'updateId');
@@ -475,17 +622,17 @@ class TemporalClientImpl {
                     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) {
@@ -523,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) {
@@ -587,6 +776,7 @@ class TemporalClientImpl {
         return { options: overrides, controller, cleanup };
     }
     #registerUpdateController(key, controller) {
+        this.#abortedUpdates.delete(key);
         const current = this.#pendingUpdateControllers.get(key);
         if (current) {
             current.add(controller);
@@ -607,12 +797,14 @@ class TemporalClientImpl {
     #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) {
@@ -689,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 };
@@ -701,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;