@outputai/core 0.10.1-next.f6a7c1a.0 → 0.11.0

package/src/worker/interceptors/workflow.js

@@ -1,13 +1,17 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
-import { workflowInfo, proxySinks, ContinueAsNew, isCancellation } from '@temporalio/workflow';
+import { workflowInfo, proxySinks, ContinueAsNew, isCancellation, ApplicationFailure, TemporalFailure, upsertMemo } from '@temporalio/workflow';
 import { memoToHeaders } from './headers.js';
 import { deepMerge } from '#helpers/object';
-import { buildApplicationFailureWithDetails } from '#helpers/errors';
-import { METADATA_ACCESS_SYMBOL, WorkflowSpecialOutput } from '#consts';
+import { WorkflowSpecialOutput } from '#consts';
 import { createWorkflowDetails } from '#helpers/temporal_context';
+import { TraceInfo } from '#helpers/trace_info';
+import { FatalError, TransparentFatalError } from '#errors';
+import { serializeError } from '#helpers/error_serializer';
+import { enforceActivityOptions } from '#helpers/activity_options';
 
-// this is a dynamic generated file with activity configs overwrites
+// these are a dynamic generated file with activity configs overwrites and workflow options
 import activityOptionsMap from '../temp/__activity_options.js';
+import workflowOptionsMap from '../temp/__workflow_options.js';
 
 /*
   This interceptor adds Memo and serialized workflowInfo() to the Activity invocation headers.
@@ -27,6 +31,8 @@ class HeadersInjectionInterceptor {
     if ( activityOptionsOverrides ) {
       input.options = deepMerge( input.options ?? {}, activityOptionsOverrides );
     }
+    // Re-enforce framework options after component overrides
+    input.options = enforceActivityOptions( input.options );
     return next( input );
   }
 };
@@ -35,6 +41,15 @@ const sinks = proxySinks();
 
 class WorkflowExecutionInterceptor {
   async execute( input, next ) {
+    const { workflowType, root } = workflowInfo();
+    const traceEnabled = workflowOptionsMap[workflowType]?.disableTrace !== true;
+    const isRoot = !root; // root workflow doesn't have the root block
+
+    upsertMemo( {
+      payloadVersion: '2',
+      ...( isRoot && traceEnabled && { traceInfo: TraceInfo.build() } )
+    } );
+
     sinks.workflow.start( input.args[0] );
     try {
       const output = await next( input );
@@ -51,19 +66,46 @@ class WorkflowExecutionInterceptor {
         throw error;
       }
 
+      /**
+       * We send serialized error to the sink, because temporal loses Error meta-information, like name, type, etc
+       * when crossing the workflow sandbox barrier. The plain object doesn't lose anything.
+       */
+      /**
+       * This happens when the workflow is cancelled.
+       * Re-throw the error as it is.
+       * Sink back the error without stack (not necessary for this).
+       */
       if ( isCancellation( error ) ) {
-        sinks.workflow.error( error );
+        sinks.workflow.error( serializeError( error, { dropKeys: [ 'stack' ] } ) );
         throw error;
       }
 
-      sinks.workflow.error( error );
+      /**
+       * This represents an error in the workflow itself, in this case the sink receives the error serialize with stack
+       * An Application failure is constructed to finish the workflow run and the serialized error is added to its details
+       * so the API or other consumers can read it. Stack is omitted
+       */
+      if ( error instanceof FatalError ) {
+        const unwrappedError = error instanceof TransparentFatalError ? error.cause : error;
+        sinks.workflow.error( serializeError( unwrappedError ) );
+        throw ApplicationFailure.fromError( unwrappedError, {
+          cause: unwrappedError,
+          nonRetryable: true,
+          details: [ { error: serializeError( unwrappedError, { dropKeys: [ 'stack' ] } ) } ]
+        } );
+      };
 
-      /*
-       * Add internal error .details to Temporal's ApplicationFailure .details
-       * This make it possible for this information be retrieved by Temporal's client instance.
-       * Ref: https://typescript.temporal.io/api/classes/common.ApplicationFailure#details
+      /**
+       * This is mostly likely an error in one Activity (or other Temporal parts)
+       * Re-throw as it is and sink back the error without failure, for the same reason as in cancellation.
        */
-      throw error[METADATA_ACCESS_SYMBOL] ? buildApplicationFailureWithDetails( error, error[METADATA_ACCESS_SYMBOL] ) : error;
+      if ( error instanceof TemporalFailure ) {
+        sinks.workflow.error( serializeError( error ) );
+        throw error;
+      }
+
+      // Workflow Task failure, do not sink as this retries the Task only,  not the Workflow
+      throw error;
     }
   }
 };

package/src/worker/interceptors/workflow.spec.js

@@ -1,12 +1,14 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { ApplicationFailure } from '@temporalio/common';
-import { METADATA_ACCESS_SYMBOL } from '#consts';
+import { FatalError, TransparentFatalError, ValidationError } from '#errors';
 
 const workflowInfoMock = vi.fn();
 const workflowStartMock = vi.fn();
 const workflowEndMock = vi.fn();
 const workflowErrorMock = vi.fn();
 const isCancellationMock = vi.fn();
+const upsertMemoMock = vi.fn();
+const traceInfoBuildMock = vi.fn();
 const startTime = new Date( '2026-06-02T09:00:00.000Z' );
 const runStartTime = new Date( '2026-06-02T09:05:00.000Z' );
 const workflowDetails = {
@@ -36,19 +38,26 @@ const workflowInfo = {
   memo: { traceInfo: { runId: 'root-run' } }
 };
 
-vi.mock( '@temporalio/workflow', () => ( {
-  workflowInfo: ( ...args ) => workflowInfoMock( ...args ),
-  proxySinks: () => ( {
-    workflow: { start: workflowStartMock, end: workflowEndMock, error: workflowErrorMock }
-  } ),
-  ContinueAsNew: class ContinueAsNew extends Error {
-    constructor() {
-      super( 'ContinueAsNew' );
-      this.name = 'ContinueAsNew';
-    }
-  },
-  isCancellation: ( ...args ) => isCancellationMock( ...args )
-} ) );
+vi.mock( '@temporalio/workflow', async importOriginal => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    workflowInfo: ( ...args ) => workflowInfoMock( ...args ),
+    proxySinks: () => ( {
+      workflow: { start: workflowStartMock, end: workflowEndMock, error: workflowErrorMock }
+    } ),
+    ContinueAsNew: class ContinueAsNew extends Error {
+      constructor() {
+        super( 'ContinueAsNew' );
+        this.name = 'ContinueAsNew';
+      }
+    },
+    isCancellation: ( ...args ) => isCancellationMock( ...args ),
+    upsertMemo: ( ...args ) => upsertMemoMock( ...args )
+  };
+} );
+
+vi.mock( '#helpers/trace_info', () => ( { TraceInfo: { build: ( ...args ) => traceInfoBuildMock( ...args ) } } ) );
 
 const memoToHeadersMock = vi.fn( memo => ( memo ? { ...memo, __asHeaders: true } : {} ) );
 vi.mock( './headers.js', () => ( { memoToHeaders: ( ...args ) => memoToHeadersMock( ...args ) } ) );
@@ -59,11 +68,17 @@ vi.mock( '#helpers/object', () => ( { deepMerge: ( ...args ) => deepMergeMock( .
 const activityOptionsDefault = {};
 vi.mock( '../temp/__activity_options.js', () => ( { default: activityOptionsDefault } ) );
 
+const workflowOptionsDefault = {};
+vi.mock( '../temp/__workflow_options.js', () => ( { default: workflowOptionsDefault } ) );
+
 describe( 'workflow interceptors', () => {
   beforeEach( () => {
     vi.clearAllMocks();
     Object.keys( activityOptionsDefault ).forEach( key => delete activityOptionsDefault[key] );
+    Object.keys( workflowOptionsDefault ).forEach( key => delete workflowOptionsDefault[key] );
+    workflowOptionsDefault.MyWorkflow = { disableTrace: false };
     isCancellationMock.mockReturnValue( false );
+    traceInfoBuildMock.mockReturnValue( { workflowId: 'workflow-1', runId: 'run-1' } );
     workflowInfoMock.mockReturnValue( workflowInfo );
   } );
 
@@ -72,7 +87,7 @@ describe( 'workflow interceptors', () => {
       const { interceptors } = await import( './workflow.js' );
       const { outbound } = interceptors();
       const interceptor = outbound[0];
-      const input = { headers: { existing: 'header' }, activityType: 'MyWorkflow#step1' };
+      const input = { headers: { existing: 'header' }, activityType: 'MyWorkflow#step1', options: {} };
       const next = vi.fn().mockResolvedValue( 'result' );
 
       memoToHeadersMock.mockReturnValue( { traceInfo: workflowInfo.memo.traceInfo, workflowDetails } );
@@ -99,7 +114,11 @@ describe( 'workflow interceptors', () => {
         memo: { traceInfo: workflowInfo.memo.traceInfo }
       } );
       memoToHeadersMock.mockReturnValue( {} );
-      deepMergeMock.mockReturnValue( { heartbeatTimeout: 10, scheduleToCloseTimeout: 60 } );
+      deepMergeMock.mockReturnValue( {
+        heartbeatTimeout: 10,
+        scheduleToCloseTimeout: 60,
+        retry: { maximumAttempts: 2, nonRetryableErrorTypes: [ 'StepError' ] }
+      } );
 
       const { interceptors } = await import( './workflow.js' );
       const { outbound } = interceptors();
@@ -110,11 +129,79 @@ describe( 'workflow interceptors', () => {
       await interceptor.scheduleActivity( input, next );
 
       expect( deepMergeMock ).toHaveBeenCalledWith( { heartbeatTimeout: 10 }, { scheduleToCloseTimeout: 60 } );
-      expect( input.options ).toEqual( { heartbeatTimeout: 10, scheduleToCloseTimeout: 60 } );
+      expect( input.options ).toEqual( {
+        heartbeatTimeout: 10,
+        scheduleToCloseTimeout: 60,
+        retry: {
+          maximumAttempts: 2,
+          nonRetryableErrorTypes: [ 'StepError', 'FatalError' ]
+        }
+      } );
+    } );
+
+    it( 'adds FatalError to activity retry options without duplicates', async () => {
+      const { interceptors } = await import( './workflow.js' );
+      const { outbound } = interceptors();
+      const interceptor = outbound[0];
+      const input = {
+        headers: {},
+        activityType: 'MyWorkflow#step1',
+        options: {
+          retry: {
+            maximumAttempts: 4,
+            nonRetryableErrorTypes: [ 'DomainError', 'FatalError' ]
+          }
+        }
+      };
+      const next = vi.fn().mockResolvedValue( undefined );
+
+      await interceptor.scheduleActivity( input, next );
+
+      expect( input.options.retry ).toEqual( {
+        maximumAttempts: 4,
+        nonRetryableErrorTypes: [ 'DomainError', 'FatalError' ]
+      } );
     } );
   } );
 
   describe( 'WorkflowExecutionInterceptor', () => {
+    it( 'upserts root trace info before starting the workflow trace', async () => {
+      const { interceptors } = await import( './workflow.js' );
+      const { inbound } = interceptors();
+      const traceInfo = { workflowId: 'workflow-1', runId: 'run-1' };
+      traceInfoBuildMock.mockReturnValue( traceInfo );
+
+      await inbound[0].execute( { args: [ {} ] }, vi.fn().mockResolvedValue( undefined ) );
+
+      expect( traceInfoBuildMock ).toHaveBeenCalledOnce();
+      expect( upsertMemoMock ).toHaveBeenCalledWith( { payloadVersion: '2', traceInfo } );
+      expect( upsertMemoMock.mock.invocationCallOrder[0] ).toBeLessThan( workflowStartMock.mock.invocationCallOrder[0] );
+    } );
+
+    it.each( [
+      {
+        name: 'tracing is disabled',
+        info: workflowInfo,
+        options: { disableTrace: true }
+      },
+      {
+        name: 'the workflow has a root',
+        info: { ...workflowInfo, root: { workflowId: 'root-workflow', runId: 'root-run' } },
+        options: { disableTrace: false }
+      }
+    ] )( 'does not build trace info when $name', async ( { info, options } ) => {
+      workflowInfoMock.mockReturnValue( info );
+      workflowOptionsDefault.MyWorkflow = options;
+      const { interceptors } = await import( './workflow.js' );
+      const { inbound } = interceptors();
+
+      await inbound[0].execute( { args: [ {} ] }, vi.fn().mockResolvedValue( undefined ) );
+
+      expect( traceInfoBuildMock ).not.toHaveBeenCalled();
+      expect( upsertMemoMock ).toHaveBeenCalledOnce();
+      expect( upsertMemoMock ).toHaveBeenCalledWith( { payloadVersion: '2' } );
+    } );
+
     it( 'calls sinks.workflow.start, next, then sinks.workflow.end on success', async () => {
       const { interceptors } = await import( './workflow.js' );
       const { inbound } = interceptors();
@@ -131,7 +218,7 @@ describe( 'workflow interceptors', () => {
       expect( workflowErrorMock ).not.toHaveBeenCalled();
     } );
 
-    it( 'calls sinks.workflow.error and rethrows workflow errors', async () => {
+    it( 'rethrows native errors as Workflow Task failures without a terminal sink event', async () => {
       const { interceptors } = await import( './workflow.js' );
       const { inbound } = interceptors();
       const interceptor = inbound[0];
@@ -141,17 +228,19 @@ describe( 'workflow interceptors', () => {
 
       await expect( interceptor.execute( input, next ) ).rejects.toBe( err );
       expect( workflowStartMock ).toHaveBeenCalled();
-      expect( workflowErrorMock ).toHaveBeenCalledWith( err );
+      expect( workflowErrorMock ).not.toHaveBeenCalled();
       expect( workflowEndMock ).not.toHaveBeenCalled();
     } );
 
-    it( 'wraps workflow errors with metadata in ApplicationFailure details', async () => {
+    it.each( [
+      { ErrorType: FatalError, type: 'FatalError' },
+      { ErrorType: ValidationError, type: 'ValidationError' }
+    ] )( 'converts $type into a non-retryable ApplicationFailure with serialized details', async ( { ErrorType, type } ) => {
       const { interceptors } = await import( './workflow.js' );
       const { inbound } = interceptors();
       const interceptor = inbound[0];
-      const trace = { trace: { destinations: { local: '/tmp/trace' } } };
-      const err = new Error( 'workflow failed' );
-      err[METADATA_ACCESS_SYMBOL] = trace;
+      const err = new ErrorType( 'workflow failed' );
+      err.code = 'EWORKFLOW';
       const next = vi.fn().mockRejectedValue( err );
 
       const thrown = await interceptor.execute( { args: [ {} ] }, next ).catch( e => e );
@@ -159,44 +248,78 @@ describe( 'workflow interceptors', () => {
       expect( thrown ).toBeInstanceOf( ApplicationFailure );
       expect( thrown ).toMatchObject( {
         message: 'workflow failed',
-        type: 'Error',
-        details: [ trace ],
+        type,
+        nonRetryable: true,
+        details: [ {
+          error: {
+            name: type,
+            message: 'workflow failed',
+            code: 'EWORKFLOW'
+          }
+        } ],
         cause: err
       } );
-      expect( workflowErrorMock ).toHaveBeenCalledWith( err );
+      expect( workflowErrorMock ).toHaveBeenCalledWith( expect.objectContaining( {
+        name: type,
+        message: 'workflow failed',
+        code: 'EWORKFLOW',
+        stack: expect.any( String )
+      } ) );
+      expect( workflowErrorMock.mock.calls[0][0] ).not.toBeInstanceOf( Error );
       expect( workflowEndMock ).not.toHaveBeenCalled();
     } );
 
-    it( 'preserves ApplicationFailure metadata when wrapping workflow errors with details', async () => {
+    it( 'uses a transparent error cause for the sink and ApplicationFailure', async () => {
       const { interceptors } = await import( './workflow.js' );
       const { inbound } = interceptors();
       const interceptor = inbound[0];
-      const trace = { trace: { destinations: { local: '/tmp/trace' } } };
-      const err = ApplicationFailure.create( {
-        message: 'domain failed',
-        type: 'DomainFailure',
-        nonRetryable: true,
-        details: [ { domain: { reason: 'bad-input' } } ]
-      } );
-      err[METADATA_ACCESS_SYMBOL] = trace;
-      const next = vi.fn().mockRejectedValue( err );
+      const cause = new TypeError( 'provider rejected request' );
+      cause.code = 'EAUTH';
+      const error = new TransparentFatalError( cause );
+      const next = vi.fn().mockRejectedValue( error );
 
       const thrown = await interceptor.execute( { args: [ {} ] }, next ).catch( e => e );
 
-      expect( thrown ).toBeInstanceOf( ApplicationFailure );
-      expect( thrown ).not.toBe( err );
-      expect( thrown.cause ).toBe( err );
-      expect( thrown.cause ).not.toBe( thrown );
       expect( thrown ).toMatchObject( {
-        message: 'domain failed',
-        type: 'DomainFailure',
+        message: 'provider rejected request',
+        type: 'TypeError',
         nonRetryable: true,
-        details: [
-          { domain: { reason: 'bad-input' } },
-          trace
-        ]
+        cause,
+        details: [ {
+          error: {
+            name: 'TypeError',
+            message: 'provider rejected request',
+            code: 'EAUTH'
+          }
+        } ]
       } );
-      expect( workflowErrorMock ).toHaveBeenCalledWith( err );
+      expect( workflowErrorMock ).toHaveBeenCalledWith( expect.objectContaining( {
+        name: 'TypeError',
+        message: 'provider rejected request',
+        code: 'EAUTH',
+        stack: expect.any( String )
+      } ) );
+      expect( workflowErrorMock.mock.calls[0][0] ).not.toHaveProperty( 'cause' );
+      expect( workflowEndMock ).not.toHaveBeenCalled();
+    } );
+
+    it( 'sinks and rethrows existing Temporal failures unchanged', async () => {
+      const { interceptors } = await import( './workflow.js' );
+      const { inbound } = interceptors();
+      const interceptor = inbound[0];
+      const err = ApplicationFailure.retryable( 'domain failed', 'DomainFailure', { reason: 'invalid' } );
+      const next = vi.fn().mockRejectedValue( err );
+
+      await expect( interceptor.execute( { args: [ {} ] }, next ) ).rejects.toBe( err );
+      expect( workflowErrorMock ).toHaveBeenCalledWith( expect.objectContaining( {
+        name: 'ApplicationFailure',
+        message: 'domain failed',
+        type: 'DomainFailure',
+        details: [ { reason: 'invalid' } ],
+        stack: expect.any( String )
+      } ) );
+      expect( workflowErrorMock.mock.calls[0][0] ).not.toBeInstanceOf( Error );
+      expect( workflowEndMock ).not.toHaveBeenCalled();
     } );
 
     it( 'calls sinks.workflow.error and rethrows cancellation errors without wrapping', async () => {
@@ -209,11 +332,15 @@ describe( 'workflow interceptors', () => {
 
       await expect( interceptor.execute( { args: [ {} ] }, next ) ).rejects.toBe( cancellation );
       expect( isCancellationMock ).toHaveBeenCalledWith( cancellation );
-      expect( workflowErrorMock ).toHaveBeenCalledWith( cancellation );
+      expect( workflowErrorMock ).toHaveBeenCalledWith( {
+        name: 'Error',
+        message: 'Workflow cancelled'
+      } );
+      expect( workflowErrorMock.mock.calls[0][0] ).not.toBeInstanceOf( Error );
       expect( workflowEndMock ).not.toHaveBeenCalled();
     } );
 
-    it( 'on ContinueAsNew calls sinks.trace.addWorkflowEventEnd and rethrows', async () => {
+    it( 'ends the workflow trace and rethrows ContinueAsNew', async () => {
       const { ContinueAsNew } = await import( '@temporalio/workflow' );
       const { WorkflowSpecialOutput } = await import( '#consts' );
       const { interceptors } = await import( './workflow.js' );

package/src/worker/loader/workflows.js

@@ -1,7 +1,7 @@
 import { EOL } from 'node:os';
 import { writeFileInTempDir, findWorkflowsInNodeModules, importComponents, matchFiles } from './tools.js';
 import { staticMatchers } from './matchers.js';
-import { WORKFLOWS_INDEX_FILENAME, WORKFLOW_CATALOG } from '#consts';
+import { WORKFLOWS_INDEX_FILENAME, WORKFLOW_CATALOG, WORKFLOW_OPTIONS_FILENAME } from '#consts';
 import { createChildLogger } from '#logger';
 import { ValidationError } from '#errors';
 
@@ -38,6 +38,7 @@ const createWorkflowsEntrypoint = workflows => {
  * @typedef LoadWorkflowsResult
  * @property {Workflow[]} workflows - Loaded workflows
  * @property {string} entrypoint - Index file loading all workflows
+ * @property {string} optionsFile - File exporting options for each workflow and their aliases
  */
 /**
  * Scan and find workflow.js files and import them.
@@ -47,6 +48,8 @@ const createWorkflowsEntrypoint = workflows => {
  */
 export async function loadWorkflows( rootDir ) {
   const workflowNames = new Set();
+  const workflowOptions = new Map();
+
   const workflows = [];
   const localWorkflows = matchFiles( rootDir, [ staticMatchers.workflowFile ] );
   const externalWorkflows = findWorkflowsInNodeModules( rootDir );
@@ -55,7 +58,7 @@ export async function loadWorkflows( rootDir ) {
     if ( staticMatchers.workflowPathHasShared( path ) ) {
       throw new ValidationError( 'Workflow directory can\'t be named "shared"' );
     }
-    const { name, aliases } = metadata;
+    const { name, aliases, options } = metadata;
     if ( workflowNames.has( name ) ) {
       throw new ValidationError( `Workflow name "${name}" conflicts with another workflow or alias. \
 Workflow names and aliases must be unique.` );
@@ -64,6 +67,8 @@ Workflow names and aliases must be unique.` );
       throw new ValidationError( `Workflow name "${name}" is reserved for the internal catalog workflow.` );
     }
     workflowNames.add( name );
+    workflowOptions.set( name, { disableTrace: options?.disableTrace ?? false } );
+
     for ( const alias of aliases ?? [] ) {
       if ( workflowNames.has( alias ) ) {
         throw new ValidationError( `Workflow "${name}" alias "${alias}" conflicts with another workflow or alias. \
@@ -73,10 +78,18 @@ Workflow names and aliases must be unique.` );
         throw new ValidationError( `Workflow "${name}" alias "${alias}" is reserved for the internal catalog workflow.` );
       }
       workflowNames.add( alias );
+      workflowOptions.set( alias, { disableTrace: options?.disableTrace ?? false } );
     }
 
     log.info( name, { path, aliases, ...( external && { external } ) } );
     workflows.push( { ...metadata, path, external } );
   }
-  return { workflows, entrypoint: createWorkflowsEntrypoint( workflows ) };
+
+  workflowOptions.set( WORKFLOW_CATALOG, { disableTrace: true } );
+
+  // writes down the static workflow options, currently only disable trace
+  const optionsContent = `export default ${JSON.stringify( Object.fromEntries( workflowOptions ), undefined, 2 )};`;
+  const optionsFile = writeFileInTempDir( optionsContent, WORKFLOW_OPTIONS_FILENAME );
+
+  return { workflows, entrypoint: createWorkflowsEntrypoint( workflows ), optionsFile };
 };

package/src/worker/loader/workflows.spec.js

@@ -5,7 +5,8 @@ vi.mock( '#consts', () => ( {
   ACTIVITY_GET_TRACE_DESTINATIONS: '__internal#getTraceDestinations',
   WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
   WORKFLOW_CATALOG: 'catalog',
-  ACTIVITY_OPTIONS_FILENAME: '__activity_options.js'
+  ACTIVITY_OPTIONS_FILENAME: '__activity_options.js',
+  WORKFLOW_OPTIONS_FILENAME: '__workflow_options.js'
 } ) );
 
 const { importComponentsMock, findWorkflowsInNodeModulesMock, matchFilesMock, writeFileInTempDirMock } = vi.hoisted( () => ( {
@@ -44,7 +45,7 @@ describe( 'loadWorkflows', () => {
     matchFilesMock.mockReset();
     matchFilesMock.mockReturnValue( [] );
     writeFileInTempDirMock.mockReset();
-    writeFileInTempDirMock.mockReturnValue( '/tmp/__workflows_entrypoint.js' );
+    writeFileInTempDirMock.mockImplementation( ( _, filename ) => `/tmp/${filename}` );
     workflowPathHasSharedMock.mockReset();
     workflowPathHasSharedMock.mockReturnValue( false );
   } );
@@ -58,9 +59,10 @@ describe( 'loadWorkflows', () => {
       yield { metadata: { name: 'Flow1', description: 'd' }, path: '/b/workflow.js' };
     } );
 
-    const { workflows, entrypoint } = await loadWorkflows( '/root' );
+    const { workflows, entrypoint, optionsFile } = await loadWorkflows( '/root' );
     expect( workflows ).toEqual( [ { name: 'Flow1', description: 'd', path: '/b/workflow.js', external: false } ] );
     expect( entrypoint ).toBe( '/tmp/__workflows_entrypoint.js' );
+    expect( optionsFile ).toBe( '/tmp/__workflow_options.js' );
     expect( importComponentsMock ).toHaveBeenNthCalledWith( 1, localFiles );
     expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledOnce();
     expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledWith( '/root' );
@@ -244,12 +246,42 @@ describe( 'loadWorkflows', () => {
     const { entrypoint } = await loadWorkflows( '/root' );
 
     expect( entrypoint ).toBe( '/tmp/__workflows_entrypoint.js' );
-    expect( writeFileInTempDirMock ).toHaveBeenCalledTimes( 1 );
-    const [ contents, filename ] = writeFileInTempDirMock.mock.calls[0];
+    expect( writeFileInTempDirMock ).toHaveBeenCalledTimes( 2 );
+    const [ contents, filename ] = writeFileInTempDirMock.mock.calls.find( ( [ , calledFilename ] ) =>
+      calledFilename === '__workflows_entrypoint.js'
+    );
     expect( filename ).toBe( '__workflows_entrypoint.js' );
     expect( contents ).toContain( 'export { default as W } from \'/abs/wf.js\';' );
     expect( contents ).toContain( 'export { default as W_old } from \'/abs/wf.js\';' );
     expect( contents ).toContain( 'export { default as W_legacy } from \'/abs/wf.js\';' );
     expect( contents ).toContain( 'export { default as catalog }' );
   } );
+
+  it( 'writes trace options for workflow names, aliases, and the catalog workflow', async () => {
+    const { loadWorkflows } = await import( './workflows.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield {
+        metadata: { name: 'Traced', aliases: [ 'Traced_old' ] },
+        path: '/abs/traced.js'
+      };
+      yield {
+        metadata: { name: 'Untraced', aliases: [ 'Untraced_old' ], options: { disableTrace: true } },
+        path: '/abs/untraced.js'
+      };
+    } );
+
+    await loadWorkflows( '/root' );
+
+    const [ contents, filename ] = writeFileInTempDirMock.mock.calls.find( ( [ , calledFilename ] ) =>
+      calledFilename === '__workflow_options.js'
+    );
+    expect( filename ).toBe( '__workflow_options.js' );
+    expect( contents ).toBe( `export default ${JSON.stringify( {
+      Traced: { disableTrace: false },
+      Traced_old: { disableTrace: false },
+      Untraced: { disableTrace: true },
+      Untraced_old: { disableTrace: true },
+      catalog: { disableTrace: true }
+    }, undefined, 2 )};` );
+  } );
 } );

package/src/worker/log_hooks.js

@@ -1,6 +1,7 @@
 import { mainEventBus } from '#bus';
 import { createChildLogger } from '#logger';
 import { ACTIVITY_GET_TRACE_DESTINATIONS, BusEventType, LifecycleEvent, WORKFLOW_CATALOG } from '#consts';
+import { serializeError } from '#helpers/error_serializer';
 
 const activityLog = createChildLogger( 'Activity' );
 const workflowLog = createChildLogger( 'Workflow' );
@@ -40,11 +41,12 @@ mainEventBus.on( BusEventType.ACTIVITY_END, ( { activityInfo, outputActivityKind
 );
 
 mainEventBus.on( BusEventType.ACTIVITY_ERROR, ( { activityInfo, outputActivityKind, error } ) =>
-  shouldLogActivity( activityInfo ) && activityLog.error( `Error ${activityInfo.activityType} ${outputActivityKind}: ${error.constructor.name}`, {
-    event: LifecycleEvent.ERROR,
-    ...serializedActivityFields( activityInfo ),
-    error: error.message
-  } )
+  shouldLogActivity( activityInfo ) &&
+    activityLog.error( `Error ${activityInfo.activityType} ${outputActivityKind}: ${error.name ?? error.constructor.name}`, {
+      event: LifecycleEvent.ERROR,
+      ...serializedActivityFields( activityInfo ),
+      error: serializeError( error, { dropKeys: [ 'stack' ] } )
+    } )
 );
 
 mainEventBus.on( BusEventType.ACTIVITY_LOG, ( { level, message, metadata, activityInfo } ) =>
@@ -83,11 +85,12 @@ mainEventBus.on( BusEventType.WORKFLOW_END, ( { workflowDetails } ) =>
 );
 
 mainEventBus.on( BusEventType.WORKFLOW_ERROR, ( { workflowDetails, error } ) =>
-  shouldLogWorkflow( workflowDetails ) && workflowLog.error( `Error ${workflowDetails.workflowType} workflow: ${error.constructor.name}`, {
-    event: LifecycleEvent.ERROR,
-    ...serializeWorkflowFields( workflowDetails ),
-    error: error.message
-  } )
+  shouldLogWorkflow( workflowDetails ) &&
+    workflowLog.error( `Error ${workflowDetails.workflowType} workflow: ${error.name ?? error.constructor.name}`, {
+      event: LifecycleEvent.ERROR,
+      ...serializeWorkflowFields( workflowDetails ),
+      error: serializeError( error, { dropKeys: [ 'stack' ] } )
+    } )
 );
 
 mainEventBus.on( BusEventType.WORKFLOW_LOG, ( { level, message, metadata, workflowDetails } ) =>