@temporalio/workflow 1.17.2 → 1.17.3

package/src/internals.ts

@@ -1,17 +1,20 @@
+import type { AsyncLocalStorage as ALS } from 'node:async_hooks';
 import type { RawSourceMap } from 'source-map';
 import type {
+  ActivitySerializationContext,
   FailureConverter,
   PayloadConverter,
+  ProtoFailure,
   Workflow,
+  WorkflowFunctionWithOptions,
   WorkflowQueryAnnotatedType,
   WorkflowSignalAnnotatedType,
   WorkflowUpdateAnnotatedType,
-  ProtoFailure,
   WorkflowUpdateType,
   WorkflowUpdateValidatorType,
-  WorkflowFunctionWithOptions,
   VersioningBehavior,
   WorkflowDefinitionOptions,
+  WorkflowSerializationContext,
 } from '@temporalio/common';
 import {
   defaultFailureConverter,
@@ -31,7 +34,6 @@ import {
   decodeSearchAttributes,
   decodeTypedSearchAttributes,
 } from '@temporalio/common/lib/converter/payload-search-attributes';
-import { composeInterceptors } from '@temporalio/common/lib/interceptors';
 import { makeProtoEnumConverters } from '@temporalio/common/lib/internal-workflow';
 import type { coresdk, temporal } from '@temporalio/proto';
 import {
@@ -42,7 +44,9 @@ import {
 import type { RNG } from './alea';
 import { alea } from './alea';
 import { RootCancellationScope } from './cancellation-scope';
-import { UpdateScope } from './update-scope';
+import { composeInterceptors } from './interceptor-composition';
+import { AsyncLocalStorage, UpdateScope } from './update-scope';
+import { deriveAleaSeed } from './random-stream-seed';
 import { DeterminismViolationError, LocalActivityDoBackoff, isCancellation } from './errors';
 import type {
   QueryInput,
@@ -106,9 +110,10 @@ export interface PromiseStackStore {
   promiseToStack: Map<Promise<unknown>, Stack>;
 }
 
-export interface Completion<Success> {
+export interface Completion<Success, Context = never> {
   resolve(val: Success): void;
   reject(reason: Error): void;
+  context?: Context;
 }
 
 export interface Condition {
@@ -139,6 +144,10 @@ interface MessageHandlerExecution {
 
 type InferMapValue<T> = T extends Map<number, infer V> ? V : never;
 
+interface ScopedWorkflowRandomSource {
+  random(): number;
+}
+
 /**
  * Keeps all of the Workflow runtime state like pending completions for activities and timers.
  *
@@ -168,13 +177,13 @@ export class Activator implements ActivationHandler {
    */
   readonly completions = {
     timer: new Map<number, Completion<void>>(),
-    activity: new Map<number, Completion<unknown>>(),
+    activity: new Map<number, Completion<unknown, ActivitySerializationContext>>(),
     nexusOperationStart: new Map<number, Completion<StartNexusOperationOutput>>(),
     nexusOperationComplete: new Map<number, Completion<unknown>>(),
-    childWorkflowStart: new Map<number, Completion<string>>(),
-    childWorkflowComplete: new Map<number, Completion<unknown>>(),
-    signalWorkflow: new Map<number, Completion<void>>(),
-    cancelWorkflow: new Map<number, Completion<void>>(),
+    childWorkflowStart: new Map<number, Completion<string, WorkflowSerializationContext>>(),
+    childWorkflowComplete: new Map<number, Completion<unknown, WorkflowSerializationContext>>(),
+    signalWorkflow: new Map<number, Completion<void, WorkflowSerializationContext>>(),
+    cancelWorkflow: new Map<number, Completion<void, WorkflowSerializationContext>>(),
   };
 
   /**
@@ -268,6 +277,22 @@ export class Activator implements ActivationHandler {
    */
   public workflowTaskError: unknown;
 
+  /**
+   * Error type _names_ (from {@link WorkerOptions.workflowFailureErrorTypes}) that
+   * should cause Workflow Execution failure rather than WFT failure.
+   *
+   * Set at workflow creation time from the worker options.
+   */
+  public failureExceptionTypeNames: string[] = [];
+
+  /**
+   * Error _types_ (from {@link WorkflowDefinitionOptions.failureExceptionTypes})
+   * that should cause Workflow Execution failure rather than WFT failure.
+   *
+   * Set in `worker-interface.ts` after the workflow definition options are read.
+   */
+  public workflowDefinitionFailureExceptionTypes: Array<new (...args: any[]) => Error> | undefined = undefined;
+
   /**
    * Set to true when running synchronous code (e.g. while processing activation jobs and when calling
    * `tryUnblockConditions()`). While this flag is set, it is safe to let errors bubble up.
@@ -419,10 +444,24 @@ export class Activator implements ActivationHandler {
   public info: WorkflowInfo;
 
   /**
-   * A deterministic RNG, used by the isolate's overridden Math.random
+   * The main deterministic RNG for this workflow execution.
+   *
+   * Scoped overrides used by `WorkflowRandomStream.with(...)` are layered on top of this RNG.
    */
   public random: RNG;
 
+  /**
+   * The current seed material for this workflow execution's deterministic RNGs.
+   */
+  public randomnessSeed: number[];
+
+  /**
+   * Additional deterministic RNG streams keyed by stable stream name.
+   */
+  public readonly namedRandomStreams = new Map<string, RNG>();
+
+  protected currentRandomStorage?: ALS<ScopedWorkflowRandomSource | undefined>;
+
   public payloadConverter: PayloadConverter = defaultPayloadConverter;
   public failureConverter: FailureConverter = defaultFailureConverter;
 
@@ -472,15 +511,55 @@ export class Activator implements ActivationHandler {
     randomnessSeed,
     registeredActivityNames,
     stackTracesEnabled,
+    failureExceptionTypeNames,
   }: WorkflowCreateOptionsInternal) {
     this.getTimeOfDay = getTimeOfDay;
     this.info = info;
     this.now = now;
     this.showStackTraceSources = showStackTraceSources;
     this.sourceMap = sourceMap;
-    this.random = alea(randomnessSeed);
+    this.randomnessSeed = [...randomnessSeed];
+    this.random = alea(this.randomnessSeed);
     this.registeredActivityNames = registeredActivityNames;
     this.stackTracesEnabled = stackTracesEnabled;
+    this.failureExceptionTypeNames = failureExceptionTypeNames ?? [];
+  }
+
+  protected setRandomnessSeed(randomnessSeed: number[]): void {
+    this.randomnessSeed = [...randomnessSeed];
+    this.random = alea(this.randomnessSeed);
+    this.namedRandomStreams.clear();
+  }
+
+  public getNamedRandom(name: string): RNG {
+    const cached = this.namedRandomStreams.get(name);
+    if (cached !== undefined) {
+      return cached;
+    }
+
+    const random = alea(deriveAleaSeed(this.randomnessSeed, name));
+    this.namedRandomStreams.set(name, random);
+    return random;
+  }
+
+  protected withRandomSource<T>(randomSource: ScopedWorkflowRandomSource | undefined, fn: () => T): T {
+    return (this.currentRandomStorage ??= new AsyncLocalStorage<ScopedWorkflowRandomSource | undefined>()).run(
+      randomSource,
+      fn
+    );
+  }
+
+  public withCurrentRandom<T>(randomSource: ScopedWorkflowRandomSource, fn: () => T): T {
+    return this.withRandomSource(randomSource, fn);
+  }
+
+  public bindCurrentRandom<T extends (...args: any[]) => any>(fn: T): T {
+    const randomSource = this.currentRandomStorage?.getStore();
+    return ((...args: Parameters<T>) => this.withRandomSource(randomSource, () => fn(...args))) as T;
+  }
+
+  public currentRandom(): number {
+    return this.currentRandomStorage?.getStore()?.random() ?? this.random();
   }
 
   /**
@@ -554,12 +633,13 @@ export class Activator implements ActivationHandler {
 
   public startWorkflow(activation: coresdk.workflow_activation.IInitializeWorkflow): void {
     const execute = composeInterceptors(this.interceptors.inbound, 'execute', this.startWorkflowNextHandler.bind(this));
+    const context = this.workflowSerializationContext();
 
     untrackPromise(
       executeWithLifecycleLogging(() =>
         execute({
           headers: activation.headers ?? {},
-          args: arrayFromPayloads(this.payloadConverter, activation.arguments),
+          args: arrayFromPayloads(this.payloadConverter, activation.arguments, context),
         })
       ).then(this.completeWorkflow.bind(this), this.handleWorkflowFailure.bind(this))
     );
@@ -567,6 +647,7 @@ export class Activator implements ActivationHandler {
 
   public initializeWorkflow(activation: coresdk.workflow_activation.IInitializeWorkflow): void {
     const { continuedFailure, lastCompletionResult, memo, searchAttributes } = activation;
+    const context = this.workflowSerializationContext();
 
     // Most things related to initialization have already been handled in the constructor
     this.mutateWorkflowInfo((info) => ({
@@ -575,15 +656,17 @@ export class Activator implements ActivationHandler {
       searchAttributes: decodeSearchAttributes(searchAttributes?.indexedFields),
       typedSearchAttributes: decodeTypedSearchAttributes(searchAttributes?.indexedFields),
 
-      memo: mapFromPayloads(this.payloadConverter, memo?.fields),
-      lastResult: fromPayloadsAtIndex(this.payloadConverter, 0, lastCompletionResult?.payloads),
+      memo: mapFromPayloads(this.payloadConverter, memo?.fields, context),
+      lastResult: fromPayloadsAtIndex(this.payloadConverter, 0, lastCompletionResult?.payloads, context),
       lastFailure:
         continuedFailure != null
-          ? this.failureConverter.failureToError(continuedFailure, this.payloadConverter)
+          ? this.failureConverter.failureToError(continuedFailure, this.payloadConverter, context)
           : undefined,
     }));
-    if (this.workflowDefinitionOptionsGetter) {
-      this.versioningBehavior = this.workflowDefinitionOptionsGetter().versioningBehavior;
+    const workflowDefinitionOpts = this.workflowDefinitionOptionsGetter?.();
+    if (workflowDefinitionOpts) {
+      this.versioningBehavior = workflowDefinitionOpts.versioningBehavior;
+      this.workflowDefinitionFailureExceptionTypes = workflowDefinitionOpts.failureExceptionTypes;
     }
   }
 
@@ -603,23 +686,23 @@ export class Activator implements ActivationHandler {
     if (!activation.result) {
       throw new TypeError('Got ResolveActivity activation with no result');
     }
-    const { resolve, reject } = this.consumeCompletion('activity', getSeq(activation));
+    const { resolve, reject, context } = this.consumeCompletion('activity', getSeq(activation));
     if (activation.result.completed) {
       const completed = activation.result.completed;
-      const result = completed.result ? this.payloadConverter.fromPayload(completed.result) : undefined;
+      const result = completed.result ? this.payloadConverter.fromPayload(completed.result, context) : undefined;
       resolve(result);
     } else if (activation.result.failed) {
       const { failure } = activation.result.failed;
       if (failure == null) {
         throw new TypeError('Got failed result with no failure attribute');
       }
-      reject(this.failureToError(failure));
+      reject(this.failureConverter.failureToError(failure, this.payloadConverter, context));
     } else if (activation.result.cancelled) {
       const { failure } = activation.result.cancelled;
       if (failure == null) {
         throw new TypeError('Got cancelled result with no failure attribute');
       }
-      reject(this.failureToError(failure));
+      reject(this.failureConverter.failureToError(failure, this.payloadConverter, context));
     } else if (activation.result.backoff) {
       reject(new LocalActivityDoBackoff(activation.result.backoff));
     }
@@ -628,7 +711,7 @@ export class Activator implements ActivationHandler {
   public resolveChildWorkflowExecutionStart(
     activation: coresdk.workflow_activation.IResolveChildWorkflowExecutionStart
   ): void {
-    const { resolve, reject } = this.consumeCompletion('childWorkflowStart', getSeq(activation));
+    const { resolve, reject, context } = this.consumeCompletion('childWorkflowStart', getSeq(activation));
     if (activation.succeeded) {
       if (!activation.succeeded.runId) {
         throw new TypeError('Got ResolveChildWorkflowExecutionStart with no runId');
@@ -652,7 +735,7 @@ export class Activator implements ActivationHandler {
       if (!activation.cancelled.failure) {
         throw new TypeError('Got no failure in cancelled variant');
       }
-      reject(this.failureToError(activation.cancelled.failure));
+      reject(this.failureConverter.failureToError(activation.cancelled.failure, this.payloadConverter, context));
     } else {
       throw new TypeError('Got ResolveChildWorkflowExecutionStart with no status');
     }
@@ -662,23 +745,23 @@ export class Activator implements ActivationHandler {
     if (!activation.result) {
       throw new TypeError('Got ResolveChildWorkflowExecution activation with no result');
     }
-    const { resolve, reject } = this.consumeCompletion('childWorkflowComplete', getSeq(activation));
+    const { resolve, reject, context } = this.consumeCompletion('childWorkflowComplete', getSeq(activation));
     if (activation.result.completed) {
       const completed = activation.result.completed;
-      const result = completed.result ? this.payloadConverter.fromPayload(completed.result) : undefined;
+      const result = completed.result ? this.payloadConverter.fromPayload(completed.result, context) : undefined;
       resolve(result);
     } else if (activation.result.failed) {
       const { failure } = activation.result.failed;
       if (failure == null) {
         throw new TypeError('Got failed result with no failure attribute');
       }
-      reject(this.failureToError(failure));
+      reject(this.failureConverter.failureToError(failure, this.payloadConverter, context));
     } else if (activation.result.cancelled) {
       const { failure } = activation.result.cancelled;
       if (failure == null) {
         throw new TypeError('Got cancelled result with no failure attribute');
       }
-      reject(this.failureToError(failure));
+      reject(this.failureConverter.failureToError(failure, this.payloadConverter, context));
     }
   }
 
@@ -704,9 +787,10 @@ export class Activator implements ActivationHandler {
 
   public resolveNexusOperation(activation: coresdk.workflow_activation.IResolveNexusOperation): void {
     const seq = getSeq(activation);
+    const context = this.workflowSerializationContext();
 
     if (activation.result?.completed) {
-      const result = this.payloadConverter.fromPayload(activation.result.completed);
+      const result = this.payloadConverter.fromPayload(activation.result.completed, context);
 
       // It is possible for ResolveNexusOperation to be received without a prior ResolveNexusOperationStart,
       // e.g. because the handler completed the Operation synchronously.
@@ -767,8 +851,14 @@ export class Activator implements ActivationHandler {
       throw new TypeError('Missing query activation attributes');
     }
 
-    // If query has __temporal_ prefix but no handler exists, throw error
-    if (queryType.startsWith(TEMPORAL_RESERVED_PREFIX) && !this.queryHandlers.has(queryType)) {
+    // Reject __temporal_-prefixed queries that would otherwise be routed to the
+    // user's default handler. A specific registered handler (e.g. from a
+    // contrib package) is allowed through.
+    if (
+      queryType.startsWith(TEMPORAL_RESERVED_PREFIX) &&
+      !this.queryHandlers.has(queryType) &&
+      this.defaultQueryHandler !== undefined
+    ) {
       throw new TypeError(`Cannot use query name: '${queryType}', with reserved prefix: '${TEMPORAL_RESERVED_PREFIX}'`);
     }
 
@@ -779,9 +869,10 @@ export class Activator implements ActivationHandler {
       queryType === ENHANCED_STACK_TRACE_QUERY_NAME;
     const interceptors = isInternalQuery ? [] : this.interceptors.inbound;
     const execute = composeInterceptors(interceptors, 'handleQuery', this.queryWorkflowNextHandler.bind(this));
+    const context = this.workflowSerializationContext();
     execute({
       queryName: queryType,
-      args: arrayFromPayloads(this.payloadConverter, activation.arguments),
+      args: arrayFromPayloads(this.payloadConverter, activation.arguments, context),
       queryId,
       headers: headers ?? {},
     }).then(
@@ -802,8 +893,15 @@ export class Activator implements ActivationHandler {
       throw new TypeError('Missing activation update protocolInstanceId');
     }
 
-    // If update has __temporal_ prefix but no handler exists, throw error
-    if (name.startsWith(TEMPORAL_RESERVED_PREFIX) && !this.updateHandlers.get(name)) {
+    // Reject __temporal_-prefixed updates that would otherwise be routed to the
+    // user's default handler. A specific registered handler (e.g. from a
+    // contrib package) is allowed through, and unregistered names without a
+    // default handler fall through to the buffer-then-reject path below.
+    if (
+      name.startsWith(TEMPORAL_RESERVED_PREFIX) &&
+      !this.updateHandlers.has(name) &&
+      this.defaultUpdateHandler !== undefined
+    ) {
       throw new TypeError(`Cannot use update name: '${name}', with reserved prefix: '${TEMPORAL_RESERVED_PREFIX}'`);
     }
 
@@ -831,12 +929,15 @@ export class Activator implements ActivationHandler {
       return;
     }
 
-    const makeInput = (): UpdateInput => ({
-      updateId,
-      args: arrayFromPayloads(this.payloadConverter, activation.input),
-      name,
-      headers: headers ?? {},
-    });
+    const makeInput = (): UpdateInput => {
+      const context = this.workflowSerializationContext();
+      return {
+        updateId,
+        args: arrayFromPayloads(this.payloadConverter, activation.input, context),
+        name,
+        headers: headers ?? {},
+      };
+    };
 
     // The implementation below is responsible for upholding, and constrained
     // by, the following contract:
@@ -979,8 +1080,15 @@ export class Activator implements ActivationHandler {
       throw new TypeError('Missing activation signalName');
     }
 
-    // If signal has __temporal_ prefix but no handler exists, throw error
-    if (signalName.startsWith(TEMPORAL_RESERVED_PREFIX) && !this.signalHandlers.has(signalName)) {
+    // Reject __temporal_-prefixed signals that would otherwise be routed to the
+    // user's default handler. A specific registered handler (e.g. from a
+    // contrib package) is allowed through, and unregistered names without a
+    // default handler fall through to the buffer-then-reject path below.
+    if (
+      signalName.startsWith(TEMPORAL_RESERVED_PREFIX) &&
+      !this.signalHandlers.has(signalName) &&
+      this.defaultSignalHandler !== undefined
+    ) {
       throw new TypeError(
         `Cannot use signal name: '${signalName}', with reserved prefix: '${TEMPORAL_RESERVED_PREFIX}'`
       );
@@ -1007,8 +1115,9 @@ export class Activator implements ActivationHandler {
     const signalExecutionNum = this.signalHandlerExecutionSeq++;
     this.inProgressSignals.set(signalExecutionNum, { name: signalName, unfinishedPolicy });
     const execute = composeInterceptors(interceptors, 'handleSignal', this.signalWorkflowNextHandler.bind(this));
+    const context = this.workflowSerializationContext();
     execute({
-      args: arrayFromPayloads(this.payloadConverter, activation.input),
+      args: arrayFromPayloads(this.payloadConverter, activation.input, context),
       signalName,
       headers: headers ?? {},
     })
@@ -1033,9 +1142,9 @@ export class Activator implements ActivationHandler {
   }
 
   public resolveSignalExternalWorkflow(activation: coresdk.workflow_activation.IResolveSignalExternalWorkflow): void {
-    const { resolve, reject } = this.consumeCompletion('signalWorkflow', getSeq(activation));
+    const { resolve, reject, context } = this.consumeCompletion('signalWorkflow', getSeq(activation));
     if (activation.failure) {
-      reject(this.failureToError(activation.failure));
+      reject(this.failureConverter.failureToError(activation.failure, this.payloadConverter, context));
     } else {
       resolve(undefined);
     }
@@ -1044,9 +1153,9 @@ export class Activator implements ActivationHandler {
   public resolveRequestCancelExternalWorkflow(
     activation: coresdk.workflow_activation.IResolveRequestCancelExternalWorkflow
   ): void {
-    const { resolve, reject } = this.consumeCompletion('cancelWorkflow', getSeq(activation));
+    const { resolve, reject, context } = this.consumeCompletion('cancelWorkflow', getSeq(activation));
     if (activation.failure) {
-      reject(this.failureToError(activation.failure));
+      reject(this.failureConverter.failureToError(activation.failure, this.payloadConverter, context));
     } else {
       resolve(undefined);
     }
@@ -1076,7 +1185,7 @@ export class Activator implements ActivationHandler {
     if (!activation.randomnessSeed) {
       throw new TypeError('Expected activation with randomnessSeed attribute');
     }
-    this.random = alea(activation.randomnessSeed.toBytes());
+    this.setRandomnessSeed(activation.randomnessSeed.toBytes());
   }
 
   public notifyHasPatch(activation: coresdk.workflow_activation.INotifyHasPatch): void {
@@ -1171,7 +1280,7 @@ export class Activator implements ActivationHandler {
       this.pushCommand({ cancelWorkflowExecution: {} }, true);
     } else if (error instanceof ContinueAsNew) {
       this.pushCommand({ continueAsNewWorkflowExecution: error.command }, true);
-    } else if (error instanceof TemporalFailure) {
+    } else if (error instanceof TemporalFailure || this.isConfiguredFailureException(error)) {
       // Fail the workflow. We do not want to issue unfinishedHandlers warnings. To achieve that, we
       // mark all handlers as completed now.
       this.inProgressSignals.clear();
@@ -1179,7 +1288,7 @@ export class Activator implements ActivationHandler {
       this.pushCommand(
         {
           failWorkflowExecution: {
-            failure: this.errorToFailure(error),
+            failure: this.errorToFailure(ensureTemporalFailure(error)),
           },
         },
         true
@@ -1189,6 +1298,42 @@ export class Activator implements ActivationHandler {
     }
   }
 
+  /**
+   * Returns true if the given error matches any of the configured failure exception types
+   * (from {@link WorkerOptions.workflowFailureErrorTypes} or
+   * {@link WorkflowDefinitionOptions.failureExceptionTypes}).
+   */
+  private isConfiguredFailureException(error: unknown): boolean {
+    // Check class references from WorkflowDefinitionOptions (instanceof-based, supports subclasses)
+    if (this.workflowDefinitionFailureExceptionTypes) {
+      // We guarantee that including Error in the list will catch _any_ error.
+      if (this.workflowDefinitionFailureExceptionTypes.includes(Error)) return true;
+
+      for (const errorType of this.workflowDefinitionFailureExceptionTypes) {
+        if (error instanceof errorType) return true;
+      }
+    }
+
+    // Check class name strings from WorkerOptions (prototype-chain-based)
+    if (this.failureExceptionTypeNames.length > 0) {
+      // We guarantee that including 'Error' in the list will catch _any_ error.
+      if (this.failureExceptionTypeNames.includes('Error')) return true;
+
+      if (typeof error === 'object' && error !== null) {
+        let ctor = (error as any).constructor;
+        while (ctor != null && ctor !== Function.prototype) {
+          const name = (ctor as any).name as string | undefined;
+          if (name) {
+            if (this.failureExceptionTypeNames.includes(name)) return true;
+          }
+          ctor = Object.getPrototypeOf(ctor);
+        }
+      }
+    }
+
+    return false;
+  }
+
   recordWorkflowTaskError(error: unknown): void {
     // Only keep the first error that bubbles up; subsequent errors will be ignored.
     if (this.workflowTaskError === undefined) this.workflowTaskError = error;
@@ -1208,8 +1353,9 @@ export class Activator implements ActivationHandler {
   }
 
   private completeQuery(queryId: string, result: unknown): void {
+    const context = this.workflowSerializationContext();
     this.pushCommand({
-      respondToQuery: { queryId, succeeded: { response: this.payloadConverter.toPayload(result) } },
+      respondToQuery: { queryId, succeeded: { response: this.payloadConverter.toPayload(result, context) } },
     });
   }
 
@@ -1227,8 +1373,9 @@ export class Activator implements ActivationHandler {
   }
 
   private completeUpdate(protocolInstanceId: string, result: unknown): void {
+    const context = this.workflowSerializationContext();
     this.pushCommand({
-      updateResponse: { protocolInstanceId, completed: this.payloadConverter.toPayload(result) },
+      updateResponse: { protocolInstanceId, completed: this.payloadConverter.toPayload(result, context) },
     });
   }
 
@@ -1266,10 +1413,11 @@ export class Activator implements ActivationHandler {
   }
 
   private completeWorkflow(result: unknown): void {
+    const context = this.workflowSerializationContext();
     this.pushCommand(
       {
         completeWorkflowExecution: {
-          result: this.payloadConverter.toPayload(result),
+          result: this.payloadConverter.toPayload(result, context),
         },
       },
       true
@@ -1277,11 +1425,21 @@ export class Activator implements ActivationHandler {
   }
 
   errorToFailure(err: unknown): ProtoFailure {
-    return this.failureConverter.errorToFailure(err, this.payloadConverter);
+    const context = this.workflowSerializationContext();
+    return this.failureConverter.errorToFailure(err, this.payloadConverter, context);
   }
 
   failureToError(failure: ProtoFailure): Error {
-    return this.failureConverter.failureToError(failure, this.payloadConverter);
+    const context = this.workflowSerializationContext();
+    return this.failureConverter.failureToError(failure, this.payloadConverter, context);
+  }
+
+  private workflowSerializationContext(): WorkflowSerializationContext {
+    return {
+      type: 'workflow',
+      namespace: this.info.namespace,
+      workflowId: this.info.workflowId,
+    };
   }
 }
 

package/src/logs.ts

@@ -1,5 +1,5 @@
-import { composeInterceptors } from '@temporalio/common/lib/interceptors';
 import { SdkComponent } from '@temporalio/common';
+import { composeInterceptors } from './interceptor-composition';
 import { untrackPromise } from './stack-helpers';
 import { type Sink, type Sinks, proxySinks } from './sinks';
 import { isCancellation } from './errors';

package/src/metrics.ts

@@ -7,7 +7,7 @@ import type {
   NumericMetricValueType,
 } from '@temporalio/common';
 import { MetricMeterWithComposedTags } from '@temporalio/common';
-import { composeInterceptors } from '@temporalio/common/lib/interceptors';
+import { composeInterceptors } from './interceptor-composition';
 import type { Sink, Sinks } from './sinks';
 import { proxySinks } from './sinks';
 import { workflowInfo } from './workflow';

package/src/nexus.ts

@@ -1,11 +1,11 @@
 import type * as nexus from 'nexus-rpc';
 import { msOptionalToTs } from '@temporalio/common/lib/time';
 import { userMetadataToPayload } from '@temporalio/common/lib/user-metadata';
-import { composeInterceptors } from '@temporalio/common/lib/interceptors';
 import { makeProtoEnumConverters } from '@temporalio/common/lib/internal-workflow/enums-helpers';
 import type { coresdk } from '@temporalio/proto';
 import { CancellationScope } from './cancellation-scope';
 import { getActivator } from './global-attributes';
+import { composeInterceptors } from './interceptor-composition';
 import { untrackPromise } from './stack-helpers';
 import type { StartNexusOperationInput, StartNexusOperationOutput, StartNexusOperationOptions } from './interceptors';
 
@@ -191,6 +191,11 @@ function startNexusOperationNextHandler({
   headers,
 }: StartNexusOperationInput): Promise<StartNexusOperationOutput> {
   const activator = getActivator();
+  const context = {
+    type: 'workflow' as const,
+    namespace: activator.info.namespace,
+    workflowId: activator.info.workflowId,
+  };
 
   return new Promise<StartNexusOperationOutput>((resolve, reject) => {
     const scope = CancellationScope.current();
@@ -223,13 +228,13 @@ function startNexusOperationNextHandler({
         service,
         operation,
         nexusHeader: headers,
-        input: activator.payloadConverter.toPayload(input),
+        input: activator.payloadConverter.toPayload(input, context),
         scheduleToCloseTimeout: msOptionalToTs(options?.scheduleToCloseTimeout),
         scheduleToStartTimeout: msOptionalToTs(options?.scheduleToStartTimeout),
         startToCloseTimeout: msOptionalToTs(options?.startToCloseTimeout),
         cancellationType: encodeNexusOperationCancellationType(options?.cancellationType),
       },
-      userMetadata: userMetadataToPayload(activator.payloadConverter, options?.summary, undefined),
+      userMetadata: userMetadataToPayload(activator.payloadConverter, options?.summary, undefined, context),
     });
 
     activator.completions.nexusOperationStart.set(seq, {

package/src/random-helpers.ts

@@ -0,0 +1,21 @@
+export function fillWithRandom(random: () => number, bytes: Uint8Array): Uint8Array {
+  for (let i = 0; i < bytes.length; ++i) {
+    bytes[i] = Math.floor(random() * 0x100);
+  }
+  return bytes;
+}
+
+export function uuid4FromRandom(random: () => number): string {
+  const ho = (n: number, p: number) => n.toString(16).padStart(p, '0');
+  const view = new DataView(new ArrayBuffer(16));
+  view.setUint32(0, (random() * 0x100000000) >>> 0);
+  view.setUint32(4, (random() * 0x100000000) >>> 0);
+  view.setUint32(8, (random() * 0x100000000) >>> 0);
+  view.setUint32(12, (random() * 0x100000000) >>> 0);
+  view.setUint8(6, (view.getUint8(6) & 0xf) | 0x40);
+  view.setUint8(8, (view.getUint8(8) & 0x3f) | 0x80);
+  return `${ho(view.getUint32(0), 8)}-${ho(view.getUint16(4), 4)}-${ho(view.getUint16(6), 4)}-${ho(
+    view.getUint16(8),
+    4
+  )}-${ho(view.getUint32(10), 8)}${ho(view.getUint16(14), 4)}`;
+}

package/src/random-stream-seed.ts

@@ -0,0 +1,18 @@
+import { encode } from '@temporalio/common/lib/encoding';
+
+const RANDOM_STREAM_SEED_PREFIX = Array.from(encode('temporal-workflow-random-stream-v1'));
+
+function encodeU32(value: number): number[] {
+  return [(value >>> 24) & 0xff, (value >>> 16) & 0xff, (value >>> 8) & 0xff, value & 0xff];
+}
+
+export function deriveAleaSeed(seed: number[], namespace: string): number[] {
+  const namespaceBytes = Array.from(encode(namespace));
+  return [
+    ...RANDOM_STREAM_SEED_PREFIX,
+    ...encodeU32(seed.length),
+    ...seed,
+    ...encodeU32(namespaceBytes.length),
+    ...namespaceBytes,
+  ];
+}