@outputai/core 0.8.2-next.ec4c07d.0 → 0.8.2-next.edf06bb.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.8.2-next.ec4c07d.0",
+  "version": "0.8.2-next.edf06bb.0",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {

package/src/hooks/index.d.ts

@@ -79,47 +79,6 @@ export interface WorkflowDetails {
   attempt: number;
 }
 
-/**
- * Attribute totals collected while an activity executes.
- */
-export interface Aggregations {
-  /** Cost totals collected from HTTP request cost and LLM usage attributes. */
-  cost: {
-    total: number;
-  };
-  /** Token totals collected from LLM usage attributes. */
-  tokens: {
-    [tokenType: string]: number | undefined;
-    total: number;
-  };
-  /** HTTP request count totals. */
-  httpRequests: {
-    total: number;
-  };
-}
-
-/**
- * Common lifecycle hook payload fields for events associated with a workflow.
- */
-export interface HookPayloadBase {
-  /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
-  eventId: string;
-  /** Timestamp of the event */
-  eventDate: number;
-  /** Information about the current workflow execution */
-  workflowDetails: WorkflowDetails;
-}
-
-/**
- * Common hook payload fields for events associated with an activity.
- */
-export interface ActivityPayloadBase extends HookPayloadBase {
-  /** Temporal's activityInfo(). */
-  activityInfo: Info;
-  /** Output component kind for the activity, e.g. step or evaluator. */
-  outputActivityKind: string;
-}
-
 /**
  * Payload passed to the onError() handler when a workflow, activity or runtime error occurs.
  */
@@ -136,8 +95,6 @@ export interface ErrorHookPayload {
   activityInfo?: Info;
   /** Output component kind for the activity, e.g. step, evaluator, or internal_step. */
   outputActivityKind?: string;
-  /** Attribute totals collected during the activity execution. */
-  aggregations?: Aggregations | null;
   /** The error thrown. */
   error: Error;
 }
@@ -145,45 +102,37 @@ export interface ErrorHookPayload {
 /**
  * Payload passed to the onWorkflowStart() handler when a workflow run begins.
  */
-export type WorkflowStartHookPayload = HookPayloadBase;
-
-/**
- * Payload passed to the onWorkflowEnd() handler when a workflow run completes successfully.
- */
-export type WorkflowEndHookPayload = HookPayloadBase;
-
-/**
- * Payload passed to the onWorkflowError() handler when a workflow run fails.
- */
-export interface WorkflowErrorHookPayload extends HookPayloadBase {
-  /** The error thrown. */
-  error: Error;
+export interface WorkflowStartHookPayload {
+  /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
+  eventId: string;
+  /** Timestamp of the event */
+  eventDate: number;
+  /** Information about the current workflow execution */
+  workflowDetails: WorkflowDetails;
 }
 
 /**
- * Common activity lifecycle hook payload fields.
- */
-export type ActivityHookPayload = ActivityPayloadBase;
-
-/**
- * Payload passed to the onActivityStart() handler when an activity starts.
- */
-export type ActivityStartHookPayload = ActivityHookPayload;
-
-/**
- * Payload passed to the onActivityEnd() handler when an activity completes successfully.
+ * Payload passed to the onWorkflowEnd() handler when a workflow run completes successfully.
  */
-export interface ActivityEndHookPayload extends ActivityHookPayload {
-  /** Attribute totals collected during the activity execution. */
-  aggregations: Aggregations | null;
+export interface WorkflowEndHookPayload {
+  /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
+  eventId: string;
+  /** Timestamp of the event */
+  eventDate: number;
+  /** Information about the current workflow execution */
+  workflowDetails: WorkflowDetails;
 }
 
 /**
- * Payload passed to the onActivityError() handler when an activity fails.
+ * Payload passed to the onWorkflowError() handler when a workflow run fails.
  */
-export interface ActivityErrorHookPayload extends ActivityHookPayload {
-  /** Attribute totals collected during the activity execution. */
-  aggregations: Aggregations | null;
+export interface WorkflowErrorHookPayload {
+  /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
+  eventId: string;
+  /** Timestamp of the event */
+  eventDate: number;
+  /** Information about the current workflow execution */
+  workflowDetails: WorkflowDetails;
   /** The error thrown. */
   error: Error;
 }
@@ -230,37 +179,16 @@ export declare function onWorkflowEnd( handler: ( payload: WorkflowEndHookPayloa
  */
 export declare function onWorkflowError( handler: ( payload: WorkflowErrorHookPayload ) => void ): void;
 
-/**
- * Register a handler to be invoked when an activity starts.
- *
- * Excludes internal activities.
- *
- * @param handler - Function called with the activity start payload.
- */
-export declare function onActivityStart( handler: ( payload: ActivityStartHookPayload ) => void ): void;
-
-/**
- * Register a handler to be invoked when an activity completes successfully.
- *
- * Excludes internal activities.
- *
- * @param handler - Function called with the activity end payload.
- */
-export declare function onActivityEnd( handler: ( payload: ActivityEndHookPayload ) => void ): void;
-
-/**
- * Register a handler to be invoked when an activity fails.
- *
- * Excludes internal activities.
- *
- * @param handler - Function called with the activity error payload.
- */
-export declare function onActivityError( handler: ( payload: ActivityErrorHookPayload ) => void ): void;
-
 /**
  * Framework-managed envelope added to payloads passed to on() handlers.
  */
-export interface OnHookEnvelope extends HookPayloadBase {
+export interface OnHookEnvelope {
+  /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
+  eventId: string;
+  /** Timestamp of the event */
+  eventDate: number;
+  /** Information about the current workflow execution */
+  workflowDetails: WorkflowDetails;
   /** Temporal's activityInfo(). */
   activityInfo: Info;
   /** Output component kind for the activity, e.g. step, evaluator, or internal_step. */

package/src/hooks/index.js

@@ -1,5 +1,5 @@
 import { messageBus } from '#bus';
-import { BusEventType, ComponentType, WORKFLOW_CATALOG } from '#consts';
+import { BusEventType, WORKFLOW_CATALOG } from '#consts';
 import { createChildLogger } from '#logger';
 
 const log = createChildLogger( 'Hooks' );
@@ -48,21 +48,6 @@ export const onWorkflowEnd = handler => messageBus.on( BusEventType.WORKFLOW_END
 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 );
-
-/** 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 );
-
 /** Generic listener for events emitted elsewhere (outside core) */
 export const on = ( eventName, handler ) => messageBus.on( `external:${eventName}`, payload =>
   safeInvoke( handler, payload, eventName ) );

package/src/hooks/index.spec.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { BusEventType, ComponentType, WORKFLOW_CATALOG } from '#consts';
+import { BusEventType, WORKFLOW_CATALOG } from '#consts';
 
 const logErrorMock = vi.hoisted( () => vi.fn() );
 const createChildLoggerMock = vi.hoisted( () =>
@@ -18,9 +18,6 @@ vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
 
 import {
   on,
-  onActivityEnd,
-  onActivityError,
-  onActivityStart,
   onBeforeWorkerStart,
   onError,
   onWorkflowEnd,
@@ -52,12 +49,6 @@ const activityInfo = {
 
 const eventDate = 1710000001234;
 
-const aggregations = {
-  cost: { total: 0 },
-  tokens: { total: 0 },
-  httpRequests: { total: 1 }
-};
-
 describe( 'hooks/index', () => {
   beforeEach( () => {
     vi.clearAllMocks();
@@ -207,51 +198,6 @@ describe( 'hooks/index', () => {
     } );
   } );
 
-  describe( 'activity lifecycle hooks', () => {
-    const cases = [
-      [ 'onActivityStart', onActivityStart, BusEventType.ACTIVITY_START, undefined ],
-      [ 'onActivityEnd', onActivityEnd, BusEventType.ACTIVITY_END, { aggregations } ],
-      [ '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 = {} ) => {
-      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]( {
-        eventId: 'evt-activity-1',
-        eventDate,
-        activityInfo,
-        workflowDetails,
-        outputActivityKind: ComponentType.STEP,
-        extra: 'passthrough',
-        ...extraFields
-      } ) );
-
-      expect( handler ).toHaveBeenCalledWith( {
-        eventId: 'evt-activity-1',
-        eventDate,
-        activityInfo,
-        workflowDetails,
-        outputActivityKind: ComponentType.STEP,
-        extra: 'passthrough',
-        ...extraFields
-      } );
-    } );
-  } );
-
   describe( 'on', () => {
     it( 'subscribes to external event channel and forwards payload', async () => {
       const handler = vi.fn().mockResolvedValue( undefined );

package/src/interface/index.d.ts

@@ -7,4 +7,4 @@ export * from './step.js';
 export * from './evaluator.js';
 export * from './workflow.js';
 export * from './evaluation_result.js';
-export * from './logger.js';
+export * as Logger from './logger.js';

package/src/interface/index.js

@@ -10,7 +10,7 @@ import { step } from './step.js';
 import { workflow } from './workflow.js';
 import { executeInParallel } from './workflow_utils.js';
 import { sendHttpRequest, sendPostRequestAndAwaitWebhook } from './webhook.js';
-import { Logger } from './logger.js';
+import * as Logger from './logger.js';
 
 export {
   evaluator,

package/src/interface/logger.d.ts

@@ -1,61 +1,53 @@
-type Logger = {
-  /**
-   * Log an error (level 0)
-   * @param message Log message
-   * @param metadata Additional information to be displayed
-   */
-  error( message: string, metadata?: Record<string, unknown> ) : void,
-
-  /**
-   * Log a warn (level 1)
-   * @param message Log message
-   * @param metadata Additional information to be displayed
-   */
-  warn( message: string, metadata?: Record<string, unknown> ) : void,
+/**
+ * Additional structured fields attached to a log record.
+ */
+export type LogMetadata = Record<string, unknown>;
 
-  /**
-   * Log an info (level 2)
-   * @param message Log message
-   * @param metadata Additional information to be displayed
-   */
-  info( message: string, metadata?: Record<string, unknown> ) : void,
+/**
+ * Log an error (level 0)
+ * @param message Log message
+ * @param metadata Additional information to be displayed
+ */
+export declare function error( message: string, metadata?: LogMetadata ) : void;
 
-  /**
-   * Log http (level 3)
-   * @param message Log message
-   * @param metadata Additional information to be displayed
-   */
-  http( message: string, metadata?: Record<string, unknown> ) : void,
+/**
+ * Log a warn (level 1)
+ * @param message Log message
+ * @param metadata Additional information to be displayed
+ */
+export declare function warn( message: string, metadata?: LogMetadata ) : void;
 
-  /**
-   * Log verbose (level 4)
-   * @param message Log message
-   * @param metadata Additional information to be displayed
-   */
-  verbose( message: string, metadata?: Record<string, unknown> ) : void,
+/**
+ * Log an info (level 2)
+ * @param message Log message
+ * @param metadata Additional information to be displayed
+ */
+export declare function info( message: string, metadata?: LogMetadata ) : void;
 
-  /**
-   * Log debug (level 5)
-   * @param message Log message
-   * @param metadata Additional information to be displayed
-   */
-  debug( message: string, metadata?: Record<string, unknown> ) : void,
+/**
+ * Log http (level 3)
+ * @param message Log message
+ * @param metadata Additional information to be displayed
+ */
+export declare function http( message: string, metadata?: LogMetadata ) : void;
 
-  /**
-   * Log silly (level 6)
-   * @param message Log message
-   * @param metadata Additional information to be displayed
-   */
-  silly( message: string, metadata?: Record<string, unknown> ) : void,
+/**
+ * Log verbose (level 4)
+ * @param message Log message
+ * @param metadata Additional information to be displayed
+ */
+export declare function verbose( message: string, metadata?: LogMetadata ) : void;
 
-  /**
-   * Creates a new Logger with a namespace value preset for all emitted logs.
-   * @param namespace
-   */
-  createLogger( namespace: string ) : Logger
-};
+/**
+ * Log debug (level 5)
+ * @param message Log message
+ * @param metadata Additional information to be displayed
+ */
+export declare function debug( message: string, metadata?: LogMetadata ) : void;
 
 /**
- * Logger tool. Can be used in activities or workflows. Logs together with the framework's own logs.
+ * Log silly (level 6)
+ * @param message Log message
+ * @param metadata Additional information to be displayed
  */
-export declare const Logger : Logger;
+export declare function silly( message: string, metadata?: LogMetadata ) : void;

package/src/interface/logger.js

@@ -9,6 +9,7 @@ const reservedMetadataFields = new Set( [
   'level',
   'message',
   'metadata',
+  'namespace',
   'splat',
   'stack',
   'timestamp',
@@ -25,7 +26,6 @@ const reservedMetadataFields = new Set( [
 // This is inoffensive and can be used outside workflow sandbox
 const sinks = proxySinks();
 
-// Winston uses npm levels by default: https://github.com/winstonjs/winston#logging-levels
 // Convert npm log levels to console levels
 const levelToConsole = {
   error: 'error',
@@ -36,17 +36,14 @@ const levelToConsole = {
   debug: 'debug',
   silly: 'log'
 };
-const levels = Object.keys( levelToConsole );
 
 /** Drops reserved keys from object */
 const removeReservedFields = obj => Object.fromEntries( Object.entries( obj ).filter( ( [ k ] ) => !reservedMetadataFields.has( k ) ) );
 
-/** Dispatch the log message downstream */
-const log = ( level, namespace, message, metadata ) => {
-  const baseMetadata = namespace ? { namespace } : {};
+const log = ( level, message, metadata ) => {
   const sanitized = {
     message: String( message ),
-    metadata: { ...baseMetadata, ...isPlainObject( metadata ) ? removeReservedFields( metadata ) : {} }
+    ...( isPlainObject( metadata ) && { metadata: removeReservedFields( metadata ) } )
   };
 
   // When inside workflow, use sinks to send logs out
@@ -61,13 +58,11 @@ const log = ( level, namespace, message, metadata ) => {
   }
 };
 
-/** Creates a new logger. It uses the npm levels, and for each level, bind the log function */
-const createLogger = namespace => ( {
-  ...Object.fromEntries( levels.map( l => [ l, log.bind( null, l, namespace ) ] ) ),
-  createLogger
-} );
-
-/** This is the default logger instance */
-const logger = createLogger( null );
-
-export { logger as Logger };
+// Winston uses npm levels by default: https://github.com/winstonjs/winston#logging-levels
+export const error = log.bind( null, 'error' );
+export const warn = log.bind( null, 'warn' );
+export const info = log.bind( null, 'info' );
+export const http = log.bind( null, 'http' );
+export const verbose = log.bind( null, 'verbose' );
+export const debug = log.bind( null, 'debug' );
+export const silly = log.bind( null, 'silly' );

package/src/interface/logger.spec.js

@@ -34,7 +34,7 @@ const consoleMethodsByLevel = {
   silly: 'log'
 };
 
-const loadLogger = async () => ( await import( './logger.js' ) ).Logger;
+const loadLogger = async () => import( './logger.js' );
 
 describe( 'interface/logger', () => {
   beforeEach( () => {
@@ -135,38 +135,4 @@ describe( 'interface/logger', () => {
     expect( consoleMocks.log ).toHaveBeenCalledTimes( 3 );
     expect( workflowLogMock ).not.toHaveBeenCalled();
   } );
-
-  it( 'creates a logger with a default namespace for every level', async () => {
-    const logger = await loadLogger();
-    inWorkflowContextMock.mockReturnValue( true );
-
-    const namespacedLogger = logger.createLogger( 'Namespace' );
-    logLevels.forEach( level => {
-      namespacedLogger[level]( `${level} message`, { requestId: level } );
-    } );
-
-    logLevels.forEach( ( level, index ) => {
-      expect( workflowLogMock ).toHaveBeenNthCalledWith( index + 1, {
-        level,
-        message: `${level} message`,
-        metadata: {
-          namespace: 'Namespace',
-          requestId: level
-        }
-      } );
-    } );
-  } );
-
-  it( 'lets log metadata override the default namespace', async () => {
-    const logger = await loadLogger();
-    inWorkflowContextMock.mockReturnValue( true );
-
-    logger.createLogger( 'Default namespace' ).info( 'message', { namespace: 'Inline namespace' } );
-
-    expect( workflowLogMock ).toHaveBeenCalledWith( {
-      level: 'info',
-      message: 'message',
-      metadata: { namespace: 'Inline namespace' }
-    } );
-  } );
 } );

package/src/worker/interceptors/activity.js

@@ -77,18 +77,21 @@ 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 } );
+      messageBus.emit( BusEventType.ACTIVITY_END, { activityInfo, workflowDetails, outputActivityKind } );
       Tracing.addEventEnd( { id: activityId, details: output, traceInfo } );
 
-      return { [ACTIVITY_WRAPPER_VERSION_FIELD]: 1, output, aggregations };
+      return {
+        [ACTIVITY_WRAPPER_VERSION_FIELD]: 1,
+        output,
+        aggregations: state.attributes.length > 0 ? aggregateAttributes( state.attributes ) : null
+      };
 
     } catch ( error ) {
-      const aggregations = state.attributes.length > 0 ? aggregateAttributes( state.attributes ) : null;
-      messageBus.emit( BusEventType.ACTIVITY_ERROR, { activityInfo, aggregations, workflowDetails, outputActivityKind, error } );
+      messageBus.emit( BusEventType.ACTIVITY_ERROR, { activityInfo, workflowDetails, outputActivityKind, error } );
       Tracing.addEventError( { id: activityId, details: error, traceInfo } );
 
+      const aggregations = state.attributes.length > 0 ? aggregateAttributes( state.attributes ) : null;
+
       throw aggregations ? buildApplicationFailureWithDetails( error, { aggregations } ) : error;
     } finally {
       clearInterval( state.heartbeat );

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

@@ -100,12 +100,6 @@ const httpRequestAttribute = {
   requestId: 'req-1'
 };
 
-const httpRequestAggregations = {
-  cost: { total: 0 },
-  tokens: { total: 0 },
-  httpRequests: { total: 1 }
-};
-
 describe( 'ActivityExecutionInterceptor', () => {
   beforeEach( () => {
     vi.clearAllMocks();
@@ -142,7 +136,7 @@ describe( 'ActivityExecutionInterceptor', () => {
     );
     expect( messageBusEmitMock ).toHaveBeenCalledWith(
       BusEventType.ACTIVITY_END,
-      { activityInfo: activityInfoMock, aggregations: null, workflowDetails: workflowDetailsMock, outputActivityKind: 'step' }
+      { activityInfo: activityInfoMock, workflowDetails: workflowDetailsMock, outputActivityKind: 'step' }
     );
     expect( addEventStartMock ).toHaveBeenCalledWith( {
       id: 'act-1',
@@ -195,16 +189,14 @@ describe( 'ActivityExecutionInterceptor', () => {
 
     await expect( interceptor.execute( makeInput(), next ) ).resolves.toEqual( {
       output: { result: 'ok' },
-      aggregations: httpRequestAggregations,
+      aggregations: {
+        cost: { total: 0 },
+        tokens: { total: 0 },
+        httpRequests: { total: 1 }
+      },
       [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
     } );
 
-    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, {
-      activityInfo: activityInfoMock,
-      aggregations: httpRequestAggregations,
-      workflowDetails: workflowDetailsMock,
-      outputActivityKind: 'step'
-    } );
   } );
 
   it( 'stores collected aggregations in ApplicationFailure details after failed execution', async () => {
@@ -223,17 +215,15 @@ describe( 'ActivityExecutionInterceptor', () => {
       message: 'step failed',
       type: 'Error',
       details: [ {
-        aggregations: httpRequestAggregations
+        aggregations: {
+          cost: { total: 0 },
+          tokens: { total: 0 },
+          httpRequests: { total: 1 }
+        }
       } ],
       cause: error
     } );
-    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
-      activityInfo: activityInfoMock,
-      aggregations: httpRequestAggregations,
-      workflowDetails: workflowDetailsMock,
-      outputActivityKind: 'step',
-      error
-    } );
+    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, expect.objectContaining( { error } ) );
     expect( addEventErrorMock ).toHaveBeenCalledOnce();
     expect( addEventEndMock ).not.toHaveBeenCalled();
   } );
@@ -253,7 +243,13 @@ describe( 'ActivityExecutionInterceptor', () => {
 
     expect( thrown.details ).toEqual( [
       { domain: { reason: 'bad-input' } },
-      { aggregations: httpRequestAggregations }
+      {
+        aggregations: {
+          cost: { total: 0 },
+          tokens: { total: 0 },
+          httpRequests: { total: 1 }
+        }
+      }
     ] );
   } );
 
@@ -304,7 +300,13 @@ describe( 'ActivityExecutionInterceptor', () => {
       nonRetryable: true,
       details: [
         { domain: { reason: 'bad-input' } },
-        { aggregations: httpRequestAggregations }
+        {
+          aggregations: {
+            cost: { total: 0 },
+            tokens: { total: 0 },
+            httpRequests: { total: 1 }
+          }
+        }
       ]
     } );
   } );
@@ -322,7 +324,6 @@ describe( 'ActivityExecutionInterceptor', () => {
     expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_START, expect.any( Object ) );
     expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
       activityInfo: activityInfoMock,
-      aggregations: null,
       workflowDetails: workflowDetailsMock,
       outputActivityKind: 'step',
       error