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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.10.0",
+  "version": "0.10.1-next.09ed166.0",
   "description": "The core module of the output framework",
   "type": "module",
   "engines": {

package/src/bus.js

@@ -1,30 +1,68 @@
 import { EventEmitter } from 'node:events';
 import { randomUUID } from 'node:crypto';
-import { isPlainObject } from '#helpers/object';
+import { Storage } from '#async_storage';
+import { WORKFLOW_CATALOG } from '#consts';
 
-const emitter = new EventEmitter();
+const mainEventBus = new EventEmitter();
+const stepEventBus = new EventEmitter();
+
+const getContext = () => {
+  const ctx = Storage.load();
+  if ( ctx ) {
+    const { outputActivityKind, activityInfo, workflowDetails } = ctx;
+    return { outputActivityKind, activityInfo, workflowDetails };
+  }
+  return {};
+};
 
 /**
- * Every object payload emitted through `messageBus` is stamped with a UUID v4 `eventId`.
+ * Attaches information and filter out events from the bus by proxying .emit().
+ *
+ * If createEnvelope=true, wrap payload:
+ * ```js
+ * {
+ *   eventId,
+ *   eventDate,
+ *   outputActivityKind,
+ *   activityInfo,
+ *   workflowDetails,
+ *   payload: <original payload>
+ * }
+ * ```
+ *
+ * if createEnvelope=false, adds eventId and eventDate to the original payload object
+ *
+ * @param {object} args
+ * @param {object} args.bus The event emitter to proxy
+ * @param {boolean} args.createEnvelope Whether to wrap event around an envelope
+ * @param {function} args.filter Filter function to drop events
  */
-emitter.emit = new Proxy( emitter.emit, {
-  apply( target, thisArg, args ) {
-    const [ eventName, payload, ...extras ] = args;
-    const newArguments = [];
-
-    // do now push arguments that dont exist. if payload is undefined with len=1, means it was never defined
-    // if payload is undefined with len>1, means user passed 'undefined' as argument
-    if ( args.length > 1 ) {
-      newArguments.push( isPlainObject( payload ) ? {
+const proxyBus = ( { bus, createEnvelope = false, filter } ) => {
+  bus.emit = new Proxy( bus.emit, {
+    apply( target, thisArg, args ) {
+      const [ eventName, payload, ...rest ] = args;
+
+      const shouldEmit = filter?.( eventName, payload ) ?? true;
+      if ( !shouldEmit ) {
+        return false;
+      }
+
+      const eventFields = {
         eventId: randomUUID(),
-        eventDate: Date.now(),
-        ...payload
-      } : payload );
-      newArguments.push( ...extras );
+        eventDate: Date.now()
+      };
+
+      const newPayload = createEnvelope ? { ...eventFields, ...getContext(), payload } : { ...eventFields, ...payload };
+      return Reflect.apply( target, thisArg, [ eventName, newPayload, ...rest ] );
     }
+  } );
+};
 
-    return Reflect.apply( target, thisArg, [ eventName, ...newArguments ] );
-  }
-} );
+const catalogWfFilter = ( _, payload ) => payload?.workflowDetails?.workflowType !== WORKFLOW_CATALOG;
+
+// Main bus is not used inside steps, so it doesn't need context
+proxyBus( { bus: mainEventBus, createEnvelope: false, filter: catalogWfFilter } );
+// This receives SDK and user events from within steps, so add context to it
+proxyBus( { bus: stepEventBus, createEnvelope: true } );
 
-export const messageBus = emitter;
+export { mainEventBus, stepEventBus };

package/src/bus.spec.js

@@ -1,135 +1,193 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { messageBus } from './bus.js';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const loadMock = vi.hoisted( () => vi.fn() );
+
+vi.mock( '#async_storage', () => ( {
+  Storage: { load: loadMock }
+} ) );
+
+import { mainEventBus, stepEventBus } from './bus.js';
 
 const UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const ACTIVITY_CONTEXT = {
+  activityInfo: { activityId: 'activity-id' },
+  workflowDetails: { workflowId: 'workflow-id' },
+  outputActivityKind: 'step'
+};
 
-describe( 'messageBus', () => {
+describe( 'event buses', () => {
   beforeEach( () => {
-    messageBus.removeAllListeners();
+    mainEventBus.removeAllListeners();
+    stepEventBus.removeAllListeners();
+    loadMock.mockReset();
   } );
 
-  describe( 'eventId stamping', () => {
-    it( 'stamps a UUID v4 eventId on every object payload', () => {
+  afterEach( () => {
+    vi.useRealTimers();
+  } );
+
+  describe( 'mainEventBus', () => {
+    it( 'adds event metadata to payload fields', () => {
       const handler = vi.fn();
-      messageBus.on( 'test:event', handler );
+      const now = new Date( '2026-06-02T12:00:00.000Z' );
+      vi.useFakeTimers();
+      vi.setSystemTime( now );
+      mainEventBus.on( 'test:event', handler );
 
-      messageBus.emit( 'test:event', { foo: 'bar' } );
+      mainEventBus.emit( 'test:event', { foo: 'bar' } );
 
-      expect( handler ).toHaveBeenCalledWith( expect.objectContaining( {
-        foo: 'bar',
-        eventId: expect.stringMatching( UUID_V4_REGEX )
-      } ) );
+      expect( handler ).toHaveBeenCalledWith( {
+        eventId: expect.stringMatching( UUID_V4_REGEX ),
+        eventDate: now.getTime(),
+        foo: 'bar'
+      } );
     } );
 
-    it( 'gives distinct emits distinct eventIds', () => {
+    it( 'preserves caller-supplied event metadata', () => {
       const handler = vi.fn();
-      messageBus.on( 'test:event', handler );
+      mainEventBus.on( 'test:event', handler );
 
-      messageBus.emit( 'test:event', { i: 1 } );
-      messageBus.emit( 'test:event', { i: 2 } );
+      mainEventBus.emit( 'test:event', { eventId: 'fixed-id', eventDate: 1234 } );
 
-      const first = handler.mock.calls[0][0].eventId;
-      const second = handler.mock.calls[1][0].eventId;
-      expect( first ).toMatch( UUID_V4_REGEX );
-      expect( second ).toMatch( UUID_V4_REGEX );
-      expect( first ).not.toBe( second );
+      expect( handler ).toHaveBeenCalledWith( {
+        eventId: 'fixed-id',
+        eventDate: 1234
+      } );
     } );
 
-    it( 'preserves a caller-supplied eventId (deterministic retry case)', () => {
+    it( 'does not mutate the caller-supplied payload', () => {
       const handler = vi.fn();
-      messageBus.on( 'test:event', handler );
+      const payload = { foo: 'bar' };
+      mainEventBus.on( 'test:event', handler );
 
-      messageBus.emit( 'test:event', { eventId: 'fixed-id', foo: 'bar' } );
+      mainEventBus.emit( 'test:event', payload );
 
-      expect( handler ).toHaveBeenCalledWith( expect.objectContaining( {
-        eventId: 'fixed-id',
-        foo: 'bar'
+      expect( handler.mock.calls[0][0] ).not.toBe( payload );
+      expect( payload ).toEqual( { foo: 'bar' } );
+    } );
+
+    it( 'does not attach activity context', () => {
+      const handler = vi.fn();
+      loadMock.mockReturnValue( {
+        activityInfo: { activityId: 'activity-id' },
+        workflowDetails: { workflowId: 'workflow-id' },
+        outputActivityKind: 'step'
+      } );
+      mainEventBus.on( 'test:event', handler );
+
+      mainEventBus.emit( 'test:event', { foo: 'bar' } );
+
+      expect( handler ).toHaveBeenCalledWith( expect.not.objectContaining( {
+        activityInfo: expect.anything(),
+        workflowDetails: expect.anything(),
+        outputActivityKind: expect.anything()
       } ) );
+      expect( loadMock ).not.toHaveBeenCalled();
     } );
 
-    it( 'stamps eventDate on every object payload', () => {
+    it( 'filters catalog workflow events', () => {
       const handler = vi.fn();
-      const now = new Date( '2026-06-02T12:00:00.000Z' );
-      vi.useFakeTimers();
-      vi.setSystemTime( now );
-      messageBus.on( 'test:event', handler );
+      mainEventBus.on( 'workflow:start', handler );
 
-      messageBus.emit( 'test:event', { foo: 'bar' } );
+      const emitted = mainEventBus.emit( 'workflow:start', {
+        workflowDetails: { workflowType: '$catalog' }
+      } );
 
-      expect( handler ).toHaveBeenCalledWith( expect.objectContaining( {
-        eventDate: now.getTime(),
-        foo: 'bar'
-      } ) );
+      expect( emitted ).toBe( false );
+      expect( handler ).not.toHaveBeenCalled();
+    } );
+  } );
 
-      vi.useRealTimers();
+  describe( 'stepEventBus', () => {
+    beforeEach( () => {
+      loadMock.mockReturnValue( ACTIVITY_CONTEXT );
     } );
 
-    it( 'preserves a caller-supplied eventDate', () => {
+    it( 'wraps payloads with event metadata and activity context', () => {
       const handler = vi.fn();
-      messageBus.on( 'test:event', handler );
+      const payload = { foo: 'bar' };
+      stepEventBus.on( 'test:event', handler );
 
-      messageBus.emit( 'test:event', { eventDate: 1234, foo: 'bar' } );
+      stepEventBus.emit( 'test:event', payload );
 
-      expect( handler ).toHaveBeenCalledWith( expect.objectContaining( {
-        eventDate: 1234,
-        foo: 'bar'
-      } ) );
+      expect( handler ).toHaveBeenCalledWith( {
+        eventId: expect.stringMatching( UUID_V4_REGEX ),
+        eventDate: expect.any( Number ),
+        ...ACTIVITY_CONTEXT,
+        payload
+      } );
     } );
 
-    it( 'does not mutate the caller-supplied payload object', () => {
+    it( 'omits activity fields outside activity context', () => {
       const handler = vi.fn();
-      messageBus.on( 'test:event', handler );
+      loadMock.mockReturnValue( undefined );
+      stepEventBus.on( 'test:event', handler );
 
-      const payload = { foo: 'bar' };
-      messageBus.emit( 'test:event', payload );
+      stepEventBus.emit( 'test:event', { foo: 'bar' } );
 
-      expect( payload ).not.toHaveProperty( 'eventId' );
-      expect( payload ).not.toHaveProperty( 'eventDate' );
+      expect( handler ).toHaveBeenCalledWith( {
+        eventId: expect.stringMatching( UUID_V4_REGEX ),
+        eventDate: expect.any( Number ),
+        payload: { foo: 'bar' }
+      } );
     } );
-  } );
 
-  describe( 'pass-through behavior', () => {
-    it( 'passes primitive payloads through unchanged', () => {
+    it( 'preserves arbitrary payloads unchanged inside the envelope', () => {
       const handler = vi.fn();
-      messageBus.on( 'test:event', handler );
-
-      messageBus.emit( 'test:event', 'a-string' );
-      messageBus.emit( 'test:event', 42 );
-      messageBus.emit( 'test:event', true );
-
-      expect( handler ).toHaveBeenNthCalledWith( 1, 'a-string' );
-      expect( handler ).toHaveBeenNthCalledWith( 2, 42 );
-      expect( handler ).toHaveBeenNthCalledWith( 3, true );
+      const array = [ 1, 2, 3 ];
+      const instance = new Date();
+      stepEventBus.on( 'test:event', handler );
+
+      stepEventBus.emit( 'test:event', 'value' );
+      stepEventBus.emit( 'test:event', array );
+      stepEventBus.emit( 'test:event', instance );
+      stepEventBus.emit( 'test:event' );
+
+      expect( handler.mock.calls[0][0].payload ).toBe( 'value' );
+      expect( handler.mock.calls[1][0].payload ).toBe( array );
+      expect( handler.mock.calls[2][0].payload ).toBe( instance );
+      expect( handler.mock.calls[3][0] ).toHaveProperty( 'payload', undefined );
     } );
 
-    it( 'passes null and undefined payloads through unchanged', () => {
+    it( 'keeps payload metadata separate from envelope metadata', () => {
       const handler = vi.fn();
-      messageBus.on( 'test:event', handler );
+      const payload = { eventId: 'payload-id', eventDate: 1234 };
+      stepEventBus.on( 'test:event', handler );
 
-      messageBus.emit( 'test:event', null );
-      messageBus.emit( 'test:event' );
+      stepEventBus.emit( 'test:event', payload );
 
-      expect( handler ).toHaveBeenNthCalledWith( 1, null );
-      expect( handler ).toHaveBeenNthCalledWith( 2 );
+      const envelope = handler.mock.calls[0][0];
+      expect( envelope.eventId ).toMatch( UUID_V4_REGEX );
+      expect( envelope.eventId ).not.toBe( payload.eventId );
+      expect( envelope.eventDate ).not.toBe( payload.eventDate );
+      expect( envelope.payload ).toBe( payload );
     } );
 
-    it( 'passes array payloads through unchanged (no key injection)', () => {
+    it( 'gives distinct emits distinct eventIds', () => {
       const handler = vi.fn();
-      messageBus.on( 'test:event', handler );
+      stepEventBus.on( 'test:event', handler );
 
-      messageBus.emit( 'test:event', [ 1, 2, 3 ] );
+      stepEventBus.emit( 'test:event', { i: 1 } );
+      stepEventBus.emit( 'test:event', { i: 2 } );
 
-      expect( handler ).toHaveBeenCalledWith( [ 1, 2, 3 ] );
+      const first = handler.mock.calls[0][0].eventId;
+      const second = handler.mock.calls[1][0].eventId;
+      expect( first ).toMatch( UUID_V4_REGEX );
+      expect( second ).toMatch( UUID_V4_REGEX );
+      expect( first ).not.toBe( second );
     } );
 
-    it( 'forwards additional positional args untouched', () => {
+    it( 'forwards additional positional arguments unchanged', () => {
       const handler = vi.fn();
-      messageBus.on( 'test:event', handler );
+      stepEventBus.on( 'test:event', handler );
 
-      messageBus.emit( 'test:event', { foo: 'bar' }, 'extra', 99 );
+      stepEventBus.emit( 'test:event', { foo: 'bar' }, 'extra', 99 );
 
       expect( handler ).toHaveBeenCalledWith(
-        expect.objectContaining( { foo: 'bar', eventId: expect.stringMatching( UUID_V4_REGEX ) } ),
+        expect.objectContaining( {
+          eventId: expect.stringMatching( UUID_V4_REGEX ),
+          payload: { foo: 'bar' }
+        } ),
         'extra',
         99
       );

package/src/consts.js

@@ -4,11 +4,12 @@ export const ACTIVITY_SEND_HTTP_REQUEST = '__internal#sendHttpRequest';
 export const ACTIVITY_WRAPPER_VERSION_FIELD = '__output_activity_wrapper_version';
 export const ACTIVITY_LOGGER_SYMBOL = Symbol.for( '__activity_logger' );
 export const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
-export const SHARED_STEP_PREFIX = '$shared';
 export const WORKFLOW_CATALOG = '$catalog';
 export const WORKFLOWS_INDEX_FILENAME = '__workflows_entrypoint.js';
 export const WORKFLOW_WRAPPER_VERSION_FIELD = '__output_workflow_wrapper_version';
 
+export const INVOKE_ACTIVITY_SYMBOL = Symbol.for( '@outputai/core:__invoke_activity' );
+
 export const ComponentType = {
   EVALUATOR: 'evaluator',
   INTERNAL_STEP: 'internal_step',

package/src/helpers/object.js

@@ -24,58 +24,71 @@ export const clone = v => {
 };
 
 /**
- * Creates a new object merging object "b" onto object "a", using a resolver function to define the value to keep.
- * - Object "b" fields that also exists on "a" will have their value defined by the "resolver" function
- * - Object "b" fields that don't exist on object "a" will be added;
- * - Object "a" fields that don't exist on object "b" will be preserved;
+ * Creates a new object recursively merging the rightmost object over the previous one using a resolver function.
+ * Give two objects, (L)eft and (R)right
+ * - Object "R" will overwrite fields on object "L" based on the result of the resolver function;
+ * - Object "R" fields that don't exist on object "L" will be added;
+ * - Object "L" fields that don't exist on object "R" will be preserved;
  *
- * If "b" isn't an object, a new object equal to "a" is returned
+ * If "R" isn't an object, a new object equal to "L" is returned.
  *
- * @param {object} a - The base object
- * @param {object} b - The target object
- * @param {function} resolver - A function that return the value to be kept. First argument is value a, second is value b
+ * The resolver function will define the final value of the merge, it receives two args value "L" and "R".
+ *
+ *
+ * @param {object} base - The base object
+ * @param {...(object|function)} args - Target objects followed by the resolver function
  * @returns {object} A new object
  */
-export const deepMergeWithResolver = ( a, b, resolver ) => {
-  if ( !isPlainObject( a ) ) {
-    throw new Error( 'Parameter "a" is not an object.' );
+export const deepMergeWithResolver = ( base, ...args ) => {
+  const objects = args.slice( 0, -1 );
+  const resolver = args.at( -1 );
+
+  if ( !isPlainObject( base ) ) {
+    throw new Error( 'First argument (base object) is not an object.' );
   }
-  if ( !isPlainObject( b ) ) {
-    return clone( a );
+
+  if ( typeof resolver !== 'function' ) {
+    throw new Error( 'Last argument (resolver) is not a function.' );
   }
-  return Object.entries( b ).reduce( ( obj, [ k, v ] ) =>
-    Object.assign( obj, {
-      [k]: ( () => {
-        if ( isPlainObject( v ) && isPlainObject( a[k] ) ) {
-          return deepMergeWithResolver( a[k], v, resolver );
-        }
-        if ( Object.hasOwn( a, k ) ) {
-          return resolver( a[k], v );
-        }
-        return v;
-      } )()
-    } )
-  , clone( a ) );
+
+  return objects.reduce( ( merged, object ) => {
+    if ( !isPlainObject( object ) ) {
+      return merged;
+    }
+
+    for ( const [ k, v ] of Object.entries( object ) ) {
+      if ( isPlainObject( v ) && isPlainObject( merged[k] ) ) {
+        merged[k] = deepMergeWithResolver( merged[k], v, resolver );
+      } else if ( Object.hasOwn( merged, k ) ) {
+        merged[k] = resolver( merged[k], v );
+      } else {
+        merged[k] = v;
+      }
+    }
+    return merged;
+  }, clone( base ) );
 };
 
 /**
- * Creates a new object merging object "b" onto object "a" biased to "b":
- * - Object "b" will overwrite fields on object "a";
- * - Object "b" fields that don't exist on object "a" will be added;
- * - Object "a" fields that don't exist on object "b" will be preserved;
+ * Creates a new object recursively merging the rightmost object over the previous one.
+ * Give two objects, (L)eft and (R)right
+ * - Object "R" will overwrite fields on object "L";
+ * - Object "R" fields that don't exist on object "L" will be added;
+ * - Object "L" fields that don't exist on object "R" will be preserved;
  *
- * If "b" isn't an object, a new object equal to "a" is returned
+ * If "R" isn't an object, a new object equal to "L" is returned.
  *
- * @param {object} a - The base object
- * @param {object} b - The target object
+ * @param {object} base - The base object
+ * @param {...object} rest - The target objects
  * @returns {object} A new object
  */
-export const deepMerge = ( a, b ) => deepMergeWithResolver( a, b, ( _, b ) => b );
+export const deepMerge = ( base, ...rest ) =>
+  deepMergeWithResolver( base, ...rest, ( _, b ) => b );
 
 /**
  * Adds an non-writable, non-configurable and non-enumerable property to an object
  * @param {object} obj
- * @param {string} key
+ * @param {string|Symbol} key
  * @param {any} value
  * @returns
  */