@outputai/core 0.10.1-next.b7b2fbe.0 → 0.10.1-next.bf95a6f.0

package/src/tracing/trace_engine.spec.js

@@ -5,10 +5,15 @@ vi.mock( '#async_storage', () => ( {
   Storage: { load: storageLoadMock }
 } ) );
 
-const logWarnMock = vi.fn();
+const serializeErrorMock = vi.fn( error => ( {
+  name: error.name,
+  message: error.message
+} ) );
+vi.mock( '#helpers/error_serializer', () => ( { serializeError: serializeErrorMock } ) );
+
 const logErrorMock = vi.fn();
 vi.mock( '#logger', () => ( {
-  createChildLogger: () => ( { warn: logWarnMock, error: logErrorMock } )
+  createChildLogger: () => ( { error: logErrorMock } )
 } ) );
 
 const localInitMock = vi.fn( async () => {} );
@@ -71,6 +76,24 @@ describe( 'tracing/trace_engine', () => {
     expect( payload.traceInfo ).toBe( traceInfo );
   } );
 
+  it( 'init() logs processor failures with serialized stacks', async () => {
+    process.env.OUTPUT_TRACE_LOCAL_ON = '1';
+    const processorError = new Error( 'processor failed' );
+    localExecMock.mockRejectedValueOnce( processorError );
+    const { init, addEventAction } = await loadTraceEngine();
+    await init();
+
+    addEventAction( 'start', {
+      kind: 'step', name: 'N', id: '1', parentId: 'p', details: null, traceInfo
+    } );
+
+    await vi.waitFor( () => expect( logErrorMock ).toHaveBeenCalledWith( 'Processor execution error', {
+      processor: 'LOCAL',
+      error: { name: 'Error', message: 'processor failed' }
+    } ) );
+    expect( serializeErrorMock ).toHaveBeenCalledWith( processorError );
+  } );
+
   it( 'addEventAction() emits an entry consumed by processors', async () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = 'on';
     const { init, addEventAction } = await loadTraceEngine();
@@ -87,34 +110,34 @@ describe( 'tracing/trace_engine', () => {
     expect( payload.entry.details ).toBe( 'done' );
   } );
 
-  it( 'addEventAction() does not emit when traceInfo is absent', async () => {
-    process.env.OUTPUT_TRACE_LOCAL_ON = '1';
+  it( 'addEventAction() serializes error details before emitting', async () => {
+    process.env.OUTPUT_TRACE_LOCAL_ON = 'on';
     const { init, addEventAction } = await loadTraceEngine();
     await init();
+    const error = new TypeError( 'step failed' );
 
-    addEventAction( 'start', {
-      kind: 'step', name: 'X', id: '1', parentId: 'p', details: {},
-      traceInfo: undefined
+    addEventAction( 'error', {
+      kind: 'step', name: 'S', id: '3', parentId: 'p3', details: error,
+      traceInfo
+    } );
+
+    expect( serializeErrorMock ).toHaveBeenCalledWith( error );
+    expect( localExecMock.mock.calls[0][0].entry.details ).toEqual( {
+      name: 'TypeError',
+      message: 'step failed'
     } );
-    expect( localExecMock ).not.toHaveBeenCalled();
   } );
 
-  it( 'addEventAction() emits when kind is INTERNAL_STEP', async () => {
+  it( 'addEventAction() does not emit when traceInfo is absent', async () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = '1';
     const { init, addEventAction } = await loadTraceEngine();
     await init();
 
     addEventAction( 'start', {
-      kind: 'internal_step', name: 'Internal', id: '1', parentId: 'p', details: {},
-      traceInfo
-    } );
-    expect( localExecMock ).toHaveBeenCalledTimes( 1 );
-    expect( localExecMock.mock.calls[0][0].entry ).toMatchObject( {
-      kind: 'internal_step',
-      name: 'Internal',
-      id: '1',
-      parentId: 'p'
+      kind: 'step', name: 'X', id: '1', parentId: 'p', details: {},
+      traceInfo: undefined
     } );
+    expect( localExecMock ).not.toHaveBeenCalled();
   } );
 
   it( 'addEventActionWithContext() uses storage when available', async () => {
@@ -135,13 +158,34 @@ describe( 'tracing/trace_engine', () => {
     expect( payload.entry.action ).toBe( 'tick' );
   } );
 
-  it( 'addEventActionWithContext() records ADD_ATTR attributes through storage context', async () => {
+  it( 'addEventActionWithContext() unwraps transparent errors without mutating options', async () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = 'true';
-    const addAttributeMock = vi.fn();
     storageLoadMock.mockReturnValue( {
       parentId: 'ctx-p',
-      traceInfo,
-      addAttribute: addAttributeMock
+      traceInfo
+    } );
+    const { init, addEventActionWithContext } = await loadTraceEngine();
+    const { TransparentFatalError } = await import( '#errors' );
+    await init();
+
+    const cause = new TypeError( 'provider rejected request' );
+    const error = new TransparentFatalError( cause );
+    const options = { kind: 'llm', name: 'generate', id: 'llm-1', details: error };
+    addEventActionWithContext( 'error', options );
+
+    expect( options.details ).toBe( error );
+    expect( serializeErrorMock ).toHaveBeenCalledWith( cause );
+    expect( localExecMock.mock.calls[0][0].entry.details ).toEqual( {
+      name: 'TypeError',
+      message: 'provider rejected request'
+    } );
+  } );
+
+  it( 'addEventActionWithContext() emits validated ADD_ATTR trace entries', async () => {
+    process.env.OUTPUT_TRACE_LOCAL_ON = 'true';
+    storageLoadMock.mockReturnValue( {
+      parentId: 'ctx-p',
+      traceInfo
     } );
     const { init, addEventActionWithContext } = await loadTraceEngine();
     const { EventAction } = await import( './trace_consts.js' );
@@ -151,8 +195,6 @@ describe( 'tracing/trace_engine', () => {
     const attribute = new Attribute.HTTPRequestCount( 'https://example.test', 'req-1' );
     addEventActionWithContext( EventAction.ADD_ATTR, { kind: 'http', name: 'request', id: 'req-1', details: attribute } );
 
-    expect( addAttributeMock ).toHaveBeenCalledTimes( 1 );
-    expect( addAttributeMock ).toHaveBeenCalledWith( attribute );
     expect( localExecMock ).toHaveBeenCalledTimes( 1 );
     expect( localExecMock.mock.calls[0][0] ).toEqual( {
       traceInfo,
@@ -170,11 +212,9 @@ describe( 'tracing/trace_engine', () => {
 
   it( 'addEventActionWithContext() throws on invalid ADD_ATTR signal payloads', async () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = 'true';
-    const addAttributeMock = vi.fn();
     storageLoadMock.mockReturnValue( {
       parentId: 'ctx-p',
-      traceInfo,
-      addAttribute: addAttributeMock
+      traceInfo
     } );
     const { init, addEventActionWithContext } = await loadTraceEngine();
     const { EventAction } = await import( './trace_consts.js' );
@@ -186,7 +226,6 @@ describe( 'tracing/trace_engine', () => {
       { kind: 'http', name: 'request', id: 'req-1', details: invalidAttribute }
     ) ).toThrow( /not a BaseAttribute instance/ );
 
-    expect( addAttributeMock ).not.toHaveBeenCalled();
     expect( localExecMock ).not.toHaveBeenCalled();
   } );
 

package/src/worker/catalog_workflow/catalog_job.js

@@ -38,7 +38,7 @@ export class CatalogJob {
         throw e;
       }
       if ( !( e instanceof WorkflowNotFoundError ) ) {
-        log.warn( 'Error describing catalog workflow', { error: e } );
+        log.warn( 'Error describing catalog workflow', { error: e.message } );
       }
       return false;
     } );
@@ -52,7 +52,7 @@ export class CatalogJob {
         throw e;
       }
       if ( !( e instanceof WorkflowNotFoundError ) ) {
-        log.warn( 'Error describing catalog workflow', { error: e } );
+        log.warn( 'Error describing catalog workflow', { error: e.message } );
       }
       return false;
     } );
@@ -66,7 +66,7 @@ export class CatalogJob {
         throw e;
       }
       if ( !( e instanceof WorkflowNotFoundError ) ) {
-        log.warn( 'Error completing previous catalog workflow', { error: e } );
+        log.warn( 'Error completing previous catalog workflow', { error: e.message } );
       }
     } );
   };

package/src/worker/catalog_workflow/catalog_job.spec.js

@@ -121,7 +121,7 @@ describe( 'CatalogJob', () => {
 
     await job.run();
 
-    expect( mockLog.warn ).toHaveBeenCalledWith( 'Error completing previous catalog workflow', { error: completeError } );
+    expect( mockLog.warn ).toHaveBeenCalledWith( 'Error completing previous catalog workflow', { error: completeError.message } );
     expect( workflowStartMock ).toHaveBeenCalledWith( 'catalog', expect.any( Object ) );
     expect( job.error ).toBeNull();
   } );

package/src/worker/configs.js

@@ -36,8 +36,6 @@ const envVarSchema = z.object( {
   OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 2 * 60 * 1000 ) ), // 2min
   // Whether to send activity heartbeats (enabled by default)
   OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: z.transform( v => v === undefined ? true : isStringboolTrue( v ) ),
-  // Time to allow for hooks to flush before shutdown
-  OUTPUT_PROCESS_FAILURE_SHUTDOWN_DELAY: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 3000 ) ),
   // Set temporal worker shutdown force time
   TEMPORAL_SHUTDOWN_FORCE_TIME: durationSchema,
   // Set temporal worker shutdown grace time
@@ -70,7 +68,6 @@ export const catalogId = envVars.OUTPUT_CATALOG_ID;
 export const workerTelemetryIntervalMs = envVars.OUTPUT_WORKER_TELEMETRY_INTERVAL_MS;
 export const activityHeartbeatIntervalMs = envVars.OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS;
 export const activityHeartbeatEnabled = envVars.OUTPUT_ACTIVITY_HEARTBEAT_ENABLED;
-export const processFailureShutdownDelay = envVars.OUTPUT_PROCESS_FAILURE_SHUTDOWN_DELAY;
 export const shutdownForceTime = envVars.TEMPORAL_SHUTDOWN_FORCE_TIME;
 export const shutdownGraceTime = envVars.TEMPORAL_SHUTDOWN_GRACE_TIME;
 export const grpcProxy = envVars.TEMPORAL_GRPC_PROXY;

package/src/worker/global_functions.js

@@ -1,4 +1,4 @@
-import { messageBus } from '#bus';
+import { mainEventBus } from '#bus';
 import { ACTIVITY_LOGGER_SYMBOL, BusEventType } from '#consts';
 import { activityInfo as activityInfoFn } from '@temporalio/activity';
 import { assignImmutableProperty } from '#helpers/object';
@@ -9,6 +9,6 @@ import { assignImmutableProperty } from '#helpers/object';
 export const bindGlobalFunctions = () => {
   /** Defines the activity logger function, accessible in activity context via logger interface */
   assignImmutableProperty( globalThis, ACTIVITY_LOGGER_SYMBOL, ( { level, message, metadata } ) =>
-    messageBus.emit( BusEventType.ACTIVITY_LOG, { level, message, metadata, activityInfo: activityInfoFn() } )
+    mainEventBus.emit( BusEventType.ACTIVITY_LOG, { level, message, metadata, activityInfo: activityInfoFn() } )
   );
 };

package/src/worker/global_functions.spec.js

@@ -10,7 +10,7 @@ const {
   }
 } ) );
 
-const messageBusMock = vi.hoisted( () => ( {
+const mainEventBusMock = vi.hoisted( () => ( {
   emit: vi.fn()
 } ) );
 const activityInfoMock = vi.hoisted( () => vi.fn( () => ( {
@@ -19,7 +19,7 @@ const activityInfoMock = vi.hoisted( () => vi.fn( () => ( {
 } ) ) );
 
 vi.mock( '#consts', () => ( { ACTIVITY_LOGGER_SYMBOL, BusEventType } ) );
-vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
 vi.mock( '@temporalio/activity', () => ( {
   activityInfo: activityInfoMock
 } ) );
@@ -42,7 +42,7 @@ describe( 'worker/global_functions', () => {
     } );
 
     expect( activityInfoMock ).toHaveBeenCalledTimes( 1 );
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.ACTIVITY_LOG, {
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( BusEventType.ACTIVITY_LOG, {
       level: 'debug',
       message: 'activity detail',
       metadata,

package/src/worker/index.js

@@ -12,13 +12,16 @@ import { initInterceptors } from './interceptors/index.js';
 import { createChildLogger } from '#logger';
 import { setupInterruptionHandler } from './interruption.js';
 import { CatalogJob } from './catalog_workflow/catalog_job.js';
-import { bootstrapFetchProxy } from './proxy.js';
-import { messageBus } from '#bus';
+import { mainEventBus } from '#bus';
+import { flushPendingHooks } from '#hooks/pending_hooks';
 import { BusEventType } from '#consts';
 import { setupTelemetry } from './telemetry.js';
 import { TemporalConnectionMonitor } from './connection_monitor.js';
 import { bindGlobalFunctions } from './global_functions.js';
+import { setupClientConfig } from '#temporal/client';
 import { runOnce } from '#helpers/function';
+import { serializeError } from '#helpers/error_serializer';
+import { setupTemporalLogger } from './temporal_logger.js';
 
 import './log_hooks.js';
 
@@ -51,6 +54,9 @@ const state = {
 const callerDir = process.argv[2];
 
 const execute = async () => {
+  log.info( 'Setup Temporal Logger' );
+  setupTemporalLogger();
+
   log.info( 'Loading config...', { callerDir } );
   await loadHooks( callerDir );
 
@@ -60,8 +66,7 @@ const execute = async () => {
   log.info( 'Loading activities...', { callerDir } );
   const { activities } = await loadActivities( callerDir, workflows );
 
-  messageBus.emit( BusEventType.WORKER_BEFORE_START );
-  bootstrapFetchProxy();
+  mainEventBus.emit( BusEventType.WORKER_BEFORE_START );
 
   log.info( 'Initializing tracing...' );
   await initTracing();
@@ -82,6 +87,9 @@ const execute = async () => {
 
   state.connection = await NativeConnection.connect( { address, tls: Boolean( apiKey ), apiKey, proxy } );
 
+  // add configs for the /temporal endpoint
+  setupClientConfig( { connection: state.connection, namespace } );
+
   log.info( 'Creating connection monitor...' );
   state.connectionMonitor = new TemporalConnectionMonitor( state.connection );
 
@@ -214,13 +222,18 @@ execute()
         .catch( e => log.warn( 'Connection close error', { error: e.message } ) );
     }
   } )
-  .then( () => log.info( 'Bye' ) )
-  .catch( error => {
-    log.error( 'Fatal error', { error: error.message, stack: error.stack } );
+  .then( async () => {
+    log.info( 'Flushing hook callbacks...' );
+    await flushPendingHooks();
+    log.info( 'Bye' );
+  } )
+  .catch( async error => {
+    log.error( 'Fatal error', { error: serializeError( error ) } );
 
-    messageBus.emit( BusEventType.RUNTIME_ERROR, { error } );
+    mainEventBus.emit( BusEventType.RUNTIME_ERROR, { error } );
 
-    const timeToFlushEvent = configs.processFailureShutdownDelay;
-    log.info( `Exiting in ${timeToFlushEvent}ms` );
-    setTimeout( () => process.exit( 1 ), timeToFlushEvent );
+    log.info( 'Flushing hook callbacks...' );
+    await flushPendingHooks();
+    log.info( 'Exiting...' );
+    setTimeout( () => process.exit( 1 ) );
   } );

package/src/worker/index.spec.js

@@ -6,14 +6,18 @@ const {
   configValues,
   connectionMonitorInstance,
   createCatalogMock,
+  flushPendingHooksMock,
   initInterceptorsMock,
-  messageBusMock,
+  mainEventBusMock,
   mockConnection,
   mockLog,
   mockWorker,
   promises,
   resetPromises,
+  serializeErrorMock,
+  setupClientConfigMock,
   setupInterruptionHandlerMock,
+  setupTemporalLoggerMock,
   setupTelemetryMock
 } = vi.hoisted( () => {
   const createDeferred = () => {
@@ -46,7 +50,6 @@ const {
     maxConcurrentActivityTaskPolls: 5,
     maxConcurrentWorkflowTaskPolls: 5,
     workerTuner: undefined,
-    processFailureShutdownDelay: 0,
     shutdownForceTime: undefined,
     shutdownGraceTime: undefined
   };
@@ -105,30 +108,36 @@ const {
     connectionMonitorInstance,
     createCatalogMock: vi.fn().mockReturnValue( { workflows: [], activities: {} } ),
     createWorkflowsEntryPointMock: vi.fn().mockReturnValue( '/fake/workflows/path.js' ),
+    flushPendingHooksMock: vi.fn().mockResolvedValue( undefined ),
     hashSourceCodeMock: vi.fn().mockResolvedValue( 'catalog-hash' ),
     initInterceptorsMock: vi.fn().mockReturnValue( [] ),
     loadActivitiesMock: vi.fn().mockResolvedValue( {} ),
     loadHooksMock: vi.fn().mockResolvedValue( undefined ),
     loadWorkflowsMock: vi.fn().mockResolvedValue( [] ),
-    messageBusMock: { emit: vi.fn(), on: vi.fn() },
+    mainEventBusMock: { emit: vi.fn(), on: vi.fn() },
     mockConnection: { close: vi.fn().mockResolvedValue( undefined ) },
     mockLog: { error: vi.fn(), info: vi.fn(), warn: vi.fn() },
     mockWorker,
     promises,
     resetPromises,
+    serializeErrorMock: vi.fn( error => ( {
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    } ) ),
+    setupClientConfigMock: vi.fn(),
     setupInterruptionHandlerMock: vi.fn(),
+    setupTemporalLoggerMock: vi.fn(),
     setupTelemetryMock: vi.fn()
   };
 } );
 
 vi.mock( '#logger', () => ( { createChildLogger: () => mockLog } ) );
-vi.mock( '#consts', async importOriginal => {
-  const actual = await importOriginal();
-  return { ...actual };
-} );
+vi.mock( '#helpers/error_serializer', () => ( { serializeError: serializeErrorMock } ) );
 const initTracing = vi.fn().mockResolvedValue( undefined );
 vi.mock( '#tracing', () => ( { init: initTracing } ) );
-vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
+vi.mock( '#hooks/pending_hooks', () => ( { flushPendingHooks: flushPendingHooksMock } ) );
 
 const loadWorkflowsMock = vi.fn().mockResolvedValue( { workflows: [], entrypoint: '/fake/workflows/path.js' } );
 const loadActivitiesMock = vi.fn().mockResolvedValue( { activities: {} } );
@@ -145,7 +154,6 @@ vi.mock( './sinks.js', () => ( { sinks: {} } ) );
 vi.mock( './catalog_workflow/index.js', () => ( { createCatalog: createCatalogMock } ) );
 vi.mock( './bundler_options.js', () => ( { webpackConfigHook: vi.fn() } ) );
 vi.mock( './interceptors/index.js', () => ( { initInterceptors: initInterceptorsMock } ) );
-vi.mock( './proxy.js', () => ( { bootstrapFetchProxy: vi.fn() } ) );
 vi.mock( './telemetry.js', () => ( { setupTelemetry: setupTelemetryMock } ) );
 vi.mock( './interruption.js', () => ( { setupInterruptionHandler: setupInterruptionHandlerMock } ) );
 vi.mock( './global_functions.js', () => ( { bindGlobalFunctions: bindGlobalFunctionsMock } ) );
@@ -160,6 +168,8 @@ vi.mock( './catalog_workflow/catalog_job.js', () => ( {
   } )
 } ) );
 vi.mock( './log_hooks.js', () => ( {} ) );
+vi.mock( './temporal_logger.js', () => ( { setupTemporalLogger: setupTemporalLoggerMock } ) );
+vi.mock( '#temporal/client', () => ( { setupClientConfig: setupClientConfigMock } ) );
 vi.mock( '@temporalio/worker', () => ( {
   NativeConnection: { connect: vi.fn().mockResolvedValue( mockConnection ) },
   Worker: { create: vi.fn().mockResolvedValue( mockWorker ) }
@@ -216,6 +226,7 @@ describe( 'worker/index', () => {
     await vi.waitFor( () => expect( Worker.create ).toHaveBeenCalled() );
 
     expect( loadHooksMock ).toHaveBeenCalledWith( '/test/caller/dir' );
+    expect( setupTemporalLoggerMock ).toHaveBeenCalledOnce();
     expect( loadWorkflowsMock ).toHaveBeenCalledWith( '/test/caller/dir' );
     expect( loadActivitiesMock ).toHaveBeenCalledWith( '/test/caller/dir', [] );
     expect( initTracing ).toHaveBeenCalled();
@@ -227,6 +238,10 @@ describe( 'worker/index', () => {
       apiKey: undefined,
       proxy: undefined
     } );
+    expect( setupClientConfigMock ).toHaveBeenCalledWith( {
+      connection: mockConnection,
+      namespace: configValues.namespace
+    } );
     expect( bindGlobalFunctionsMock ).toHaveBeenCalledTimes( 1 );
     expect( bindGlobalFunctionsMock.mock.invocationCallOrder[0] ).toBeLessThan(
       NativeConnection.connect.mock.invocationCallOrder[0]
@@ -262,6 +277,7 @@ describe( 'worker/index', () => {
     expect( catalogJobInstance.run ).toHaveBeenCalled();
 
     await settleWorker();
+    await vi.waitFor( () => expect( flushPendingHooksMock ).toHaveBeenCalledOnce() );
     expect( mockLog.info ).toHaveBeenCalledWith( 'Bye' );
   } );
 
@@ -354,11 +370,15 @@ describe( 'worker/index', () => {
 
     await vi.waitFor( () => {
       expect( mockLog.error ).toHaveBeenCalledWith( 'Fatal error', expect.objectContaining( {
-        error: 'Big Failure'
+        error: expect.objectContaining( { message: 'Big Failure' } )
       } ) );
     } );
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
+    expect( serializeErrorMock ).toHaveBeenCalledWith( error );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
     await vi.waitFor( () => expect( exitMock ).toHaveBeenCalledWith( 1 ) );
+    expect( flushPendingHooksMock ).toHaveBeenCalledOnce();
+    expect( mainEventBusMock.emit.mock.invocationCallOrder[0] ).toBeLessThan( flushPendingHooksMock.mock.invocationCallOrder[0] );
+    expect( flushPendingHooksMock.mock.invocationCallOrder[0] ).toBeLessThan( exitMock.mock.invocationCallOrder[0] );
   } );
 
   it( 'throws connection monitor errors after graceful shutdown', async () => {
@@ -373,12 +393,12 @@ describe( 'worker/index', () => {
 
     await vi.waitFor( () => {
       expect( mockLog.error ).toHaveBeenCalledWith( 'Fatal error', expect.objectContaining( {
-        error: 'connection lost'
+        error: expect.objectContaining( { message: 'connection lost' } )
       } ) );
     } );
     expect( mockWorker.shutdown ).toHaveBeenCalledOnce();
     expect( catalogJobInstance.interrupt ).toHaveBeenCalledOnce();
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
   } );
 
   it( 'throws catalog job errors after graceful shutdown', async () => {
@@ -393,12 +413,12 @@ describe( 'worker/index', () => {
 
     await vi.waitFor( () => {
       expect( mockLog.error ).toHaveBeenCalledWith( 'Fatal error', expect.objectContaining( {
-        error: 'catalog failed'
+        error: expect.objectContaining( { message: 'catalog failed' } )
       } ) );
     } );
     expect( mockWorker.shutdown ).toHaveBeenCalledOnce();
     expect( connectionMonitorInstance.stop ).toHaveBeenCalledOnce();
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
   } );
 
   it( 'cleans up partial startup failures after connecting', async () => {
@@ -413,7 +433,7 @@ describe( 'worker/index', () => {
     expect( catalogJobInstance.interrupt ).not.toHaveBeenCalled();
     await vi.waitFor( () => {
       expect( mockLog.error ).toHaveBeenCalledWith( 'Fatal error', expect.objectContaining( {
-        error: 'worker create failed'
+        error: expect.objectContaining( { message: 'worker create failed' } )
       } ) );
     } );
   } );

package/src/worker/interceptors/activity.js

@@ -1,12 +1,14 @@
-import { Context, activityInfo as activityInfoFn } from '@temporalio/activity';
+import { Context, activityInfo as activityInfoFn, ApplicationFailure } from '@temporalio/activity';
+import { CompleteAsyncError, TemporalFailure } from '@temporalio/common';
 import { Storage } from '#async_storage';
 import * as Tracing from '#tracing';
 import { headersToObject } from './headers.js';
-import { ACTIVITY_WRAPPER_VERSION_FIELD, BusEventType, METADATA_ACCESS_SYMBOL } from '#consts';
+import { ActivitySpecialOutput, BusEventType, METADATA_ACCESS_SYMBOL } from '#consts';
 import { activityHeartbeatEnabled, activityHeartbeatIntervalMs } from '../configs.js';
-import { messageBus } from '#bus';
-import { aggregateAttributes } from '#helpers/aggregations';
-import { buildApplicationFailureWithDetails } from '#helpers/errors';
+import { mainEventBus } from '#bus';
+import { inheritsFromAnyNamedType } from '#helpers/errors';
+import { serializeError } from '#helpers/error_serializer';
+import { FatalError, TransparentFatalError } from '#errors';
 
 /*
   This interceptor wraps every activity execution with cross-cutting concerns:
@@ -51,12 +53,9 @@ export class ActivityExecutionInterceptor {
     }
 
     const state = {
-      heartbeat: null,
-      attributes: []
+      heartbeat: null
     };
 
-    const addAttribute = attribute => state.attributes.push( attribute );
-
     // Adds context accessible information
     const storageContext = {
       parentId: activityId,
@@ -64,11 +63,10 @@ export class ActivityExecutionInterceptor {
       activityInfo,
       workflowDetails,
       workflowFilename,
-      traceInfo,
-      addAttribute
+      traceInfo
     };
 
-    messageBus.emit( BusEventType.ACTIVITY_START, { activityInfo, workflowDetails, outputActivityKind } );
+    mainEventBus.emit( BusEventType.ACTIVITY_START, { activityInfo, workflowDetails, outputActivityKind } );
     Tracing.addEventStart( { id: activityId, name: activityType, kind: outputActivityKind, parentId: runId, details: input.args[0], traceInfo } );
 
     try {
@@ -77,19 +75,34 @@ export class ActivityExecutionInterceptor {
 
       const output = await Storage.runWithContext( async _ => next( input ), storageContext );
 
-      const aggregations = state.attributes.length > 0 ? aggregateAttributes( state.attributes ) : null;
-
-      messageBus.emit( BusEventType.ACTIVITY_END, { activityInfo, aggregations, workflowDetails, outputActivityKind } );
+      mainEventBus.emit( BusEventType.ACTIVITY_END, { activityInfo, workflowDetails, outputActivityKind } );
       Tracing.addEventEnd( { id: activityId, details: output, traceInfo } );
 
-      return { [ACTIVITY_WRAPPER_VERSION_FIELD]: 1, output, aggregations };
+      return output;
 
     } catch ( error ) {
-      const aggregations = state.attributes.length > 0 ? aggregateAttributes( state.attributes ) : null;
-      messageBus.emit( BusEventType.ACTIVITY_ERROR, { activityInfo, aggregations, workflowDetails, outputActivityKind, error } );
-      Tracing.addEventError( { id: activityId, details: error, traceInfo } );
-
-      throw aggregations ? buildApplicationFailureWithDetails( error, { aggregations } ) : error;
+      // Record async completion handoff as a trace end without emitting a bus event.
+      if ( error instanceof CompleteAsyncError ) {
+        Tracing.addEventEnd( { id: activityId, details: ActivitySpecialOutput.ASYNC_HANDOFF, traceInfo } );
+        throw error;
+      }
+
+      const unwrappedError = error instanceof TransparentFatalError ? error.cause : error;
+
+      Tracing.addEventError( { id: activityId, details: unwrappedError, traceInfo } );
+      mainEventBus.emit( BusEventType.ACTIVITY_ERROR, { activityInfo, workflowDetails, outputActivityKind, error: unwrappedError } );
+
+      // Native Temporal errors are just re-thrown
+      if ( error instanceof TemporalFailure ) {
+        throw error;
+      }
+
+      const nonRetryable = error instanceof FatalError || inheritsFromAnyNamedType( error, activityInfo.retryPolicy?.nonRetryableErrorTypes ?? [] );
+      throw ApplicationFailure.fromError( unwrappedError, {
+        nonRetryable,
+        cause: unwrappedError,
+        details: [ { error: serializeError( unwrappedError, { dropKeys: [ 'stack' ] } ) } ]
+      } );
     } finally {
       clearInterval( state.heartbeat );
     }