@outputai/core 0.6.0 → 0.6.1-next.383b24b.0

package/src/tracing/trace_engine.js

@@ -32,16 +32,12 @@ const processors = [
 /**
  * Returns the destinations for a given execution context
  *
- * @param {object} executionContext
- * @param {string} executionContext.startTime
- * @param {string} executionContext.workflowId
- * @param {string} executionContext.workflowName
- * @param {boolean} executionContext.disableTrace
+ * @param {object} traceInfo - The trace information object
  * @returns {object} A trace destinations object: { [dest-name]: 'path' }
  */
-export const getDestinations = executionContext =>
+export const getDestinations = traceInfo =>
   processors.reduce( ( o, p ) =>
-    Object.assign( o, { [p.name.toLowerCase()]: p.enabled && !executionContext.disableTrace ? p.getDestination( executionContext ) : null } )
+    Object.assign( o, { [p.name.toLowerCase()]: p.enabled && !traceInfo.disableTrace ? p.getDestination( traceInfo ) : null } )
   , {} );
 
 /**
@@ -72,11 +68,11 @@ const serializeDetails = details => details instanceof Error ? serializeError( d
  * @param {object} fields - All the trace fields
  * @returns {void}
  */
-export const addEventAction = ( action, { kind, name, id, parentId, details, executionContext } ) => {
+export const addEventAction = ( action, { kind, name, id, parentId, details, traceInfo } ) => {
   // Ignores internal steps in the actual trace files, ignore trace if the flag is true
-  if ( kind !== ComponentType.INTERNAL_STEP && !executionContext.disableTrace ) {
+  if ( kind !== ComponentType.INTERNAL_STEP && !traceInfo.disableTrace ) {
     traceBus.emit( 'entry', {
-      executionContext,
+      traceInfo,
       entry: { kind, action, name, id, parentId, timestamp: Date.now(), details: serializeDetails( details ) }
     } );
   }
@@ -93,7 +89,7 @@ export const addEventAction = ( action, { kind, name, id, parentId, details, exe
 export function addEventActionWithContext( action, options ) {
   const storeContent = Storage.load();
   if ( storeContent ) { // If there is no storageContext this was not called from a Temporal environment
-    const { parentId, executionContext, addAttribute } = storeContent;
+    const { parentId, traceInfo, addAttribute } = storeContent;
     if ( action === EventAction.ADD_ATTR ) {
       const attribute = options.details;
       if ( !( attribute instanceof BaseAttribute ) ) {
@@ -102,6 +98,6 @@ export function addEventActionWithContext( action, options ) {
         addAttribute( options.details );
       }
     }
-    addEventAction( action, { ...options, parentId, executionContext } );
+    addEventAction( action, { ...options, parentId, traceInfo } );
   }
 };

package/src/tracing/trace_engine.spec.js

@@ -34,6 +34,14 @@ async function loadTraceEngine() {
   return import( './trace_engine.js' );
 }
 
+const traceInfo = {
+  workflowId: 'w1',
+  runId: 'r1',
+  workflowType: 'WF',
+  startTime: 1,
+  disableTrace: false
+};
+
 describe( 'tracing/trace_engine', () => {
   beforeEach( () => {
     vi.clearAllMocks();
@@ -52,9 +60,8 @@ describe( 'tracing/trace_engine', () => {
     expect( localInitMock ).toHaveBeenCalledTimes( 1 );
     expect( s3InitMock ).not.toHaveBeenCalled();
 
-    const executionContext = { disableTrace: false };
     addEventAction( 'start', {
-      kind: 'step', name: 'N', id: '1', parentId: 'p', details: { ok: true }, executionContext
+      kind: 'step', name: 'N', id: '1', parentId: 'p', details: { ok: true }, traceInfo
     } );
     expect( localExecMock ).toHaveBeenCalledTimes( 1 );
     const payload = localExecMock.mock.calls[0][0];
@@ -62,7 +69,7 @@ describe( 'tracing/trace_engine', () => {
     expect( payload.entry.kind ).toBe( 'step' );
     expect( payload.entry.action ).toBe( 'start' );
     expect( payload.entry.details ).toEqual( { ok: true } );
-    expect( payload.executionContext ).toBe( executionContext );
+    expect( payload.traceInfo ).toBe( traceInfo );
   } );
 
   it( 'addEventAction() emits an entry consumed by processors', async () => {
@@ -72,7 +79,7 @@ describe( 'tracing/trace_engine', () => {
 
     addEventAction( 'end', {
       kind: 'workflow', name: 'W', id: '2', parentId: 'p2', details: 'done',
-      executionContext: { disableTrace: false }
+      traceInfo
     } );
     expect( localExecMock ).toHaveBeenCalledTimes( 1 );
     const payload = localExecMock.mock.calls[0][0];
@@ -81,14 +88,14 @@ describe( 'tracing/trace_engine', () => {
     expect( payload.entry.details ).toBe( 'done' );
   } );
 
-  it( 'addEventAction() does not emit when executionContext.disableTrace is true', async () => {
+  it( 'addEventAction() does not emit when traceInfo.disableTrace is true', async () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = '1';
     const { init, addEventAction } = await loadTraceEngine();
     await init();
 
     addEventAction( 'start', {
       kind: 'step', name: 'X', id: '1', parentId: 'p', details: {},
-      executionContext: { disableTrace: true }
+      traceInfo: { ...traceInfo, disableTrace: true }
     } );
     expect( localExecMock ).not.toHaveBeenCalled();
   } );
@@ -100,7 +107,7 @@ describe( 'tracing/trace_engine', () => {
 
     addEventAction( 'start', {
       kind: 'internal_step', name: 'Internal', id: '1', parentId: 'p', details: {},
-      executionContext: { disableTrace: false }
+      traceInfo
     } );
     expect( localExecMock ).not.toHaveBeenCalled();
   } );
@@ -109,7 +116,7 @@ describe( 'tracing/trace_engine', () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = 'true';
     storageLoadMock.mockReturnValue( {
       parentId: 'ctx-p',
-      executionContext: { runId: 'r1', disableTrace: false }
+      traceInfo
     } );
     const { init, addEventActionWithContext } = await loadTraceEngine();
     await init();
@@ -117,7 +124,7 @@ describe( 'tracing/trace_engine', () => {
     addEventActionWithContext( 'tick', { kind: 'step', name: 'S', id: '3', details: 1 } );
     expect( localExecMock ).toHaveBeenCalledTimes( 1 );
     const payload = localExecMock.mock.calls[0][0];
-    expect( payload.executionContext ).toEqual( { runId: 'r1', disableTrace: false } );
+    expect( payload.traceInfo ).toBe( traceInfo );
     expect( payload.entry.parentId ).toBe( 'ctx-p' );
     expect( payload.entry.name ).toBe( 'S' );
     expect( payload.entry.action ).toBe( 'tick' );
@@ -126,10 +133,9 @@ describe( 'tracing/trace_engine', () => {
   it( 'addEventActionWithContext() records ADD_ATTR attributes through storage context', async () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = 'true';
     const addAttributeMock = vi.fn();
-    const executionContext = { runId: 'r1', disableTrace: false };
     storageLoadMock.mockReturnValue( {
       parentId: 'ctx-p',
-      executionContext,
+      traceInfo,
       addAttribute: addAttributeMock
     } );
     const { init, addEventActionWithContext } = await loadTraceEngine();
@@ -144,7 +150,7 @@ describe( 'tracing/trace_engine', () => {
     expect( addAttributeMock ).toHaveBeenCalledWith( attribute );
     expect( localExecMock ).toHaveBeenCalledTimes( 1 );
     expect( localExecMock.mock.calls[0][0] ).toEqual( {
-      executionContext,
+      traceInfo,
       entry: {
         kind: 'http',
         action: EventAction.ADD_ATTR,
@@ -162,7 +168,7 @@ describe( 'tracing/trace_engine', () => {
     const addAttributeMock = vi.fn();
     storageLoadMock.mockReturnValue( {
       parentId: 'ctx-p',
-      executionContext: { runId: 'r1', disableTrace: false },
+      traceInfo,
       addAttribute: addAttributeMock
     } );
     const { init, addEventActionWithContext } = await loadTraceEngine();
@@ -179,11 +185,11 @@ describe( 'tracing/trace_engine', () => {
     expect( localExecMock ).not.toHaveBeenCalled();
   } );
 
-  it( 'addEventActionWithContext() does not emit when storage executionContext.disableTrace is true', async () => {
+  it( 'addEventActionWithContext() does not emit when storage traceInfo.disableTrace is true', async () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = '1';
     storageLoadMock.mockReturnValue( {
       parentId: 'ctx-p',
-      executionContext: { runId: 'r1', disableTrace: true }
+      traceInfo: { ...traceInfo, disableTrace: true }
     } );
     const { init, addEventActionWithContext } = await loadTraceEngine();
     await init();
@@ -203,21 +209,19 @@ describe( 'tracing/trace_engine', () => {
   } );
 
   describe( 'getDestinations()', () => {
-    const executionContext = { workflowId: 'w1', workflowName: 'WF', startTime: 1, disableTrace: false };
-
     it( 'returns null for both when traces are off (env vars unset)', async () => {
       const { getDestinations } = await loadTraceEngine();
-      const result = getDestinations( executionContext );
+      const result = getDestinations( traceInfo );
       expect( result ).toEqual( { local: null, remote: null } );
       expect( localGetDestinationMock ).not.toHaveBeenCalled();
       expect( s3GetDestinationMock ).not.toHaveBeenCalled();
     } );
 
-    it( 'returns null for both when executionContext.disableTrace is true', async () => {
+    it( 'returns null for both when traceInfo.disableTrace is true', async () => {
       process.env.OUTPUT_TRACE_LOCAL_ON = '1';
       process.env.OUTPUT_TRACE_REMOTE_ON = '1';
       const { getDestinations } = await loadTraceEngine();
-      const result = getDestinations( { ...executionContext, disableTrace: true } );
+      const result = getDestinations( { ...traceInfo, disableTrace: true } );
       expect( result ).toEqual( { local: null, remote: null } );
       expect( localGetDestinationMock ).not.toHaveBeenCalled();
       expect( s3GetDestinationMock ).not.toHaveBeenCalled();
@@ -227,24 +231,24 @@ describe( 'tracing/trace_engine', () => {
       process.env.OUTPUT_TRACE_LOCAL_ON = '1';
       process.env.OUTPUT_TRACE_REMOTE_ON = 'true';
       const { getDestinations } = await loadTraceEngine();
-      const result = getDestinations( executionContext );
+      const result = getDestinations( traceInfo );
       expect( result ).toEqual( {
         local: '/local/path.json',
         remote: 'https://bucket.s3.amazonaws.com/key.json'
       } );
       expect( localGetDestinationMock ).toHaveBeenCalledTimes( 1 );
-      expect( localGetDestinationMock ).toHaveBeenCalledWith( executionContext );
+      expect( localGetDestinationMock ).toHaveBeenCalledWith( traceInfo );
       expect( s3GetDestinationMock ).toHaveBeenCalledTimes( 1 );
-      expect( s3GetDestinationMock ).toHaveBeenCalledWith( executionContext );
+      expect( s3GetDestinationMock ).toHaveBeenCalledWith( traceInfo );
     } );
 
     it( 'returns local only when local trace on and remote off', async () => {
       process.env.OUTPUT_TRACE_LOCAL_ON = '1';
       process.env.OUTPUT_TRACE_REMOTE_ON = '0';
       const { getDestinations } = await loadTraceEngine();
-      const result = getDestinations( executionContext );
+      const result = getDestinations( traceInfo );
       expect( result ).toEqual( { local: '/local/path.json', remote: null } );
-      expect( localGetDestinationMock ).toHaveBeenCalledWith( executionContext );
+      expect( localGetDestinationMock ).toHaveBeenCalledWith( traceInfo );
       expect( s3GetDestinationMock ).not.toHaveBeenCalled();
     } );
 
@@ -252,10 +256,10 @@ describe( 'tracing/trace_engine', () => {
       process.env.OUTPUT_TRACE_LOCAL_ON = '0';
       process.env.OUTPUT_TRACE_REMOTE_ON = 'true';
       const { getDestinations } = await loadTraceEngine();
-      const result = getDestinations( executionContext );
+      const result = getDestinations( traceInfo );
       expect( result ).toEqual( { local: null, remote: 'https://bucket.s3.amazonaws.com/key.json' } );
       expect( localGetDestinationMock ).not.toHaveBeenCalled();
-      expect( s3GetDestinationMock ).toHaveBeenCalledWith( executionContext );
+      expect( s3GetDestinationMock ).toHaveBeenCalledWith( traceInfo );
     } );
   } );
 } );

package/src/worker/interceptors/activity.js

@@ -1,4 +1,4 @@
-import { Context } from '@temporalio/activity';
+import { Context, activityInfo as activityInfoFn } from '@temporalio/activity';
 import { Storage } from '#async_storage';
 import * as Tracing from '#tracing';
 import { headersToObject } from '../sandboxed_utils.js';
@@ -25,7 +25,7 @@ const log = createChildLogger( 'ActivityInterceptor' );
 
   Context information comes from two sources:
   - Temporal's Activity Context (workflowId, activityId, activityType)
-  - Headers injected by the workflow interceptor (executionContext)
+  - Headers injected by the workflow interceptor
 */
 export class ActivityExecutionInterceptor {
   constructor( { activities, workflows, connection } ) {
@@ -42,25 +42,24 @@ export class ActivityExecutionInterceptor {
 
   /**
    * Returns a workflow entry by its name or throws error
-   * @param {string} workflowName
+   * @param {string} workflowType
    * @returns {object} Workflow entry
    * @throws {Error}
    */
-  getWorkflowEntry( workflowName ) {
-    const workflowEntry = this.workflowsMap.get( workflowName );
+  getWorkflowEntry( workflowType ) {
+    const workflowEntry = this.workflowsMap.get( workflowType );
     if ( !workflowEntry ) {
-      throw new Error( `Activity interceptor: workflow "${workflowName}" not found in workflowsMap.` );
+      throw new Error( `Activity interceptor: workflow "${workflowType}" not found in workflowsMap.` );
     }
     return workflowEntry;
   }
 
   async execute( input, next ) {
-    const startDate = Date.now();
-
-    const { workflowExecution: { workflowId }, activityId: id, activityType: name, workflowType: workflowName } = Context.current().info;
-    const { executionContext } = headersToObject( input.headers );
-    const { type: kind } = this.activities?.[name]?.[METADATA_ACCESS_SYMBOL];
-    const { path: workflowFilename } = this.getWorkflowEntry( workflowName );
+    const activityInfo = activityInfoFn();
+    const { workflowExecution: { workflowId, runId }, activityId, activityType, workflowType } = activityInfo;
+    const { traceInfo, workflowDetails } = headersToObject( input.headers );
+    const { type: outputActivityKind } = this.activities?.[activityType]?.[METADATA_ACCESS_SYMBOL];
+    const { path: workflowFilename } = this.getWorkflowEntry( workflowType );
 
     const state = {
       heartbeat: null,
@@ -76,32 +75,35 @@ export class ActivityExecutionInterceptor {
           const workflowHandle = client.workflow.getHandle( workflowId );
           await workflowHandle.signal( Signal.SEND_AGGREGATIONS, aggregateAttributes( state.attributes ) );
         } catch ( error ) {
-          log.warn( `Signal "${Signal.SEND_AGGREGATIONS}" failed`, {
-            message: error.message,
-            stack: error.stack,
-            activityId: id,
-            activityName: name,
-            workflowId,
-            workflowName
-          } );
+          const errorContext = { message: error.message, stack: error.stack, activityId, activityType, workflowId, workflowType, runId };
+          log.warn( `Signal "${Signal.SEND_AGGREGATIONS}" failed`, errorContext );
         }
       }
     };
 
-    // Wraps the execution with accessible metadata for the activity
-    const ctx = { parentId: id, executionContext, workflowFilename, addAttribute };
+    // Adds context accessible information
+    const storageContext = {
+      parentId: activityId,
+      outputActivityKind,
+      activityInfo,
+      workflowDetails,
+      workflowFilename,
+      traceInfo,
+      addAttribute
+    };
 
-    messageBus.emit( BusEventType.ACTIVITY_START, { id, name, kind, workflowId, workflowName } );
-    Tracing.addEventStart( { id, name, kind, parentId: workflowId, details: input.args[0], executionContext } );
+    messageBus.emit( BusEventType.ACTIVITY_START, { activityInfo, workflowDetails, outputActivityKind } );
+    Tracing.addEventStart( { id: activityId, name: activityType, kind: outputActivityKind, parentId: runId, details: input.args[0], traceInfo } );
 
     try {
       // Sends heartbeat to communicate that activity is still alive
       state.heartbeat = activityHeartbeatEnabled && setInterval( () => Context.current().heartbeat(), activityHeartbeatIntervalMs );
 
-      const output = await Storage.runWithContext( async _ => next( input ), ctx );
+      const output = await Storage.runWithContext( async _ => next( input ), storageContext );
+
+      messageBus.emit( BusEventType.ACTIVITY_END, { activityInfo, workflowDetails, outputActivityKind } );
+      Tracing.addEventEnd( { id: activityId, details: output, traceInfo } );
 
-      messageBus.emit( BusEventType.ACTIVITY_END, { id, name, kind, workflowId, workflowName, duration: Date.now() - startDate } );
-      Tracing.addEventEnd( { id, details: output, executionContext } );
       return {
         [ACTIVITY_WRAPPER_VERSION_FIELD]: 1,
         output,
@@ -109,8 +111,8 @@ export class ActivityExecutionInterceptor {
       };
 
     } catch ( error ) {
-      messageBus.emit( BusEventType.ACTIVITY_ERROR, { id, name, kind, workflowId, workflowName, duration: Date.now() - startDate, error } );
-      Tracing.addEventError( { id, details: error, executionContext } );
+      messageBus.emit( BusEventType.ACTIVITY_ERROR, { activityInfo, workflowDetails, outputActivityKind, error } );
+      Tracing.addEventError( { id: activityId, details: error, traceInfo } );
 
       await sendAggregationsViaSignal();
 

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

@@ -7,20 +7,36 @@ const workflowHandleMock = vi.hoisted( () => ( { signal: vi.fn() } ) );
 const getHandleMock = vi.hoisted( () => vi.fn( () => workflowHandleMock ) );
 const clientConstructorMock = vi.hoisted( () => vi.fn() );
 const logWarnMock = vi.hoisted( () => vi.fn() );
-
-const heartbeatMock = vi.fn();
+const heartbeatMock = vi.hoisted( () => vi.fn() );
 const runWithContextMock = vi.hoisted( () => vi.fn().mockImplementation( async fn => fn() ) );
-const contextInfoMock = {
-  workflowExecution: { workflowId: 'wf-1' },
+const activityInfoMock = vi.hoisted( () => ( {
+  workflowExecution: { workflowId: 'wf-1', runId: 'run-1' },
   activityId: 'act-1',
   activityType: 'myWorkflow#myStep',
   workflowType: 'myWorkflow'
-};
+} ) );
+const traceInfoMock = vi.hoisted( () => ( {
+  workflowId: 'wf-1',
+  runId: 'run-1',
+  workflowType: 'myWorkflow',
+  startTime: 1710000000000,
+  disableTrace: false
+} ) );
+const workflowDetailsMock = vi.hoisted( () => ( {
+  workflowId: 'wf-1',
+  runId: 'run-1',
+  workflowType: 'myWorkflow',
+  firstExecutionRunId: 'run-1',
+  startTime: 1710000000000,
+  runStartTime: 1710000000000,
+  attempt: 1
+} ) );
 
 vi.mock( '@temporalio/activity', () => ( {
+  activityInfo: () => activityInfoMock,
   Context: {
     current: () => ( {
-      info: contextInfoMock,
+      info: activityInfoMock,
       heartbeat: heartbeatMock
     } )
   }
@@ -58,7 +74,7 @@ vi.mock( '#tracing', () => ( {
 } ) );
 
 vi.mock( '../sandboxed_utils.js', () => ( {
-  headersToObject: () => ( { executionContext: { workflowId: 'wf-1' } } )
+  headersToObject: () => ( { traceInfo: traceInfoMock, workflowDetails: workflowDetailsMock } )
 } ) );
 
 const messageBusEmitMock = vi.fn();
@@ -105,6 +121,7 @@ const httpRequestAttribute = {
 describe( 'ActivityExecutionInterceptor', () => {
   beforeEach( () => {
     vi.clearAllMocks();
+    activityInfoMock.workflowType = 'myWorkflow';
     workflowHandleMock.signal.mockResolvedValue( undefined );
     vi.useFakeTimers();
     vi.resetModules();
@@ -132,22 +149,34 @@ describe( 'ActivityExecutionInterceptor', () => {
       aggregations: null,
       [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
     } );
-    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_START, expect.objectContaining( {
-      id: 'act-1', name: 'myWorkflow#myStep', kind: 'step', workflowId: 'wf-1', workflowName: 'myWorkflow'
-    } ) );
-    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, expect.objectContaining( {
-      id: 'act-1', name: 'myWorkflow#myStep', kind: 'step', workflowId: 'wf-1', workflowName: 'myWorkflow', duration: expect.any( Number )
-    } ) );
-    expect( addEventStartMock ).toHaveBeenCalledOnce();
-    expect( addEventEndMock ).toHaveBeenCalledOnce();
+    expect( messageBusEmitMock ).toHaveBeenCalledWith(
+      BusEventType.ACTIVITY_START,
+      { activityInfo: activityInfoMock, workflowDetails: workflowDetailsMock, outputActivityKind: 'step' }
+    );
+    expect( messageBusEmitMock ).toHaveBeenCalledWith(
+      BusEventType.ACTIVITY_END,
+      { activityInfo: activityInfoMock, workflowDetails: workflowDetailsMock, outputActivityKind: 'step' }
+    );
+    expect( addEventStartMock ).toHaveBeenCalledWith( {
+      id: 'act-1',
+      name: 'myWorkflow#myStep',
+      kind: 'step',
+      parentId: 'run-1',
+      details: { someInput: 'data' },
+      traceInfo: traceInfoMock
+    } );
+    expect( addEventEndMock ).toHaveBeenCalledWith( { id: 'act-1', details: { result: 'ok' }, traceInfo: traceInfoMock } );
     expect( addEventErrorMock ).not.toHaveBeenCalled();
     expect( clientConstructorMock ).not.toHaveBeenCalled();
     expect( runWithContextMock ).toHaveBeenCalledWith(
       expect.any( Function ),
       expect.objectContaining( {
         parentId: 'act-1',
-        executionContext: { workflowId: 'wf-1' },
+        activityInfo: activityInfoMock,
+        workflowDetails: workflowDetailsMock,
+        outputActivityKind: 'step',
         workflowFilename: '/workflows/myWorkflow.js',
+        traceInfo: traceInfoMock,
         addAttribute: expect.any( Function )
       } )
     );
@@ -166,7 +195,7 @@ describe( 'ActivityExecutionInterceptor', () => {
     } );
 
     expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, expect.any( Object ) );
-    expect( addEventEndMock ).toHaveBeenCalledWith( { id: 'act-1', details: { result: 'sync' }, executionContext: { workflowId: 'wf-1' } } );
+    expect( addEventEndMock ).toHaveBeenCalledWith( { id: 'act-1', details: { result: 'sync' }, traceInfo: traceInfoMock } );
     expect( addEventErrorMock ).not.toHaveBeenCalled();
   } );
 
@@ -244,9 +273,10 @@ describe( 'ActivityExecutionInterceptor', () => {
     expect( logWarnMock ).toHaveBeenCalledWith( `Signal "${Signal.SEND_AGGREGATIONS}" failed`, expect.objectContaining( {
       message: 'signal failed',
       activityId: 'act-1',
-      activityName: 'myWorkflow#myStep',
+      activityType: 'myWorkflow#myStep',
       workflowId: 'wf-1',
-      workflowName: 'myWorkflow'
+      workflowType: 'myWorkflow',
+      runId: 'run-1'
     } ) );
   } );
 
@@ -261,12 +291,14 @@ describe( 'ActivityExecutionInterceptor', () => {
 
     await expect( promise ).rejects.toThrow( 'step failed' );
     expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_START, expect.any( Object ) );
-    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, expect.objectContaining( {
-      id: 'act-1', name: 'myWorkflow#myStep', kind: 'step', workflowId: 'wf-1', workflowName: 'myWorkflow',
-      duration: expect.any( Number ), error: expect.any( Error )
-    } ) );
+    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
+      activityInfo: activityInfoMock,
+      workflowDetails: workflowDetailsMock,
+      outputActivityKind: 'step',
+      error
+    } );
     expect( addEventStartMock ).toHaveBeenCalledOnce();
-    expect( addEventErrorMock ).toHaveBeenCalledOnce();
+    expect( addEventErrorMock ).toHaveBeenCalledWith( { id: 'act-1', details: error, traceInfo: traceInfoMock } );
     expect( addEventEndMock ).not.toHaveBeenCalled();
   } );
 
@@ -331,7 +363,7 @@ describe( 'ActivityExecutionInterceptor', () => {
     const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows } );
 
     // Override context to use alias as workflowType
-    contextInfoMock.workflowType = 'myWorkflowOld';
+    activityInfoMock.workflowType = 'myWorkflowOld';
     const next = vi.fn().mockResolvedValue( { result: 'ok' } );
 
     const promise = interceptor.execute( makeInput(), next );
@@ -345,7 +377,7 @@ describe( 'ActivityExecutionInterceptor', () => {
     );
 
     // Restore for other tests
-    contextInfoMock.workflowType = 'myWorkflow';
+    activityInfoMock.workflowType = 'myWorkflow';
   } );
 
   it( 'does not heartbeat when OUTPUT_ACTIVITY_HEARTBEAT_ENABLED is false', async () => {

package/src/worker/interceptors/workflow.js

@@ -5,6 +5,7 @@ import { deepMerge } from '#utils';
 import { METADATA_ACCESS_SYMBOL, WorkflowSpecialOutput } from '#consts';
 // this is a dynamic generated file with activity configs overwrites
 import stepOptions from '../temp/__activity_options.js';
+import { createWorkflowDetails } from '#internal_utils/temporal_context';
 
 /*
   This is not an AI comment!
@@ -17,8 +18,12 @@ import stepOptions from '../temp/__activity_options.js';
 */
 class HeadersInjectionInterceptor {
   async scheduleActivity( input, next ) {
-    const memo = workflowInfo().memo ?? {};
-    Object.assign( input.headers, memoToHeaders( memo ) );
+    const info = workflowInfo();
+    const memo = info.memo ?? {};
+    Object.assign( input.headers, memoToHeaders( {
+      ...memo,
+      workflowDetails: createWorkflowDetails( info )
+    } ) );
     // apply per-invocation options passed as second argument by rewritten calls
     const options = stepOptions[input.activityType];
     if ( options ) {

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

@@ -7,6 +7,35 @@ const workflowStartMock = vi.fn();
 const workflowEndMock = vi.fn();
 const workflowErrorMock = vi.fn();
 const isCancellationMock = vi.fn();
+const startTime = new Date( '2026-06-02T09:00:00.000Z' );
+const runStartTime = new Date( '2026-06-02T09:05:00.000Z' );
+const workflowDetails = {
+  attempt: 1,
+  continuedFromExecutionRunId: undefined,
+  firstExecutionRunId: 'first-run',
+  parent: undefined,
+  root: undefined,
+  runId: 'run-1',
+  runStartTime: runStartTime.getTime(),
+  startTime: startTime.getTime(),
+  workflowId: 'workflow-1',
+  workflowType: 'MyWorkflow'
+};
+
+const workflowInfo = {
+  attempt: 1,
+  continuedFromExecutionRunId: undefined,
+  firstExecutionRunId: 'first-run',
+  parent: undefined,
+  root: undefined,
+  runId: 'run-1',
+  runStartTime,
+  startTime,
+  workflowId: 'workflow-1',
+  workflowType: 'MyWorkflow',
+  memo: { traceInfo: { runId: 'root-run' } }
+};
+
 vi.mock( '@temporalio/workflow', () => ( {
   workflowInfo: ( ...args ) => workflowInfoMock( ...args ),
   proxySinks: () => ( {
@@ -53,7 +82,7 @@ describe( 'workflow interceptors', () => {
   beforeEach( () => {
     vi.clearAllMocks();
     isCancellationMock.mockReturnValue( false );
-    workflowInfoMock.mockReturnValue( { workflowType: 'MyWorkflow', memo: { executionContext: { id: 'ctx-1' } } } );
+    workflowInfoMock.mockReturnValue( workflowInfo );
   } );
 
   describe( 'HeadersInjectionInterceptor', () => {
@@ -64,12 +93,19 @@ describe( 'workflow interceptors', () => {
       const input = { headers: { existing: 'header' }, activityType: 'MyWorkflow#step1' };
       const next = vi.fn().mockResolvedValue( 'result' );
 
-      memoToHeadersMock.mockReturnValue( { executionContext: { id: 'ctx-1' } } );
+      memoToHeadersMock.mockReturnValue( { traceInfo: workflowInfo.memo.traceInfo, workflowDetails } );
 
       const out = await interceptor.scheduleActivity( input, next );
 
-      expect( memoToHeadersMock ).toHaveBeenCalledWith( { executionContext: { id: 'ctx-1' } } );
-      expect( input.headers ).toEqual( { existing: 'header', executionContext: { id: 'ctx-1' } } );
+      expect( memoToHeadersMock ).toHaveBeenCalledWith( {
+        traceInfo: workflowInfo.memo.traceInfo,
+        workflowDetails
+      } );
+      expect( input.headers ).toEqual( {
+        existing: 'header',
+        traceInfo: workflowInfo.memo.traceInfo,
+        workflowDetails
+      } );
       expect( next ).toHaveBeenCalledWith( input );
       expect( out ).toBe( 'result' );
     } );
@@ -77,8 +113,8 @@ describe( 'workflow interceptors', () => {
     it( 'merges stepOptions with memo.activityOptions when stepOptions exist for activityType', async () => {
       stepOptionsDefault['MyWorkflow#step1'] = { scheduleToCloseTimeout: 60 };
       workflowInfoMock.mockReturnValue( {
-        workflowType: 'MyWorkflow',
-        memo: { executionContext: {}, activityOptions: { heartbeatTimeout: 10 } }
+        ...workflowInfo,
+        memo: { traceInfo: workflowInfo.memo.traceInfo, activityOptions: { heartbeatTimeout: 10 } }
       } );
       memoToHeadersMock.mockReturnValue( {} );
       deepMergeMock.mockReturnValue( { heartbeatTimeout: 10, scheduleToCloseTimeout: 60 } );