@outputai/core 0.10.1-dev.b7b2fbe.0 → 0.10.1-next.09ed166.0

package/src/hooks/index.js

@@ -1,17 +1,17 @@
-import { messageBus } from '#bus';
-import { BusEventType, ComponentType, WORKFLOW_CATALOG } from '#consts';
+import { mainEventBus, stepEventBus } from '#bus';
+import { BusEventType } from '#consts';
 import { createChildLogger } from '#logger';
 
 const log = createChildLogger( 'Hooks' );
 
 /**
- * Invokes an external hook handler function with a try catch around it
+ * Invokes a function within a try catch and log the error
  *
  * @param {Function} fn
  * @param {any} args - Args to invoke the function with
  * @param {string} hookName - hookName to identify this hook function in the logs
  */
-const safeInvoke = async ( fn, args, hookName ) => {
+const callHookCb = async ( fn, args, hookName ) => {
   try {
     await fn( args );
   } catch ( error ) {
@@ -19,50 +19,55 @@ const safeInvoke = async ( fn, args, hookName ) => {
   }
 };
 
-/** Triggers on any errors: workflow, activity and runtime */
-export const onError = handler => {
-  messageBus.on( BusEventType.ACTIVITY_ERROR, async payload =>
-    safeInvoke( handler, { source: 'activity', ...payload }, 'onError' ) );
-  messageBus.on( BusEventType.WORKFLOW_ERROR, async payload =>
-    safeInvoke( handler, { source: 'workflow', ...payload }, 'onError' ) );
-  messageBus.on( BusEventType.RUNTIME_ERROR, async payload =>
-    safeInvoke( handler, { source: 'runtime', ...payload }, 'onError' ) );
+// General Life-cycle
+// --------------------------------------
+const onError = cb => {
+  mainEventBus.on( BusEventType.ACTIVITY_ERROR, async payload =>
+    callHookCb( cb, { source: 'activity', ...payload }, 'onError' ) );
+  mainEventBus.on( BusEventType.WORKFLOW_ERROR, async payload =>
+    callHookCb( cb, { source: 'workflow', ...payload }, 'onError' ) );
+  mainEventBus.on( BusEventType.RUNTIME_ERROR, async payload =>
+    callHookCb( cb, { source: 'runtime', ...payload }, 'onError' ) );
 };
 
-/** Listen to worker before start events */
-export const onBeforeWorkerStart = handler => messageBus.on( BusEventType.WORKER_BEFORE_START, () =>
-  safeInvoke( handler, undefined, 'onBeforeWorkerStart' ) );
+const onBeforeWorkerStart = cb => mainEventBus.on( BusEventType.WORKER_BEFORE_START, () => callHookCb( cb, undefined, 'onBeforeWorkerStart' ) );
 
-/** Catalog workflow events should not be emitted */
-const shouldEmitWorkflowEvent = workflowDetails => WORKFLOW_CATALOG !== workflowDetails.workflowType;
+// Workflow Life-cycle
+// --------------------------------------
+const onWorkflowStart = cb => mainEventBus.on( BusEventType.WORKFLOW_START, payload => callHookCb( cb, payload, 'onWorkflowStart' ) );
+const onWorkflowEnd = cb => mainEventBus.on( BusEventType.WORKFLOW_END, payload => callHookCb( cb, payload, 'onWorkflowEnd' ) );
+const onWorkflowError = cb => mainEventBus.on( BusEventType.WORKFLOW_ERROR, payload => callHookCb( cb, payload, 'onWorkflowError' ) );
 
-/** Listen to workflow start events, excludes catalog workflow */
-export const onWorkflowStart = handler => messageBus.on( BusEventType.WORKFLOW_START, ( { workflowDetails, ...eventFields } ) =>
-  shouldEmitWorkflowEvent( workflowDetails ) ? safeInvoke( handler, { workflowDetails, ...eventFields }, 'onWorkflowStart' ) : null );
+// Activity Life-cycle
+// --------------------------------------
+const onActivityStart = cb => mainEventBus.on( BusEventType.ACTIVITY_START, fields => callHookCb( cb, fields, 'onActivityStart' ) );
+const onActivityEnd = cb => mainEventBus.on( BusEventType.ACTIVITY_END, fields => callHookCb( cb, fields, 'onActivityEnd' ) );
+const onActivityError = cb => mainEventBus.on( BusEventType.ACTIVITY_ERROR, fields => callHookCb( cb, fields, 'onActivityError' ) );
 
-/** Listen to workflow end events, excludes catalog workflow */
-export const onWorkflowEnd = handler => messageBus.on( BusEventType.WORKFLOW_END, ( { workflowDetails, ...eventFields } ) =>
-  shouldEmitWorkflowEvent( workflowDetails ) ? safeInvoke( handler, { workflowDetails, ...eventFields }, 'onWorkflowEnd' ) : null );
-
-/** Listen to workflow error events, excludes catalog workflow */
-export const onWorkflowError = handler => messageBus.on( BusEventType.WORKFLOW_ERROR, ( { workflowDetails, ...eventFields } ) =>
-  shouldEmitWorkflowEvent( workflowDetails ) ? safeInvoke( handler, { workflowDetails, ...eventFields }, 'onWorkflowError' ) : null );
-
-/** Internal activities do not trigger hooks */
-const shouldEmitActivityEvent = outputActivityKind => outputActivityKind !== ComponentType.INTERNAL_STEP;
-
-/** Listen to workflow start events, excludes catalog workflow */
-export const onActivityStart = handler => messageBus.on( BusEventType.ACTIVITY_START, ( { outputActivityKind, ...eventFields } ) =>
-  shouldEmitActivityEvent( outputActivityKind ) ? safeInvoke( handler, { outputActivityKind, ...eventFields }, 'onActivityStart' ) : null );
-
-/** Listen to workflow end events, excludes catalog workflow */
-export const onActivityEnd = handler => messageBus.on( BusEventType.ACTIVITY_END, ( { outputActivityKind, ...eventFields } ) =>
-  shouldEmitActivityEvent( outputActivityKind ) ? safeInvoke( handler, { outputActivityKind, ...eventFields }, 'onActivityEnd' ) : null );
+// Generic Events
+// --------------------------------------
+/** Listen to both sdk and custom events */
+const on = ( eventName, cb ) => {
+  stepEventBus.on( `sdk:${eventName}`, payload => callHookCb( cb, payload, eventName ) );
+  stepEventBus.on( `usr:${eventName}`, payload => callHookCb( cb, payload, eventName ) );
+};
 
-/** Listen to workflow error events, excludes catalog workflow */
-export const onActivityError = handler => messageBus.on( BusEventType.ACTIVITY_ERROR, ( { outputActivityKind, ...eventFields } ) =>
-  shouldEmitActivityEvent( outputActivityKind ) ? safeInvoke( handler, { outputActivityKind, ...eventFields }, 'onActivityError' ) : null );
+/**
+ * Emits a custom event
+ * @param {string} eventName
+ * @param {any} payload
+ */
+const emit = ( eventName, payload ) => stepEventBus.emit( `usr:${eventName}`, payload );
 
-/** Generic listener for events emitted elsewhere (outside core) */
-export const on = ( eventName, handler ) => messageBus.on( `external:${eventName}`, payload =>
-  safeInvoke( handler, payload, eventName ) );
+export {
+  emit,
+  on,
+  onActivityEnd,
+  onActivityError,
+  onActivityStart,
+  onBeforeWorkerStart,
+  onError,
+  onWorkflowEnd,
+  onWorkflowError,
+  onWorkflowStart
+};

package/src/hooks/index.spec.js

@@ -1,22 +1,33 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { BusEventType, ComponentType, WORKFLOW_CATALOG } from '#consts';
+import { BusEventType } from '#consts';
 
 const logErrorMock = vi.hoisted( () => vi.fn() );
 const createChildLoggerMock = vi.hoisted( () =>
   vi.fn( () => ( { error: logErrorMock } ) )
 );
 
-const onHandlers = vi.hoisted( () => ( {} ) );
-const messageBusMock = vi.hoisted( () => ( {
+const mainOnHandlers = vi.hoisted( () => ( {} ) );
+const stepOnHandlers = vi.hoisted( () => ( {} ) );
+const mainEventBusMock = vi.hoisted( () => ( {
   on: vi.fn( ( eventType, handler ) => {
-    onHandlers[eventType] = handler;
+    mainOnHandlers[eventType] = handler;
+  } )
+} ) );
+const stepEventBusMock = vi.hoisted( () => ( {
+  emit: vi.fn( () => true ),
+  on: vi.fn( ( eventType, handler ) => {
+    stepOnHandlers[eventType] = handler;
   } )
 } ) );
 
 vi.mock( '#logger', () => ( { createChildLogger: createChildLoggerMock } ) );
-vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+vi.mock( '#bus', () => ( {
+  mainEventBus: mainEventBusMock,
+  stepEventBus: stepEventBusMock
+} ) );
 
 import {
+  emit,
   on,
   onActivityEnd,
   onActivityError,
@@ -38,11 +49,6 @@ const workflowDetails = {
   attempt: 1
 };
 
-const catalogWorkflowDetails = {
-  ...workflowDetails,
-  workflowType: WORKFLOW_CATALOG
-};
-
 const activityInfo = {
   activityId: 'act-1',
   activityType: 'wf#step',
@@ -61,8 +67,11 @@ const aggregations = {
 describe( 'hooks/index', () => {
   beforeEach( () => {
     vi.clearAllMocks();
-    Object.keys( onHandlers ).forEach( k => {
-      delete onHandlers[k];
+    Object.keys( mainOnHandlers ).forEach( k => {
+      delete mainOnHandlers[k];
+    } );
+    Object.keys( stepOnHandlers ).forEach( k => {
+      delete stepOnHandlers[k];
     } );
   } );
 
@@ -71,9 +80,9 @@ describe( 'hooks/index', () => {
       const handler = vi.fn().mockResolvedValue( undefined );
       onError( handler );
 
-      expect( messageBusMock.on ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, expect.any( Function ) );
-      expect( messageBusMock.on ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, expect.any( Function ) );
-      expect( messageBusMock.on ).toHaveBeenCalledWith( BusEventType.RUNTIME_ERROR, expect.any( Function ) );
+      expect( mainEventBusMock.on ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, expect.any( Function ) );
+      expect( mainEventBusMock.on ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, expect.any( Function ) );
+      expect( mainEventBusMock.on ).toHaveBeenCalledWith( BusEventType.RUNTIME_ERROR, expect.any( Function ) );
     } );
 
     it( 'invokes handler with activity-shaped payload, forwarding bus fields', async () => {
@@ -81,7 +90,7 @@ describe( 'hooks/index', () => {
       onError( handler );
 
       const err = new Error( 'act-fail' );
-      await onHandlers[BusEventType.ACTIVITY_ERROR]( {
+      await mainOnHandlers[BusEventType.ACTIVITY_ERROR]( {
         eventId: 'evt-act-1',
         eventDate,
         activityInfo,
@@ -108,7 +117,7 @@ describe( 'hooks/index', () => {
       onError( handler );
 
       const err = new Error( 'wf-fail' );
-      await onHandlers[BusEventType.WORKFLOW_ERROR]( {
+      await mainOnHandlers[BusEventType.WORKFLOW_ERROR]( {
         eventId: 'evt-wf-1',
         eventDate,
         workflowDetails,
@@ -131,7 +140,7 @@ describe( 'hooks/index', () => {
       onError( handler );
 
       const error = new Error( 'rt' );
-      await onHandlers[BusEventType.RUNTIME_ERROR]( { eventId: 'evt-rt-1', eventDate, error } );
+      await mainOnHandlers[BusEventType.RUNTIME_ERROR]( { eventId: 'evt-rt-1', eventDate, error } );
 
       expect( handler ).toHaveBeenCalledWith( { eventId: 'evt-rt-1', eventDate, source: 'runtime', error } );
     } );
@@ -142,68 +151,35 @@ describe( 'hooks/index', () => {
       const handler = vi.fn().mockResolvedValue( undefined );
       onBeforeWorkerStart( handler );
 
-      expect( messageBusMock.on ).toHaveBeenCalledWith( BusEventType.WORKER_BEFORE_START, expect.any( Function ) );
-      await onHandlers[BusEventType.WORKER_BEFORE_START]();
+      expect( mainEventBusMock.on ).toHaveBeenCalledWith( BusEventType.WORKER_BEFORE_START, expect.any( Function ) );
+      await mainOnHandlers[BusEventType.WORKER_BEFORE_START]();
 
       expect( handler ).toHaveBeenCalledWith( undefined );
     } );
   } );
 
-  describe( 'onWorkflowStart', () => {
-    it( 'skips catalog workflow and forwards bus fields for real workflows', async () => {
-      const handler = vi.fn().mockResolvedValue( undefined );
-      onWorkflowStart( handler );
-
-      await Promise.resolve( onHandlers[BusEventType.WORKFLOW_START]( {
-        eventId: 'evt-ignored', eventDate, workflowDetails: catalogWorkflowDetails
-      } ) );
-      expect( handler ).not.toHaveBeenCalled();
-
-      await Promise.resolve( onHandlers[BusEventType.WORKFLOW_START]( {
-        eventId: 'evt-start-1', eventDate, workflowDetails, extra: 'passthrough'
-      } ) );
-      expect( handler ).toHaveBeenCalledWith( {
-        eventId: 'evt-start-1', eventDate, workflowDetails, extra: 'passthrough'
-      } );
-    } );
-  } );
-
-  describe( 'onWorkflowEnd', () => {
-    it( 'skips catalog workflow and forwards bus fields for real workflows', async () => {
-      const handler = vi.fn().mockResolvedValue( undefined );
-      onWorkflowEnd( handler );
-
-      await Promise.resolve( onHandlers[BusEventType.WORKFLOW_END]( {
-        eventId: 'evt-ignored', eventDate, workflowDetails: catalogWorkflowDetails
-      } ) );
-      expect( handler ).not.toHaveBeenCalled();
-
-      await Promise.resolve( onHandlers[BusEventType.WORKFLOW_END]( {
-        eventId: 'evt-end-1', eventDate, workflowDetails, extra: 'passthrough'
-      } ) );
-      expect( handler ).toHaveBeenCalledWith( {
-        eventId: 'evt-end-1', eventDate, workflowDetails, extra: 'passthrough'
-      } );
-    } );
-  } );
+  describe( 'workflow lifecycle hooks', () => {
+    const cases = [
+      [ 'onWorkflowStart', onWorkflowStart, BusEventType.WORKFLOW_START, {} ],
+      [ 'onWorkflowEnd', onWorkflowEnd, BusEventType.WORKFLOW_END, {} ],
+      [ 'onWorkflowError', onWorkflowError, BusEventType.WORKFLOW_ERROR, { error: new Error( 'workflow failed' ) } ]
+    ];
 
-  describe( 'onWorkflowError', () => {
-    it( 'skips catalog workflow and forwards bus fields for real workflows', async () => {
+    it.each( cases )( '%s forwards bus fields', async ( _name, registerHook, eventType, extraFields ) => {
       const handler = vi.fn().mockResolvedValue( undefined );
-      const err = new Error( 'wf' );
-      onWorkflowError( handler );
+      const payload = {
+        eventId: 'evt-workflow-1',
+        eventDate,
+        workflowDetails,
+        extra: 'passthrough',
+        ...extraFields
+      };
+      registerHook( handler );
 
-      await Promise.resolve( onHandlers[BusEventType.WORKFLOW_ERROR]( {
-        eventId: 'evt-ignored', eventDate, workflowDetails: catalogWorkflowDetails, error: err
-      } ) );
-      expect( handler ).not.toHaveBeenCalled();
+      expect( mainEventBusMock.on ).toHaveBeenCalledWith( eventType, expect.any( Function ) );
+      await mainOnHandlers[eventType]( payload );
 
-      await Promise.resolve( onHandlers[BusEventType.WORKFLOW_ERROR]( {
-        eventId: 'evt-err-1', eventDate, workflowDetails, error: err, extra: 'passthrough'
-      } ) );
-      expect( handler ).toHaveBeenCalledWith( {
-        eventId: 'evt-err-1', eventDate, workflowDetails, error: err, extra: 'passthrough'
-      } );
+      expect( handler ).toHaveBeenCalledWith( payload );
     } );
   } );
 
@@ -214,53 +190,49 @@ describe( 'hooks/index', () => {
       [ 'onActivityError', onActivityError, BusEventType.ACTIVITY_ERROR, { error: new Error( 'activity failed' ) } ]
     ];
 
-    it.each( cases )( '%s skips internal activities and forwards bus fields', async ( _name, registerHook, eventType, extraFields = {} ) => {
+    it.each( cases )( '%s forwards internal activity bus fields', async ( _name, registerHook, eventType, extraFields = {} ) => {
       const handler = vi.fn().mockResolvedValue( undefined );
-      registerHook( handler );
-
-      expect( messageBusMock.on ).toHaveBeenCalledWith( eventType, expect.any( Function ) );
-
-      await Promise.resolve( onHandlers[eventType]( {
-        eventId: 'evt-ignored',
-        eventDate,
-        activityInfo,
-        workflowDetails,
-        outputActivityKind: ComponentType.INTERNAL_STEP,
-        ...extraFields
-      } ) );
-      expect( handler ).not.toHaveBeenCalled();
-
-      await Promise.resolve( onHandlers[eventType]( {
+      const payload = {
         eventId: 'evt-activity-1',
         eventDate,
         activityInfo,
         workflowDetails,
-        outputActivityKind: ComponentType.STEP,
+        outputActivityKind: 'internal_step',
         extra: 'passthrough',
         ...extraFields
-      } ) );
+      };
+      registerHook( handler );
 
-      expect( handler ).toHaveBeenCalledWith( {
-        eventId: 'evt-activity-1',
-        eventDate,
-        activityInfo,
-        workflowDetails,
-        outputActivityKind: ComponentType.STEP,
-        extra: 'passthrough',
-        ...extraFields
-      } );
+      expect( mainEventBusMock.on ).toHaveBeenCalledWith( eventType, expect.any( Function ) );
+      await mainOnHandlers[eventType]( payload );
+
+      expect( handler ).toHaveBeenCalledWith( payload );
     } );
   } );
 
   describe( 'on', () => {
-    it( 'subscribes to external event channel and forwards payload', async () => {
+    it( 'subscribes to SDK and user event channels and forwards payloads', async () => {
       const handler = vi.fn().mockResolvedValue( undefined );
       on( 'myEvent', handler );
 
-      expect( messageBusMock.on ).toHaveBeenCalledWith( 'external:myEvent', expect.any( Function ) );
-      await onHandlers['external:myEvent']( { foo: 1 } );
+      expect( stepEventBusMock.on ).toHaveBeenCalledWith( 'sdk:myEvent', expect.any( Function ) );
+      expect( stepEventBusMock.on ).toHaveBeenCalledWith( 'usr:myEvent', expect.any( Function ) );
+      await stepOnHandlers['sdk:myEvent']( { payload: { source: 'sdk' } } );
+      await stepOnHandlers['usr:myEvent']( { payload: { source: 'user' } } );
+
+      expect( handler ).toHaveBeenNthCalledWith( 1, { payload: { source: 'sdk' } } );
+      expect( handler ).toHaveBeenNthCalledWith( 2, { payload: { source: 'user' } } );
+    } );
+  } );
+
+  describe( 'emit', () => {
+    it( 'emits payloads on the user event channel', () => {
+      const payload = { foo: 1 };
+
+      const emitted = emit( 'myEvent', payload );
 
-      expect( handler ).toHaveBeenCalledWith( { foo: 1 } );
+      expect( stepEventBusMock.emit ).toHaveBeenCalledWith( 'usr:myEvent', payload );
+      expect( emitted ).toBe( true );
     } );
   } );
 } );

package/src/sdk/runtime/events.d.ts

@@ -2,14 +2,12 @@
  * Tools to interact with Events
  */
 export declare const Event: {
+
   /**
-   * Emits a custom event on the in-process message bus.
-   *
-   * When called inside an Output activity context, the framework automatically
-   * attaches `activityInfo`, `workflowDetails`, and `outputActivityKind` onto the emitted payload.
+   * Emits an event on step message bus.
    *
    * @param eventName - The name of the event to emit
-   * @param payload - An optional payload to send to the event
+   * @param payload - An optional payload to send to the event.
    */
-  emit( eventName: string, payload?: object ): void;
+  emit( eventName: string, payload?: object ): boolean;
 };

package/src/sdk/runtime/events.js

@@ -1,18 +1,5 @@
-import { messageBus } from '#bus';
-import { Storage } from '#async_storage';
+import { stepEventBus } from '#bus';
 
 export const Event = {
-  emit: ( eventName, payload ) => {
-    const ctx = Storage.load();
-
-    messageBus.emit( `external:${eventName}`, {
-      ...payload ?? {},
-      ...( ctx && {
-        activityInfo: ctx.activityInfo,
-        workflowDetails: ctx.workflowDetails,
-        outputActivityKind: ctx.outputActivityKind
-      } )
-    } );
-  }
+  emit: ( eventName, payload ) => stepEventBus.emit( `sdk:${eventName}`, payload )
 };
-

package/src/sdk/runtime/events.spec.js

@@ -1,118 +1,40 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
-const loadMock = vi.hoisted( () => vi.fn() );
 const emitMock = vi.hoisted( () => vi.fn() );
 
-vi.mock( '#async_storage', () => ( {
-  Storage: { load: loadMock }
-} ) );
-
 vi.mock( '#bus', () => ( {
-  messageBus: { emit: emitMock }
+  stepEventBus: { emit: emitMock }
 } ) );
 
 import { Event } from './events.js';
 
-// `eventId` stamping is the bus layer's responsibility (see bus.spec.js).
-// Assertions here use `objectContaining` so they don't have to know about that enrichment.
 describe( 'Event.emit', () => {
   beforeEach( () => {
     vi.clearAllMocks();
   } );
 
-  it( 'forwards activityInfo, workflowDetails, and outputActivityKind from storage', () => {
-    const activityInfo = {
-      activityId: 'act-1',
-      activityType: 'step',
-      workflowExecution: { workflowId: 'wf-1', runId: 'run-1' },
-      workflowType: 'workflow'
-    };
-    const workflowDetails = {
-      workflowId: 'wf-1',
-      runId: 'run-1',
-      workflowType: 'workflow'
-    };
-    loadMock.mockReturnValue( {
-      activityInfo,
-      workflowDetails,
-      outputActivityKind: 'step'
-    } );
+  it( 'forwards class instance payloads unchanged', () => {
+    class Payload {
+      value = 'test';
+    }
+    const payload = new Payload();
 
-    Event.emit( 'cost:llm:request', { modelId: 'gpt-4o' } );
+    Event.emit( 'test:event', payload );
 
-    expect( emitMock ).toHaveBeenCalledWith( 'external:cost:llm:request', expect.objectContaining( {
-      activityInfo,
-      workflowDetails,
-      outputActivityKind: 'step',
-      modelId: 'gpt-4o'
-    } ) );
+    expect( emitMock ).toHaveBeenCalledWith( 'sdk:test:event', payload );
   } );
 
-  it( 'emits payload without context when storage is missing', () => {
-    loadMock.mockReturnValue( undefined );
+  it( 'emits plain object payloads on the SDK event channel', () => {
+    const payload = { modelId: 'gpt-4o' };
 
-    Event.emit( 'foo:bar', { x: 1 } );
+    Event.emit( 'cost:llm:request', payload );
 
-    expect( emitMock ).toHaveBeenCalledWith( 'external:foo:bar', { x: 1 } );
+    expect( emitMock ).toHaveBeenCalledWith( 'sdk:cost:llm:request', payload );
   } );
 
-  it( 'handles missing payload', () => {
-    const activityInfo = {
-      activityId: 'act-2',
-      activityType: 'step',
-      workflowExecution: { workflowId: 'wf-2', runId: 'run-2' },
-      workflowType: 'workflow'
-    };
-    const workflowDetails = {
-      workflowId: 'wf-2',
-      runId: 'run-2',
-      workflowType: 'workflow'
-    };
-    loadMock.mockReturnValue( {
-      activityInfo,
-      workflowDetails,
-      outputActivityKind: 'step'
-    } );
-
+  it( 'forwards a missing payload as undefined', () => {
     Event.emit( 'lifecycle:start' );
 
-    expect( emitMock ).toHaveBeenCalledWith( 'external:lifecycle:start', expect.objectContaining( {
-      activityInfo,
-      workflowDetails,
-      outputActivityKind: 'step'
-    } ) );
-  } );
-
-  it( 'does not let payload override activityInfo, workflowDetails, or outputActivityKind', () => {
-    const activityInfo = {
-      activityId: 'act-3',
-      activityType: 'step',
-      workflowExecution: { workflowId: 'wf-3', runId: 'run-3' },
-      workflowType: 'workflow'
-    };
-    const workflowDetails = {
-      workflowId: 'wf-3',
-      runId: 'run-3',
-      workflowType: 'workflow'
-    };
-    loadMock.mockReturnValue( {
-      activityInfo,
-      workflowDetails,
-      outputActivityKind: 'step'
-    } );
-
-    Event.emit( 'cost:http:request', {
-      activityInfo: { activityId: 'should-be-overridden' },
-      workflowDetails: { workflowId: 'should-be-overridden' },
-      outputActivityKind: 'should-be-overridden',
-      url: 'https://example.com'
-    } );
-
-    expect( emitMock ).toHaveBeenCalledWith( 'external:cost:http:request', expect.objectContaining( {
-      activityInfo,
-      workflowDetails,
-      outputActivityKind: 'step',
-      url: 'https://example.com'
-    } ) );
+    expect( emitMock ).toHaveBeenCalledWith( 'sdk:lifecycle:start', undefined );
   } );
 } );

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

@@ -13,7 +13,7 @@ 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 { BusEventType } from '#consts';
 import { setupTelemetry } from './telemetry.js';
 import { TemporalConnectionMonitor } from './connection_monitor.js';
@@ -60,7 +60,7 @@ const execute = async () => {
   log.info( 'Loading activities...', { callerDir } );
   const { activities } = await loadActivities( callerDir, workflows );
 
-  messageBus.emit( BusEventType.WORKER_BEFORE_START );
+  mainEventBus.emit( BusEventType.WORKER_BEFORE_START );
   bootstrapFetchProxy();
 
   log.info( 'Initializing tracing...' );
@@ -218,7 +218,7 @@ execute()
   .catch( error => {
     log.error( 'Fatal error', { error: error.message, stack: error.stack } );
 
-    messageBus.emit( BusEventType.RUNTIME_ERROR, { error } );
+    mainEventBus.emit( BusEventType.RUNTIME_ERROR, { error } );
 
     const timeToFlushEvent = configs.processFailureShutdownDelay;
     log.info( `Exiting in ${timeToFlushEvent}ms` );