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

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 } ) =>

package/src/worker/log_hooks.spec.js

@@ -27,9 +27,14 @@ const mainEventBusMock = vi.hoisted( () => ( {
     onHandlers[eventType] = handler;
   } )
 } ) );
+const serializeErrorMock = vi.hoisted( () => vi.fn( error => ( {
+  name: error.name,
+  message: error.message
+} ) ) );
 
 vi.mock( '#logger', () => ( { createChildLogger: createChildLoggerMock } ) );
 vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
+vi.mock( '#helpers/error_serializer', () => ( { serializeError: serializeErrorMock } ) );
 
 import './log_hooks.js';
 
@@ -104,6 +109,7 @@ describe( 'log_hooks', () => {
 
     it( 'ACTIVITY_ERROR logs full message and second arg', () => {
       const err = new Error( 'step failed' );
+      err.name = 'ProviderError';
       onHandlers[BusEventType.ACTIVITY_ERROR]( {
         ...basePayload,
         duration: 100,
@@ -112,7 +118,7 @@ describe( 'log_hooks', () => {
 
       expect( activityLogMock.error ).toHaveBeenCalledTimes( 1 );
       expect( activityLogMock.error ).toHaveBeenCalledWith(
-        'Error myWorkflow#myStep step: Error',
+        'Error myWorkflow#myStep step: ProviderError',
         {
           event: LifecycleEvent.ERROR,
           activityId: 'act-1',
@@ -120,9 +126,10 @@ describe( 'log_hooks', () => {
           workflowId: 'wf-1',
           workflowType: 'myWorkflow',
           runId: 'run-1',
-          error: 'step failed'
+          error: { name: 'ProviderError', message: 'step failed' }
         }
       );
+      expect( serializeErrorMock ).toHaveBeenCalledWith( err, { dropKeys: [ 'stack' ] } );
     } );
 
     it( 'ACTIVITY_ERROR does not log trace destination activity', () => {
@@ -229,7 +236,7 @@ describe( 'log_hooks', () => {
     } );
 
     it( 'WORKFLOW_ERROR logs full message and second arg', () => {
-      const err = new TypeError( 'workflow boom' );
+      const err = { name: 'TypeError', message: 'workflow boom' };
       onHandlers[BusEventType.WORKFLOW_ERROR]( {
         ...basePayload,
         duration: 150,
@@ -244,9 +251,10 @@ describe( 'log_hooks', () => {
           workflowId: 'wf-1',
           workflowType: 'myWorkflow',
           runId: 'run-1',
-          error: 'workflow boom'
+          error: { name: 'TypeError', message: 'workflow boom' }
         }
       );
+      expect( serializeErrorMock ).toHaveBeenCalledWith( err, { dropKeys: [ 'stack' ] } );
     } );
 
     it( 'WORKFLOW_ERROR does not log when workflowType is WORKFLOW_CATALOG', () => {

package/src/worker/sinks.js

@@ -2,6 +2,7 @@ import { BusEventType, ComponentType } from '#consts';
 import * as Tracing from '#tracing';
 import { mainEventBus } from '#bus';
 import { createWorkflowDetails } from '#helpers/temporal_context';
+import { rehydrateError } from '#helpers/errors';
 
 // This sink allow for sandbox Temporal environment to send trace logs back to the main thread.
 export const sinks = {
@@ -48,7 +49,8 @@ export const sinks = {
     error: {
       fn: ( workflowInfo, error ) => {
         const { runId, memo: { traceInfo } } = workflowInfo;
-        mainEventBus.emit( BusEventType.WORKFLOW_ERROR, { workflowDetails: createWorkflowDetails( workflowInfo ), error } );
+        // re-hydrate workflow error
+        mainEventBus.emit( BusEventType.WORKFLOW_ERROR, { workflowDetails: createWorkflowDetails( workflowInfo ), error: rehydrateError( error ) } );
         if ( traceInfo ) {
           Tracing.addEventError( { id: runId, details: error, traceInfo } );
         }

package/src/worker/sinks.spec.js

@@ -15,6 +15,8 @@ const createWorkflowDetailsMock = vi.hoisted( () => vi.fn( workflowInfo => ( {
   runId: workflowInfo.runId
 } ) ) );
 
+const rehydrateErrorMock = vi.hoisted( () => vi.fn( error => error ) );
+
 vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
 vi.mock( '#tracing', () => ( {
   addEventStart: addEventStartMock,
@@ -24,6 +26,9 @@ vi.mock( '#tracing', () => ( {
 vi.mock( '#helpers/temporal_context', () => ( {
   createWorkflowDetails: createWorkflowDetailsMock
 } ) );
+vi.mock( '#helpers/errors', () => ( {
+  rehydrateError: rehydrateErrorMock
+} ) );
 
 describe( 'worker/sinks', () => {
   const workflowInfo = {
@@ -128,11 +133,17 @@ describe( 'worker/sinks', () => {
 
   it( 'workflow.error emits workflow error events and trace error events', async () => {
     const { sinks } = await import( './sinks.js' );
-    const error = new Error( 'workflow failed' );
+    const error = { name: 'Error', message: 'workflow failed' };
+    const rehydrated = new Error( 'workflow failed' );
+    rehydrateErrorMock.mockReturnValueOnce( rehydrated );
 
     sinks.workflow.error.fn( workflowInfo, error );
 
-    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, { workflowDetails, error } );
+    expect( rehydrateErrorMock ).toHaveBeenCalledWith( error );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith(
+      BusEventType.WORKFLOW_ERROR,
+      { workflowDetails, error: rehydrated }
+    );
     expect( addEventErrorMock ).toHaveBeenCalledWith( {
       id: 'run-1',
       details: error,
@@ -142,11 +153,17 @@ describe( 'worker/sinks', () => {
 
   it( 'workflow.error skips tracing when trace info is absent', async () => {
     const { sinks } = await import( './sinks.js' );
-    const error = new Error( 'workflow failed' );
+    const error = { name: 'Error', message: 'workflow failed' };
+    const rehydrated = new Error( 'workflow failed' );
+    rehydrateErrorMock.mockReturnValueOnce( rehydrated );
 
     sinks.workflow.error.fn( { ...workflowInfo, memo: {} }, error );
 
-    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, { workflowDetails, error } );
+    expect( rehydrateErrorMock ).toHaveBeenCalledWith( error );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith(
+      BusEventType.WORKFLOW_ERROR,
+      { workflowDetails, error: rehydrated }
+    );
     expect( addEventErrorMock ).not.toHaveBeenCalled();
   } );