@temporalio/client 1.7.4 → 1.8.1

package/src/schedule-types.ts

@@ -1,5 +1,5 @@
 import { checkExtends, Replace } from '@temporalio/common/lib/type-helpers';
-import { SearchAttributes, Workflow } from '@temporalio/common';
+import { Duration, SearchAttributes, Workflow } from '@temporalio/common';
 import type { temporal } from '@temporalio/proto';
 import { WorkflowStartOptions } from './workflow-options';
 
@@ -46,7 +46,7 @@ export interface ScheduleOptions<A extends ScheduleOptionsAction = ScheduleOptio
      * @default 1 minute
      * @format number of milliseconds or {@link https://www.npmjs.com/package/ms | ms-formatted string}
      */
-    catchupWindow?: number | string;
+    catchupWindow?: Duration;
 
     /**
      * When an Action times out or reaches the end of its Retry Policy, {@link pause}.
@@ -465,7 +465,7 @@ export interface ScheduleSpec {
    * @default 0
    * @format number of milliseconds or {@link https://www.npmjs.com/package/ms | ms-formatted string}
    */
-  jitter?: number | string;
+  jitter?: Duration;
 
   /**
    * IANA timezone name, for example `US/Pacific`.
@@ -659,7 +659,7 @@ export interface IntervalSpec {
    *
    * @format number of milliseconds or {@link https://www.npmjs.com/package/ms | ms-formatted string}
    */
-  every: number | string;
+  every: Duration;
 
   /**
    * Value is rounded to the nearest second.
@@ -667,7 +667,7 @@ export interface IntervalSpec {
    * @default 0
    * @format number of milliseconds or {@link https://www.npmjs.com/package/ms | ms-formatted string}
    */
-  offset?: number | string;
+  offset?: Duration;
 }
 
 /**

package/src/task-queue-client.ts

@@ -0,0 +1,297 @@
+import { status } from '@grpc/grpc-js';
+import { filterNullAndUndefined } from '@temporalio/common/lib/internal-non-workflow';
+import { assertNever, RequireAtLeastOne } from '@temporalio/common/lib/type-helpers';
+import { temporal } from '@temporalio/proto';
+import { BaseClient, BaseClientOptions, defaultBaseClientOptions, LoadedWithDefaults } from './base-client';
+import { WorkflowService } from './types';
+import { BuildIdOperation, versionSetsFromProto, WorkerBuildIdVersionSets } from './build-id-types';
+import { isGrpcServiceError, ServiceError } from './errors';
+import { rethrowKnownErrorTypes } from './helpers';
+
+type IUpdateWorkerBuildIdCompatibilityRequest =
+  temporal.api.workflowservice.v1.IUpdateWorkerBuildIdCompatibilityRequest;
+type GetWorkerTaskReachabilityResponse = temporal.api.workflowservice.v1.GetWorkerTaskReachabilityResponse;
+
+/**
+ * @experimental
+ */
+export type TaskQueueClientOptions = BaseClientOptions;
+
+/**
+ * @experimental
+ */
+export type LoadedTaskQueueClientOptions = LoadedWithDefaults<TaskQueueClientOptions>;
+
+/**
+ * A stand-in for a Build Id for unversioned Workers
+ * @experimental
+ */
+export const UnversionedBuildId = Symbol.for('__temporal_unversionedBuildId');
+export type UnversionedBuildIdType = typeof UnversionedBuildId;
+
+/**
+ * Client for starting Workflow executions and creating Workflow handles
+ *
+ * @experimental
+ */
+export class TaskQueueClient extends BaseClient {
+  public readonly options: LoadedTaskQueueClientOptions;
+
+  constructor(options?: TaskQueueClientOptions) {
+    super(options);
+    this.options = {
+      ...defaultBaseClientOptions(),
+      ...filterNullAndUndefined(options ?? {}),
+      loadedDataConverter: this.dataConverter,
+    };
+  }
+
+  /**
+   * Raw gRPC access to the Temporal service.
+   *
+   * **NOTE**: The namespace provided in {@link options} is **not** automatically set on requests
+   * using this service attribute.
+   */
+  get workflowService(): WorkflowService {
+    return this.connection.workflowService;
+  }
+
+  /**
+   * Used to add new Build Ids or otherwise update the relative compatibility of Build Ids as
+   * defined on a specific task queue for the Worker Versioning feature. For more on this feature,
+   * see https://docs.temporal.io/workers#worker-versioning
+   *
+   * @param taskQueue The task queue to make changes to.
+   * @param operation The operation to be performed.
+   */
+  public async updateBuildIdCompatibility(taskQueue: string, operation: BuildIdOperation): Promise<void> {
+    const request: IUpdateWorkerBuildIdCompatibilityRequest = {
+      namespace: this.options.namespace,
+      taskQueue,
+    };
+    switch (operation.operation) {
+      case 'addNewIdInNewDefaultSet':
+        request.addNewBuildIdInNewDefaultSet = operation.buildId;
+        break;
+      case 'addNewCompatibleVersion':
+        request.addNewCompatibleBuildId = {
+          newBuildId: operation.buildId,
+          existingCompatibleBuildId: operation.existingCompatibleBuildId,
+        };
+        break;
+      case 'promoteSetByBuildId':
+        request.promoteSetByBuildId = operation.buildId;
+        break;
+      case 'promoteBuildIdWithinSet':
+        request.promoteBuildIdWithinSet = operation.buildId;
+        break;
+      case 'mergeSets':
+        request.mergeSets = {
+          primarySetBuildId: operation.primaryBuildId,
+          secondarySetBuildId: operation.secondaryBuildId,
+        };
+        break;
+      default:
+        assertNever('Unknown build id update operation', operation);
+    }
+    try {
+      await this.workflowService.updateWorkerBuildIdCompatibility(request);
+    } catch (e) {
+      this.rethrowGrpcError(e, 'Unexpected error updating Build Id compatibility');
+    }
+  }
+
+  /**
+   * Fetch the sets of compatible Build Ids for a given task queue.
+   *
+   * @param taskQueue The task queue to fetch the compatibility information for.
+   * @returns The sets of compatible Build Ids for the given task queue, or undefined if the queue
+   *          has no Build Ids defined on it.
+   */
+  public async getBuildIdCompatability(taskQueue: string): Promise<WorkerBuildIdVersionSets | undefined> {
+    let resp;
+    try {
+      resp = await this.workflowService.getWorkerBuildIdCompatibility({
+        taskQueue,
+        namespace: this.options.namespace,
+      });
+    } catch (e) {
+      this.rethrowGrpcError(e, 'Unexpected error fetching Build Id compatibility');
+    }
+    if (resp.majorVersionSets == null || resp.majorVersionSets.length === 0) {
+      return undefined;
+    }
+    return versionSetsFromProto(resp);
+  }
+
+  /**
+   * Fetches task reachability to determine whether a worker may be retired. The request may specify
+   * task queues to query for or let the server fetch all task queues mapped to the given build IDs.
+   *
+   * When requesting a large number of task queues or all task queues associated with the given
+   * build ids in a namespace, all task queues will be listed in the response but some of them may
+   * not contain reachability information due to a server enforced limit. When reaching the limit,
+   * task queues that reachability information could not be retrieved for will be marked with a
+   * `NotFetched` entry in {@link BuildIdReachability.taskQueueReachability}. The caller may issue
+   * another call to get the reachability for those task queues.
+   */
+  public async getReachability(options: ReachabilityOptions): Promise<ReachabilityResponse> {
+    let resp;
+    const buildIds = options.buildIds?.map((bid) => {
+      if (bid === UnversionedBuildId) {
+        return '';
+      }
+      return bid;
+    });
+    try {
+      resp = await this.workflowService.getWorkerTaskReachability({
+        namespace: this.options.namespace,
+        taskQueues: options.taskQueues,
+        buildIds,
+        reachability: reachabilityTypeToProto(options.reachability),
+      });
+    } catch (e) {
+      this.rethrowGrpcError(e, 'Unexpected error fetching Build Id reachability');
+    }
+    return reachabilityResponseFromProto(resp);
+  }
+
+  protected rethrowGrpcError(err: unknown, fallbackMessage: string): never {
+    if (isGrpcServiceError(err)) {
+      rethrowKnownErrorTypes(err);
+      if (err.code === status.NOT_FOUND) {
+        throw new BuildIdNotFoundError(err.details ?? 'Build Id not found');
+      }
+      throw new ServiceError(fallbackMessage, { cause: err });
+    }
+    throw new ServiceError('Unexpected error while making gRPC request');
+  }
+}
+
+/**
+ * Options for {@link TaskQueueClient.getReachability}
+ */
+export type ReachabilityOptions = RequireAtLeastOne<BaseReachabilityOptions, 'buildIds' | 'taskQueues'>;
+
+/**
+ * There are different types of reachability:
+ *   - `NEW_WORKFLOWS`: The Build Id might be used by new workflows
+ *   - `EXISTING_WORKFLOWS` The Build Id might be used by open workflows and/or closed workflows.
+ *   - `OPEN_WORKFLOWS` The Build Id might be used by open workflows
+ *   - `CLOSED_WORKFLOWS` The Build Id might be used by closed workflows
+ */
+export type ReachabilityType = 'NEW_WORKFLOWS' | 'EXISTING_WORKFLOWS' | 'OPEN_WORKFLOWS' | 'CLOSED_WORKFLOWS';
+
+/**
+ * See {@link ReachabilityOptions}
+ */
+export interface BaseReachabilityOptions {
+  /**
+   * A list of build ids to query the reachability of. Currently, at least one Build Id must be
+   * specified, but this restriction may be lifted in the future.
+   */
+  buildIds: (string | UnversionedBuildIdType)[];
+  /**
+   * A list of task queues with Build Ids defined on them that the request is
+   * concerned with.
+   */
+  taskQueues?: string[];
+  /** The kind of reachability this request is concerned with. */
+  reachability?: ReachabilityType;
+}
+
+export interface ReachabilityResponse {
+  /** Maps Build Ids to their reachability information. */
+  buildIdReachability: Record<string | UnversionedBuildIdType, BuildIdReachability>;
+}
+
+export type ReachabilityTypeResponse = ReachabilityType | 'NOT_FETCHED';
+
+export interface BuildIdReachability {
+  /**
+   *  Maps Task Queue names to how the Build Id may be reachable from them. If they are not
+   *  reachable, the map value will be an empty array.
+   */
+  taskQueueReachability: Record<string, ReachabilityTypeResponse[]>;
+}
+
+function reachabilityTypeToProto(type: ReachabilityType | undefined | null): temporal.api.enums.v1.TaskReachability {
+  switch (type) {
+    case null:
+    case undefined:
+      return temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_UNSPECIFIED;
+    case 'NEW_WORKFLOWS':
+      return temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_NEW_WORKFLOWS;
+    case 'EXISTING_WORKFLOWS':
+      return temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_EXISTING_WORKFLOWS;
+    case 'OPEN_WORKFLOWS':
+      return temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_OPEN_WORKFLOWS;
+    case 'CLOSED_WORKFLOWS':
+      return temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_CLOSED_WORKFLOWS;
+    default:
+      assertNever('Unknown Build Id reachability operation', type);
+  }
+}
+
+export function reachabilityResponseFromProto(resp: GetWorkerTaskReachabilityResponse): ReachabilityResponse {
+  return {
+    buildIdReachability: Object.fromEntries(
+      resp.buildIdReachability.map((bir) => {
+        const taskQueueReachability: Record<string, ReachabilityTypeResponse[]> = {};
+        if (bir.taskQueueReachability != null) {
+          for (const tqr of bir.taskQueueReachability) {
+            if (tqr.taskQueue == null) {
+              continue;
+            }
+            if (tqr.reachability == null) {
+              taskQueueReachability[tqr.taskQueue] = [];
+              continue;
+            }
+            taskQueueReachability[tqr.taskQueue] = tqr.reachability.map(reachabilityTypeFromProto);
+          }
+        }
+        let bid: string | UnversionedBuildIdType;
+        if (bir.buildId) {
+          bid = bir.buildId;
+        } else {
+          bid = UnversionedBuildId;
+        }
+        return [bid, { taskQueueReachability }];
+      })
+    ) as Record<string | UnversionedBuildIdType, BuildIdReachability>,
+  };
+}
+
+function reachabilityTypeFromProto(rtype: temporal.api.enums.v1.TaskReachability): ReachabilityTypeResponse {
+  switch (rtype) {
+    case temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_UNSPECIFIED:
+      return 'NOT_FETCHED';
+    case temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_NEW_WORKFLOWS:
+      return 'NEW_WORKFLOWS';
+    case temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_EXISTING_WORKFLOWS:
+      return 'EXISTING_WORKFLOWS';
+    case temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_OPEN_WORKFLOWS:
+      return 'OPEN_WORKFLOWS';
+    case temporal.api.enums.v1.TaskReachability.TASK_REACHABILITY_CLOSED_WORKFLOWS:
+      return 'CLOSED_WORKFLOWS';
+    default:
+      return assertNever('Unknown Build Id reachability operation', rtype);
+  }
+}
+
+/**
+ * Thrown when one or more Build Ids are not found while using the {@link TaskQueueClient}.
+ *
+ * It could be because:
+ * - Id passed is incorrect
+ * - Build Id has been scavenged by the server.
+ *
+ * @experimental
+ */
+export class BuildIdNotFoundError extends Error {
+  public readonly name: string = 'BuildIdNotFoundError';
+
+  constructor(message: string) {
+    super(message);
+  }
+}

package/src/workflow-client.ts

@@ -18,6 +18,7 @@ import {
   WorkflowExecutionAlreadyStartedError,
   WorkflowNotFoundError,
   WorkflowResultType,
+  extractWorkflowType,
 } from '@temporalio/common';
 import { composeInterceptors } from '@temporalio/common/lib/interceptors';
 import { History } from '@temporalio/common/lib/proto-utils';
@@ -30,7 +31,7 @@ import {
   filterNullAndUndefined,
 } from '@temporalio/common/lib/internal-non-workflow';
 import { temporal } from '@temporalio/proto';
-import { isServerErrorResponse, ServiceError, WorkflowContinuedAsNewError, WorkflowFailedError } from './errors';
+import { ServiceError, WorkflowContinuedAsNewError, WorkflowFailedError, isGrpcServiceError } from './errors';
 import {
   WorkflowCancelInput,
   WorkflowClientInterceptor,
@@ -59,7 +60,7 @@ import {
   WorkflowSignalWithStartOptions,
   WorkflowStartOptions,
 } from './workflow-options';
-import { executionInfoFromRaw } from './helpers';
+import { executionInfoFromRaw, rethrowKnownErrorTypes } from './helpers';
 import {
   BaseClient,
   BaseClientOptions,
@@ -345,7 +346,7 @@ export class WorkflowClient extends BaseClient {
     options: WithWorkflowArgs<T, WorkflowOptions>,
     interceptors: WorkflowClientInterceptor[]
   ): Promise<string> {
-    const workflowType = typeof workflowTypeOrFunc === 'string' ? workflowTypeOrFunc : workflowTypeOrFunc.name;
+    const workflowType = extractWorkflowType(workflowTypeOrFunc);
     assertRequiredWorkflowOptions(options);
     const compiledOptions = compileWorkflowOptions(ensureArgs(options));
 
@@ -369,7 +370,7 @@ export class WorkflowClient extends BaseClient {
     options: WithWorkflowArgs<T, WorkflowSignalWithStartOptions<SA>>,
     interceptors: WorkflowClientInterceptor[]
   ): Promise<string> {
-    const workflowType = typeof workflowTypeOrFunc === 'string' ? workflowTypeOrFunc : workflowTypeOrFunc.name;
+    const workflowType = extractWorkflowType(workflowTypeOrFunc);
     const { signal, signalArgs, ...rest } = options;
     assertRequiredWorkflowOptions(rest);
     const compiledOptions = compileWorkflowOptions(ensureArgs(rest));
@@ -486,7 +487,7 @@ export class WorkflowClient extends BaseClient {
       try {
         res = await this.workflowService.getWorkflowExecutionHistory(req);
       } catch (err) {
-        this.rethrowGrpcError(err, { workflowId, runId }, 'Failed to get Workflow execution history');
+        this.rethrowGrpcError(err, 'Failed to get Workflow execution history', { workflowId, runId });
       }
       const events = res.history?.events;
 
@@ -580,18 +581,21 @@ export class WorkflowClient extends BaseClient {
     }
   }
 
-  protected rethrowGrpcError(err: unknown, workflowExecution: WorkflowExecution, fallbackMessage: string): never {
-    if (isServerErrorResponse(err)) {
+  protected rethrowGrpcError(err: unknown, fallbackMessage: string, workflowExecution?: WorkflowExecution): never {
+    if (isGrpcServiceError(err)) {
+      rethrowKnownErrorTypes(err);
+
       if (err.code === grpcStatus.NOT_FOUND) {
         throw new WorkflowNotFoundError(
           err.details ?? 'Workflow not found',
-          workflowExecution.workflowId,
-          workflowExecution.runId
+          workflowExecution?.workflowId ?? '',
+          workflowExecution?.runId
         );
       }
+
       throw new ServiceError(fallbackMessage, { cause: err });
     }
-    throw new ServiceError('Unexpected error while making gRPC request');
+    throw new ServiceError('Unexpected error while making gRPC request', { cause: err as Error });
   }
 
   /**
@@ -600,23 +604,27 @@ export class WorkflowClient extends BaseClient {
    * Used as the final function of the query interceptor chain
    */
   protected async _queryWorkflowHandler(input: WorkflowQueryInput): Promise<unknown> {
+    const req: temporal.api.workflowservice.v1.IQueryWorkflowRequest = {
+      queryRejectCondition: input.queryRejectCondition,
+      namespace: this.options.namespace,
+      execution: input.workflowExecution,
+      query: {
+        queryType: input.queryType,
+        queryArgs: { payloads: await encodeToPayloads(this.dataConverter, ...input.args) },
+        header: { fields: input.headers },
+      },
+    };
     let response: temporal.api.workflowservice.v1.QueryWorkflowResponse;
     try {
-      response = await this.workflowService.queryWorkflow({
-        queryRejectCondition: input.queryRejectCondition,
-        namespace: this.options.namespace,
-        execution: input.workflowExecution,
-        query: {
-          queryType: input.queryType,
-          queryArgs: { payloads: await encodeToPayloads(this.dataConverter, ...input.args) },
-          header: { fields: input.headers },
-        },
-      });
+      response = await this.workflowService.queryWorkflow(req);
     } catch (err) {
-      if (isServerErrorResponse(err) && err.code === grpcStatus.INVALID_ARGUMENT) {
-        throw new QueryNotRegisteredError(err.message.replace(/^3 INVALID_ARGUMENT: /, ''), err.code);
+      if (isGrpcServiceError(err)) {
+        rethrowKnownErrorTypes(err);
+        if (err.code === grpcStatus.INVALID_ARGUMENT) {
+          throw new QueryNotRegisteredError(err.message.replace(/^3 INVALID_ARGUMENT: /, ''), err.code);
+        }
       }
-      this.rethrowGrpcError(err, input.workflowExecution, 'Failed to query Workflow');
+      this.rethrowGrpcError(err, 'Failed to query Workflow', input.workflowExecution);
     }
     if (response.queryRejected) {
       if (response.queryRejected.status === undefined || response.queryRejected.status === null) {
@@ -637,19 +645,20 @@ export class WorkflowClient extends BaseClient {
    * Used as the final function of the signal interceptor chain
    */
   protected async _signalWorkflowHandler(input: WorkflowSignalInput): Promise<void> {
+    const req: temporal.api.workflowservice.v1.ISignalWorkflowExecutionRequest = {
+      identity: this.options.identity,
+      namespace: this.options.namespace,
+      workflowExecution: input.workflowExecution,
+      requestId: uuid4(),
+      // control is unused,
+      signalName: input.signalName,
+      header: { fields: input.headers },
+      input: { payloads: await encodeToPayloads(this.dataConverter, ...input.args) },
+    };
     try {
-      await this.workflowService.signalWorkflowExecution({
-        identity: this.options.identity,
-        namespace: this.options.namespace,
-        workflowExecution: input.workflowExecution,
-        requestId: uuid4(),
-        // control is unused,
-        signalName: input.signalName,
-        header: { fields: input.headers },
-        input: { payloads: await encodeToPayloads(this.dataConverter, ...input.args) },
-      });
+      await this.workflowService.signalWorkflowExecution(req);
     } catch (err) {
-      this.rethrowGrpcError(err, input.workflowExecution, 'Failed to signal Workflow');
+      this.rethrowGrpcError(err, 'Failed to signal Workflow', input.workflowExecution);
     }
   }
 
@@ -661,37 +670,37 @@ export class WorkflowClient extends BaseClient {
   protected async _signalWithStartWorkflowHandler(input: WorkflowSignalWithStartInput): Promise<string> {
     const { identity } = this.options;
     const { options, workflowType, signalName, signalArgs, headers } = input;
+    const req: temporal.api.workflowservice.v1.ISignalWithStartWorkflowExecutionRequest = {
+      namespace: this.options.namespace,
+      identity,
+      requestId: uuid4(),
+      workflowId: options.workflowId,
+      workflowIdReusePolicy: options.workflowIdReusePolicy,
+      workflowType: { name: workflowType },
+      input: { payloads: await encodeToPayloads(this.dataConverter, ...options.args) },
+      signalName,
+      signalInput: { payloads: await encodeToPayloads(this.dataConverter, ...signalArgs) },
+      taskQueue: {
+        kind: temporal.api.enums.v1.TaskQueueKind.TASK_QUEUE_KIND_UNSPECIFIED,
+        name: options.taskQueue,
+      },
+      workflowExecutionTimeout: options.workflowExecutionTimeout,
+      workflowRunTimeout: options.workflowRunTimeout,
+      workflowTaskTimeout: options.workflowTaskTimeout,
+      retryPolicy: options.retry ? compileRetryPolicy(options.retry) : undefined,
+      memo: options.memo ? { fields: await encodeMapToPayloads(this.dataConverter, options.memo) } : undefined,
+      searchAttributes: options.searchAttributes
+        ? {
+            indexedFields: mapToPayloads(searchAttributePayloadConverter, options.searchAttributes),
+          }
+        : undefined,
+      cronSchedule: options.cronSchedule,
+      header: { fields: headers },
+    };
     try {
-      const { runId } = await this.workflowService.signalWithStartWorkflowExecution({
-        namespace: this.options.namespace,
-        identity,
-        requestId: uuid4(),
-        workflowId: options.workflowId,
-        workflowIdReusePolicy: options.workflowIdReusePolicy,
-        workflowType: { name: workflowType },
-        input: { payloads: await encodeToPayloads(this.dataConverter, ...options.args) },
-        signalName,
-        signalInput: { payloads: await encodeToPayloads(this.dataConverter, ...signalArgs) },
-        taskQueue: {
-          kind: temporal.api.enums.v1.TaskQueueKind.TASK_QUEUE_KIND_UNSPECIFIED,
-          name: options.taskQueue,
-        },
-        workflowExecutionTimeout: options.workflowExecutionTimeout,
-        workflowRunTimeout: options.workflowRunTimeout,
-        workflowTaskTimeout: options.workflowTaskTimeout,
-        retryPolicy: options.retry ? compileRetryPolicy(options.retry) : undefined,
-        memo: options.memo ? { fields: await encodeMapToPayloads(this.dataConverter, options.memo) } : undefined,
-        searchAttributes: options.searchAttributes
-          ? {
-              indexedFields: mapToPayloads(searchAttributePayloadConverter, options.searchAttributes),
-            }
-          : undefined,
-        cronSchedule: options.cronSchedule,
-        header: { fields: headers },
-      });
-      return runId;
+      return (await this.workflowService.signalWithStartWorkflowExecution(req)).runId;
     } catch (err) {
-      this.rethrowGrpcError(err, { workflowId: options.workflowId }, 'Failed to signalWithStart Workflow');
+      this.rethrowGrpcError(err, 'Failed to signalWithStart Workflow', { workflowId: options.workflowId });
     }
   }
 
@@ -729,8 +738,7 @@ export class WorkflowClient extends BaseClient {
       header: { fields: headers },
     };
     try {
-      const res = await this.workflowService.startWorkflowExecution(req);
-      return res.runId;
+      return (await this.workflowService.startWorkflowExecution(req)).runId;
     } catch (err: any) {
       if (err.code === grpcStatus.ALREADY_EXISTS) {
         throw new WorkflowExecutionAlreadyStartedError(
@@ -739,7 +747,7 @@ export class WorkflowClient extends BaseClient {
           workflowType
         );
       }
-      this.rethrowGrpcError(err, { workflowId: opts.workflowId }, 'Failed to start Workflow');
+      this.rethrowGrpcError(err, 'Failed to start Workflow', { workflowId: opts.workflowId });
     }
   }
 
@@ -751,18 +759,19 @@ export class WorkflowClient extends BaseClient {
   protected async _terminateWorkflowHandler(
     input: WorkflowTerminateInput
   ): Promise<TerminateWorkflowExecutionResponse> {
+    const req: temporal.api.workflowservice.v1.ITerminateWorkflowExecutionRequest = {
+      namespace: this.options.namespace,
+      identity: this.options.identity,
+      ...input,
+      details: {
+        payloads: input.details ? await encodeToPayloads(this.dataConverter, ...input.details) : undefined,
+      },
+      firstExecutionRunId: input.firstExecutionRunId,
+    };
     try {
-      return await this.workflowService.terminateWorkflowExecution({
-        namespace: this.options.namespace,
-        identity: this.options.identity,
-        ...input,
-        details: {
-          payloads: input.details ? await encodeToPayloads(this.dataConverter, ...input.details) : undefined,
-        },
-        firstExecutionRunId: input.firstExecutionRunId,
-      });
+      return await this.workflowService.terminateWorkflowExecution(req);
     } catch (err) {
-      this.rethrowGrpcError(err, input.workflowExecution, 'Failed to terminate Workflow');
+      this.rethrowGrpcError(err, 'Failed to terminate Workflow', input.workflowExecution);
     }
   }
 
@@ -781,7 +790,7 @@ export class WorkflowClient extends BaseClient {
         firstExecutionRunId: input.firstExecutionRunId,
       });
     } catch (err) {
-      this.rethrowGrpcError(err, input.workflowExecution, 'Failed to cancel workflow');
+      this.rethrowGrpcError(err, 'Failed to cancel workflow', input.workflowExecution);
     }
   }
 
@@ -797,7 +806,7 @@ export class WorkflowClient extends BaseClient {
         execution: input.workflowExecution,
       });
     } catch (err) {
-      this.rethrowGrpcError(err, input.workflowExecution, 'Failed to describe workflow');
+      this.rethrowGrpcError(err, 'Failed to describe workflow', input.workflowExecution);
     }
   }
 
@@ -925,12 +934,17 @@ export class WorkflowClient extends BaseClient {
   protected async *_list(options?: ListOptions): AsyncIterable<WorkflowExecutionInfo> {
     let nextPageToken: Uint8Array = Buffer.alloc(0);
     for (;;) {
-      const response = await this.workflowService.listWorkflowExecutions({
-        namespace: this.options.namespace,
-        query: options?.query,
-        nextPageToken,
-        pageSize: options?.pageSize,
-      });
+      let response: temporal.api.workflowservice.v1.ListWorkflowExecutionsResponse;
+      try {
+        response = await this.workflowService.listWorkflowExecutions({
+          namespace: this.options.namespace,
+          query: options?.query,
+          nextPageToken,
+          pageSize: options?.pageSize,
+        });
+      } catch (e) {
+        this.rethrowGrpcError(e, 'Failed to list workflows', undefined);
+      }
       // Not decoding memo payloads concurrently even though we could have to keep the lazy nature of this iterator.
       // Decoding is done for `memo` fields which tend to be small.
       // We might decide to change that based on user feedback.