@outputai/core 0.2.1-next.fd72d95.0 → 0.3.1-next.00e0047.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.2.1-next.fd72d95.0",
+  "version": "0.3.1-next.00e0047.0",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {
@@ -32,16 +32,16 @@
     "output-copy-assets": "./bin/copy_assets.js"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "3.1031.0",
+    "@aws-sdk/client-s3": "3.1038.0",
     "@babel/generator": "7.29.1",
     "@babel/parser": "7.29.2",
     "@babel/traverse": "7.29.0",
     "@babel/types": "7.29.0",
-    "@temporalio/activity": "1.15.0",
-    "@temporalio/client": "1.15.0",
-    "@temporalio/common": "1.15.0",
-    "@temporalio/worker": "1.15.0",
-    "@temporalio/workflow": "1.15.0",
+    "@temporalio/activity": "1.17.0",
+    "@temporalio/client": "1.17.0",
+    "@temporalio/common": "1.17.0",
+    "@temporalio/worker": "1.17.0",
+    "@temporalio/workflow": "1.17.0",
     "redis": "5.12.1",
     "stacktrace-parser": "0.1.11",
     "undici": "8.1.0",

package/src/activity_integration/tracing.d.ts

@@ -1,32 +1,45 @@
 /**
- * Record the start of an event on the default trace for the current workflow.
+ * Creates a new event.
  *
- * @param args - Event information
- * @param args.id - A unique id for the Event, must be the same across all phases: start, end, error.
+ * @param args
+ * @param args.id - A unique id for the Event.
  * @param args.kind - The kind of Event, like HTTP, DiskWrite, DBOp, etc.
- * @param args.name - The human friendly name of the Event: query, request, create.
- * @param args.details - Arbitrary metadata associated with this phase (e.g., payloads, summaries).
+ * @param args.name - The human-friendly name of the Event: query, request, create.
+ * @param args.details - Arbitrary data to add to this event, it will be used as the "input" field.
  */
 export declare function addEventStart( args: { id: string; kind: string; name: string; details: unknown } ): void;
 
 /**
- * Record the end of an event on the default trace for the current workflow.
+ * Concludes an event.
  *
- * Use the same id as the start phase to correlate phases.
- *
- * @param args - Event information
- * @param args.id - Identifier matching the event's start phase.
- * @param args.details - Arbitrary metadata associated with this phase (e.g., results, response body).
+ * @param args
+ * @param args.id - The id of the event to conclude.
+ * @param args.details - Arbitrary data to add to this event, it will be used as the "output" field.
  */
 export declare function addEventEnd( args: { id: string; details: unknown } ): void;
 
 /**
- * Record an error for an event on the default trace for the current workflow.
- *
- * Use the same id as the start phase to correlate phases.
+ * Concludes an event with an error.
  *
- * @param args - Event metadata for the error phase.
- * @param args.id - Identifier matching the event's start phase.
- * @param args.details - Arbitrary metadata associated with this phase, possible error info.
+ * @param args
+ * @param args.id - The id of the event to conclude.
+ * @param args.details - Arbitrary data to add to this event, it will be used as the "error" field.
  */
 export declare function addEventError( args: { id: string; details: unknown } ): void;
+
+/**
+ * Adds an attribute to an event.
+ *
+ * @param args
+ * @param args.eventId - The id of the event to attach the attribute to.
+ * @param args.name - The attribute name
+ * @param args.value - The attribute value
+ */
+export declare function addEventAttribute( args: { eventId: string; name: string, value: unknown } ): void;
+
+/**
+ * Known attributes.
+ */
+export declare const Attribute: {
+  COST: 'cost';
+};

package/src/activity_integration/tracing.js

@@ -1,37 +1,53 @@
-import { addEventPhaseWithContext } from '#tracing';
+import { addEventActionWithContext, EventAction } from '#tracing';
 
 /**
- * Adds the start phase of a new event at the default trace for the current workflow.
+ * Creates a new event.
  *
  * @param {object} args
- * @param {string} args.id - A unique id for the Event, must be the same across all phases: start, end, error.
+ * @param {string} args.id - A unique id for the Event.
  * @param {string} args.kind - The kind of Event, like HTTP, DiskWrite, DBOp, etc.
- * @param {string} args.name - The human friendly name of the Event: query, request, create.
- * @param {object} args.details - All details attached to this Event Phase. DB queried records, HTTP response body.
+ * @param {string} args.name - The human-friendly name of the Event: query, request, create.
+ * @param {object} args.details - Arbitrary data to add to this event, it will be used as the "input" field.
  * @returns {void}
  */
-export const addEventStart = ( { id, kind, name, details } ) => addEventPhaseWithContext( 'start', { kind, name, details, id } );
+export const addEventStart = ( { id, kind, name, details } ) =>
+  addEventActionWithContext( EventAction.START, { kind, name, details, id } );
 
 /**
- * Adds the end phase at an event at the default trace for the current workflow.
- *
- * It needs to use the same id of the start phase.
+ * Concludes an event.
  *
  * @param {object} args
- * @param {string} args.id - A unique id for the Event, must be the same across all phases: start, end, error.
- * @param {object} args.details - All details attached to this Event Phase. DB queried records, HTTP response body.
+ * @param {string} args.id - The id of the event to conclude.
+ * @param {object} args.details - Arbitrary data to add to this event, it will be used as the "output" field.
  * @returns {void}
  */
-export const addEventEnd = ( { id, details } ) => addEventPhaseWithContext( 'end', { id, details } );
+export const addEventEnd = ( { id, details } ) => addEventActionWithContext( EventAction.END, { id, details } );
 
 /**
- * Adds the error phase at an event as error at the default trace for the current workflow.
+ * Concludes an event with an error.
  *
- * It needs to use the same id of the start phase.
+ * @param {object} args
+ * @param {string} args.id - The id of the event to conclude.
+ * @param {object} args.details - Arbitrary data to add to this event, it will be used as the "error" field.
+ * @returns {void}
+ */
+export const addEventError = ( { id, details } ) => addEventActionWithContext( EventAction.ERROR, { id, details } );
+
+/**
+ * Adds an attribute to an event.
  *
  * @param {object} args
- * @param {string} args.id - A unique id for the Event, must be the same across all phases: start, end, error.
- * @param {object} args.details - All details attached to this Event Phase. DB queried records, HTTP response body.
+ * @param {string} args.eventId - The id of the event to attach the attribute to.
+ * @param {string} args.name - The attribute name
+ * @param {unknown} args.value - The attribute value
  * @returns {void}
  */
-export const addEventError = ( { id, details } ) => addEventPhaseWithContext( 'error', { id, details } );
+export const addEventAttribute = ( { eventId, name, value } ) =>
+  addEventActionWithContext( EventAction.ADD_ATTR, { id: eventId, details: { name, value } } );
+
+/**
+ * Known attributes
+ */
+export const Attribute = {
+  COST: 'cost'
+};

package/src/hooks/index.d.ts

@@ -12,6 +12,42 @@ export interface ErrorHookPayload {
   error: Error;
 }
 
+/**
+ * Payload passed to the onWorkflowStart handler when a workflow run begins.
+ */
+export interface WorkflowStartHookPayload {
+  /** Identifier of the workflow run. */
+  id: string;
+  /** Name of the workflow. */
+  name: string;
+}
+
+/**
+ * Payload passed to the onWorkflowEnd handler when a workflow run completes successfully.
+ */
+export interface WorkflowEndHookPayload {
+  /** Identifier of the workflow run. */
+  id: string;
+  /** Name of the workflow. */
+  name: string;
+  /** Duration of the workflow run in milliseconds. */
+  duration: number;
+}
+
+/**
+ * Payload passed to the onWorkflowError handler when a workflow run fails.
+ */
+export interface WorkflowErrorHookPayload {
+  /** Identifier of the workflow run. */
+  id: string;
+  /** Name of the workflow. */
+  name: string;
+  /** Elapsed time before failure in milliseconds. */
+  duration: number;
+  /** The error thrown. */
+  error: Error;
+}
+
 /**
  * Register a handler to be invoked on workflow, activity or runtime errors.
  *
@@ -21,11 +57,38 @@ export declare function onError( handler: ( payload: ErrorHookPayload ) => void
 
 /**
  * Register a handler to be invoked once, before the worker starts processing tasks.
- * Runs synchronously after activities are loaded and before Worker.create().
+ * It is invoked before Worker.create().
  *
  * @param handler - Function called with no arguments.
  */
-export declare function onBeforeStart( handler: () => void ): void;
+export declare function onBeforeWorkerStart( handler: () => void ): void;
+
+/**
+ * Register a handler to be invoked when a workflow run starts.
+ *
+ * Excludes the $catalog internal workflow.
+ *
+ * @param handler - Function called with the workflow start payload.
+ */
+export declare function onWorkflowStart( handler: ( payload: WorkflowStartHookPayload ) => void ): void;
+
+/**
+ * Register a handler to be invoked when a workflow run completes successfully.
+ *
+ * Excludes the $catalog internal workflow.
+ *
+ * @param handler - Function called with the workflow end payload.
+ */
+export declare function onWorkflowEnd( handler: ( payload: WorkflowEndHookPayload ) => void ): void;
+
+/**
+ * Register a handler to be invoked when a workflow run fails.
+ *
+ * Excludes the $catalog internal workflow.
+ *
+ * @param handler - Function called with the workflow error payload.
+ */
+export declare function onWorkflowError( handler: ( payload: WorkflowErrorHookPayload ) => void ): void;
 
 /**
  * Register a handler to be invoked when a given event happens
@@ -33,4 +96,4 @@ export declare function onBeforeStart( handler: () => void ): void;
  * @param eventName - The name of the event to subscribe
  * @param handler - Function called with the event payload
  */
-export declare function on( eventName: string, handler: ( payload: object ) => void ): void;
+export declare function on( eventName: string, handler: ( payload?: object ) => void ): void;

package/src/hooks/index.js

@@ -1,34 +1,50 @@
 import { messageBus } from '#bus';
-import { BusEventType } from '#consts';
+import { BusEventType, WORKFLOW_CATALOG } from '#consts';
 import { createChildLogger } from '#logger';
 
 const log = createChildLogger( 'Hooks' );
 
+/**
+ * Invokes an external hook handler function with a try catch around it
+ *
+ * @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 ) => {
+  try {
+    await fn( args );
+  } catch ( error ) {
+    log.error( `${hookName} hook error`, { message: error.message, stack: error.stack } );
+  }
+};
+
+/** Triggers on any errors: workflow, activity and runtime */
 export const onError = handler => {
-  const invokeHandler = async args => {
-    try {
-      await handler( args );
-    } catch ( error ) {
-      log.error( 'onError hook error', { error } );
-    }
-  };
-
-  messageBus.on( BusEventType.ACTIVITY_ERROR, async ( { name, workflowName, error } ) =>
-    invokeHandler( { source: 'activity', activityName: name, workflowName, error } ) );
-  messageBus.on( BusEventType.WORKFLOW_ERROR, async ( { name, error } ) =>
-    invokeHandler( { source: 'workflow', workflowName: name, error } ) );
+  messageBus.on( BusEventType.ACTIVITY_ERROR, async ( { id, name, workflowId, workflowName, error } ) =>
+    safeInvoke( handler, { source: 'activity', activityId: id, activityName: name, workflowId, workflowName, error }, 'onError' ) );
+  messageBus.on( BusEventType.WORKFLOW_ERROR, async ( { id, name, error } ) =>
+    safeInvoke( handler, { source: 'workflow', workflowId: id, workflowName: name, error }, 'onError' ) );
   messageBus.on( BusEventType.RUNTIME_ERROR, async ( { error } ) =>
-    invokeHandler( { source: 'runtime', error } ) );
+    safeInvoke( handler, { source: 'runtime', error }, 'onError' ) );
 };
 
-export const onBeforeStart = handler => messageBus.on( BusEventType.WORKER_BEFORE_START, handler );
+/** Listen to worker before start events */
+export const onBeforeWorkerStart = handler => messageBus.on( BusEventType.WORKER_BEFORE_START, () =>
+  safeInvoke( handler, undefined, 'onBeforeWorkerStart' ) );
 
-export const on = ( eventName, handler ) => {
-  messageBus.on( `external:${eventName}`, async payload => {
-    try {
-      await handler( payload );
-    } catch ( error ) {
-      log.error( `on(${eventName}) hook error`, { error } );
-    }
-  } );
-};
+/** Listen to workflow start events, excludes catalog workflow */
+export const onWorkflowStart = handler => messageBus.on( BusEventType.WORKFLOW_START, ( { id, name } ) =>
+  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { id, name }, 'onWorkflowStart' ) : null );
+
+/** Listen to workflow end events, excludes catalog workflow */
+export const onWorkflowEnd = handler => messageBus.on( BusEventType.WORKFLOW_END, ( { id, name, duration } ) =>
+  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { id, name, duration }, 'onWorkflowEnd' ) : null );
+
+/** Listen to workflow error events, excludes catalog workflow */
+export const onWorkflowError = handler => messageBus.on( BusEventType.WORKFLOW_ERROR, ( { id, name, duration, error } ) =>
+  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { id, name, duration, error }, 'onWorkflowError' ) : 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

@@ -0,0 +1,176 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { BusEventType, WORKFLOW_CATALOG } from '#consts';
+
+const logErrorMock = vi.hoisted( () => vi.fn() );
+const createChildLoggerMock = vi.hoisted( () =>
+  vi.fn( () => ( { error: logErrorMock } ) )
+);
+
+const onHandlers = vi.hoisted( () => ( {} ) );
+const messageBusMock = vi.hoisted( () => ( {
+  on: vi.fn( ( eventType, handler ) => {
+    onHandlers[eventType] = handler;
+  } )
+} ) );
+
+vi.mock( '#logger', () => ( { createChildLogger: createChildLoggerMock } ) );
+vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+
+import {
+  on,
+  onBeforeWorkerStart,
+  onError,
+  onWorkflowEnd,
+  onWorkflowError,
+  onWorkflowStart
+} from './index.js';
+
+describe( 'hooks/index', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    Object.keys( onHandlers ).forEach( k => {
+      delete onHandlers[k];
+    } );
+  } );
+
+  describe( 'onError', () => {
+    it( 'registers activity, workflow, and runtime error listeners', () => {
+      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 ) );
+    } );
+
+    it( 'invokes handler with activity-shaped payload', async () => {
+      const handler = vi.fn().mockResolvedValue( undefined );
+      onError( handler );
+
+      const err = new Error( 'act-fail' );
+      await onHandlers[BusEventType.ACTIVITY_ERROR]( {
+        id: 'act-1',
+        name: 'wf#step',
+        workflowId: 'wf-run-1',
+        workflowName: 'wf',
+        error: err
+      } );
+
+      expect( handler ).toHaveBeenCalledWith( {
+        source: 'activity',
+        activityId: 'act-1',
+        activityName: 'wf#step',
+        workflowId: 'wf-run-1',
+        workflowName: 'wf',
+        error: err
+      } );
+    } );
+
+    it( 'invokes handler with workflow-shaped payload', async () => {
+      const handler = vi.fn().mockResolvedValue( undefined );
+      onError( handler );
+
+      const err = new Error( 'wf-fail' );
+      await onHandlers[BusEventType.WORKFLOW_ERROR]( {
+        id: 'wf-run-2',
+        name: 'myWorkflow',
+        error: err
+      } );
+
+      expect( handler ).toHaveBeenCalledWith( {
+        source: 'workflow',
+        workflowId: 'wf-run-2',
+        workflowName: 'myWorkflow',
+        error: err
+      } );
+    } );
+
+    it( 'logs and does not rethrow when handler rejects', async () => {
+      const handler = vi.fn().mockRejectedValue( new Error( 'boom' ) );
+      onError( handler );
+
+      const error = new Error( 'rt' );
+      await onHandlers[BusEventType.RUNTIME_ERROR]( { error } );
+
+      expect( handler ).toHaveBeenCalledWith( { source: 'runtime', error } );
+    } );
+  } );
+
+  describe( 'onBeforeWorkerStart', () => {
+    it( 'registers and invokes handler with undefined payload', async () => {
+      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( handler ).toHaveBeenCalledWith( undefined );
+    } );
+  } );
+
+  describe( 'onWorkflowStart', () => {
+    it( 'skips catalog workflow name', async () => {
+      const handler = vi.fn().mockResolvedValue( undefined );
+      onWorkflowStart( handler );
+
+      await Promise.resolve( onHandlers[BusEventType.WORKFLOW_START]( { id: '1', name: WORKFLOW_CATALOG } ) );
+      expect( handler ).not.toHaveBeenCalled();
+
+      await Promise.resolve( onHandlers[BusEventType.WORKFLOW_START]( { id: '2', name: 'myWorkflow' } ) );
+      expect( handler ).toHaveBeenCalledWith( { id: '2', name: 'myWorkflow' } );
+    } );
+  } );
+
+  describe( 'onWorkflowEnd', () => {
+    it( 'skips catalog workflow name', async () => {
+      const handler = vi.fn().mockResolvedValue( undefined );
+      onWorkflowEnd( handler );
+
+      await Promise.resolve( onHandlers[BusEventType.WORKFLOW_END]( {
+        id: '1',
+        name: WORKFLOW_CATALOG,
+        duration: 10
+      } ) );
+      expect( handler ).not.toHaveBeenCalled();
+
+      await Promise.resolve( onHandlers[BusEventType.WORKFLOW_END]( { id: '2', name: 'myWorkflow', duration: 5 } ) );
+      expect( handler ).toHaveBeenCalledWith( { id: '2', name: 'myWorkflow', duration: 5 } );
+    } );
+  } );
+
+  describe( 'onWorkflowError', () => {
+    it( 'skips catalog workflow name', async () => {
+      const handler = vi.fn().mockResolvedValue( undefined );
+      const err = new Error( 'wf' );
+      onWorkflowError( handler );
+
+      await Promise.resolve( onHandlers[BusEventType.WORKFLOW_ERROR]( {
+        id: '1',
+        name: WORKFLOW_CATALOG,
+        duration: 1,
+        error: err
+      } ) );
+      expect( handler ).not.toHaveBeenCalled();
+
+      await Promise.resolve( onHandlers[BusEventType.WORKFLOW_ERROR]( {
+        id: '2',
+        name: 'myWorkflow',
+        duration: 2,
+        error: err
+      } ) );
+      expect( handler ).toHaveBeenCalledWith( { id: '2', name: 'myWorkflow', duration: 2, error: err } );
+    } );
+  } );
+
+  describe( 'on', () => {
+    it( 'subscribes to external event channel and forwards payload', 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( handler ).toHaveBeenCalledWith( { foo: 1 } );
+    } );
+  } );
+} );

package/src/tracing/internal_interface.js

@@ -1,4 +1,5 @@
-import { addEventPhase, addEventPhaseWithContext, init, getDestinations } from './trace_engine.js';
+import { addEventAction, addEventActionWithContext, init, getDestinations } from './trace_engine.js';
+import { EventAction } from './trace_consts.js';
 
 /**
  * Init method, if not called, no processors are attached and trace functions are dummy
@@ -6,66 +7,71 @@ import { addEventPhase, addEventPhaseWithContext, init, getDestinations } from '
 export { init, getDestinations };
 
 /**
- * Internal use only - adds event phase with AsyncLocalStorage context resolution
+ * Internal use only - adds an action with AsyncLocalStorage context resolution
  */
-export { addEventPhaseWithContext };
+export { addEventActionWithContext };
+
+export { EventAction };
 
 /**
  * Trace nomenclature
  *
  * Trace - The collection of Events;
- * Event - Any entry in the Trace file, must have the two phases START and END or ERROR;
- * Phase - An specific part of an Event, either START or the conclusive END or ERROR;
+ * Event - Any entry in the Trace file must have both START and END/ERROR actions, plus any number of ADD_ATTR actions;
+ * Action - A specific part of an Event: START, END, ERROR, or ADD_ATTR;
  */
 
 /**
  * Internal use only
  *
- * Adds the start phase of a new event at the default trace for the current workflow.
+ * Creates a new event and appends it to the trace.
  *
  * @param {object} args
- * @param {string} args.id - A unique id for the Event, must be the same across all phases: start, end, error.
+ * @param {string} args.id - A unique id for the Event.
  * @param {string} args.kind - The kind of Event, like HTTP, DiskWrite, DBOp, etc.
- * @param {string} args.name - The human friendly name of the Event: query, request, create.
- * @param {any} args.details - All details attached to this Event Phase. DB queried records, HTTP response body.
- * @param {string} args.parentId - The parent Event, used to build a three.
+ * @param {string} args.name - The human-friendly name of the Event: query, request, create.
+ * @param {any} args.details - Arbitrary data to add to this event, it will be used as the "input" field.
+ * @param {string} args.parentId - The parent Event, used to build a tree.
  * @param {object} args.executionContext - The original execution context from the workflow
  * @returns {void}
  */
-export const addEventStart = options => addEventPhase( 'start', options );
+export const addEventStart = options => addEventAction( EventAction.START, options );
 
 /**
  * Internal use only
  *
- * Adds the end phase at an event at the default trace for the current workflow.
- *
- * It needs to use the same id of the start phase.
+ * Concludes an event, matching by its id.
  *
  * @param {object} args
- * @param {string} args.id - A unique id for the Event, must be the same across all phases: start, end, error.
- * @param {string} args.kind - The kind of Event, like HTTP, DiskWrite, DBOp, etc.
- * @param {string} args.name - The human friendly name of the Event: query, request, create.
- * @param {any} args.details - All details attached to this Event Phase. DB queried records, HTTP response body.
- * @param {string} args.parentId - The parent Event, used to build a three.
+ * @param {string} args.id - The id of the event to conclude.
+ * @param {any} args.details - Arbitrary data to add to the event; it is used as the "output" field.
  * @param {object} args.executionContext - The original execution context from the workflow
  * @returns {void}
  */
-export const addEventEnd = options => addEventPhase( 'end', options );
+export const addEventEnd = options => addEventAction( EventAction.END, options );
 
 /**
  * Internal use only
  *
- * Adds the error phase at an event as error at the default trace for the current workflow.
+ * Concludes an event with an error, matching by its id.
+ *
+ * @param {object} args
+ * @param {string} args.id - The id of the event to conclude.
+ * @param {any} args.details - Arbitrary data to add to the event; it is used as the "error" field.
+ * @param {object} args.executionContext - The original execution context from the workflow
+ * @returns {void}
+ */
+export const addEventError = options => addEventAction( EventAction.ERROR, options );
+
+/**
+ * Internal use only
  *
- * It needs to use the same id of the start phase.
+ * Adds an attribute to an event using its id.
  *
  * @param {object} args
- * @param {string} args.id - A unique id for the Event, must be the same across all phases: start, end, error.
- * @param {string} args.kind - The kind of Event, like HTTP, DiskWrite, DBOp, etc.
- * @param {string} args.name - The human friendly name of the Event: query, request, create.
- * @param {any} args.details - All details attached to this Event Phase. DB queried records, HTTP response body.
- * @param {string} args.parentId - The parent Event, used to build a three.
+ * @param {string} args.id - The id of the event to attach the attribute to.
+ * @param {object} args.details - The attribute to add to this event, must be in `{ name: string, value: any }` format.
  * @param {object} args.executionContext - The original execution context from the workflow
  * @returns {void}
  */
-export const addEventError = options => addEventPhase( 'error', options );
+export const addEventAttribute = options => addEventAction( EventAction.ADD_ATTR, options );