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

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` );

package/src/worker/index.spec.js

@@ -7,7 +7,7 @@ const {
   connectionMonitorInstance,
   createCatalogMock,
   initInterceptorsMock,
-  messageBusMock,
+  mainEventBusMock,
   mockConnection,
   mockLog,
   mockWorker,
@@ -110,7 +110,7 @@ const {
     loadActivitiesMock: vi.fn().mockResolvedValue( {} ),
     loadHooksMock: vi.fn().mockResolvedValue( undefined ),
     loadWorkflowsMock: vi.fn().mockResolvedValue( [] ),
-    messageBusMock: { emit: vi.fn(), on: vi.fn() },
+    mainEventBusMock: { emit: vi.fn(), on: vi.fn() },
     mockConnection: { close: vi.fn().mockResolvedValue( undefined ) },
     mockLog: { error: vi.fn(), info: vi.fn(), warn: vi.fn() },
     mockWorker,
@@ -128,7 +128,7 @@ vi.mock( '#consts', async importOriginal => {
 } );
 const initTracing = vi.fn().mockResolvedValue( undefined );
 vi.mock( '#tracing', () => ( { init: initTracing } ) );
-vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
 
 const loadWorkflowsMock = vi.fn().mockResolvedValue( { workflows: [], entrypoint: '/fake/workflows/path.js' } );
 const loadActivitiesMock = vi.fn().mockResolvedValue( { activities: {} } );
@@ -357,7 +357,7 @@ describe( 'worker/index', () => {
         error: 'Big Failure'
       } ) );
     } );
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
     await vi.waitFor( () => expect( exitMock ).toHaveBeenCalledWith( 1 ) );
   } );
 
@@ -378,7 +378,7 @@ describe( 'worker/index', () => {
     } );
     expect( mockWorker.shutdown ).toHaveBeenCalledOnce();
     expect( catalogJobInstance.interrupt ).toHaveBeenCalledOnce();
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
   } );
 
   it( 'throws catalog job errors after graceful shutdown', async () => {
@@ -398,7 +398,7 @@ describe( 'worker/index', () => {
     } );
     expect( mockWorker.shutdown ).toHaveBeenCalledOnce();
     expect( connectionMonitorInstance.stop ).toHaveBeenCalledOnce();
-    expect( messageBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
+    expect( mainEventBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
   } );
 
   it( 'cleans up partial startup failures after connecting', async () => {

package/src/worker/interceptors/activity.js

@@ -4,7 +4,7 @@ import * as Tracing from '#tracing';
 import { headersToObject } from './headers.js';
 import { ACTIVITY_WRAPPER_VERSION_FIELD, BusEventType, METADATA_ACCESS_SYMBOL } from '#consts';
 import { activityHeartbeatEnabled, activityHeartbeatIntervalMs } from '../configs.js';
-import { messageBus } from '#bus';
+import { mainEventBus } from '#bus';
 import { aggregateAttributes } from '#helpers/aggregations';
 import { buildApplicationFailureWithDetails } from '#helpers/errors';
 
@@ -68,7 +68,7 @@ export class ActivityExecutionInterceptor {
       addAttribute
     };
 
-    messageBus.emit( BusEventType.ACTIVITY_START, { activityInfo, workflowDetails, outputActivityKind } );
+    mainEventBus.emit( BusEventType.ACTIVITY_START, { activityInfo, workflowDetails, outputActivityKind } );
     Tracing.addEventStart( { id: activityId, name: activityType, kind: outputActivityKind, parentId: runId, details: input.args[0], traceInfo } );
 
     try {
@@ -79,14 +79,14 @@ export class ActivityExecutionInterceptor {
 
       const aggregations = state.attributes.length > 0 ? aggregateAttributes( state.attributes ) : null;
 
-      messageBus.emit( BusEventType.ACTIVITY_END, { activityInfo, aggregations, workflowDetails, outputActivityKind } );
+      mainEventBus.emit( BusEventType.ACTIVITY_END, { activityInfo, aggregations, workflowDetails, outputActivityKind } );
       Tracing.addEventEnd( { id: activityId, details: output, traceInfo } );
 
       return { [ACTIVITY_WRAPPER_VERSION_FIELD]: 1, output, aggregations };
 
     } catch ( error ) {
       const aggregations = state.attributes.length > 0 ? aggregateAttributes( state.attributes ) : null;
-      messageBus.emit( BusEventType.ACTIVITY_ERROR, { activityInfo, aggregations, workflowDetails, outputActivityKind, error } );
+      mainEventBus.emit( BusEventType.ACTIVITY_ERROR, { activityInfo, aggregations, workflowDetails, outputActivityKind, error } );
       Tracing.addEventError( { id: activityId, details: error, traceInfo } );
 
       throw aggregations ? buildApplicationFailureWithDetails( error, { aggregations } ) : error;

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

@@ -61,8 +61,8 @@ vi.mock( './headers.js', () => ( {
   headersToObject: () => ( { traceInfo: traceInfoMock, workflowDetails: workflowDetailsMock } )
 } ) );
 
-const messageBusEmitMock = vi.fn();
-vi.mock( '#bus', () => ( { messageBus: { emit: messageBusEmitMock } } ) );
+const mainEventBusEmitMock = vi.fn();
+vi.mock( '#bus', () => ( { mainEventBus: { emit: mainEventBusEmitMock } } ) );
 
 vi.mock( '#consts', async importOriginal => {
   const actual = await importOriginal();
@@ -135,11 +135,11 @@ describe( 'ActivityExecutionInterceptor', () => {
       aggregations: null,
       [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
     } );
-    expect( messageBusEmitMock ).toHaveBeenCalledWith(
+    expect( mainEventBusEmitMock ).toHaveBeenCalledWith(
       BusEventType.ACTIVITY_START,
       { activityInfo: activityInfoMock, workflowDetails: workflowDetailsMock, outputActivityKind: 'step' }
     );
-    expect( messageBusEmitMock ).toHaveBeenCalledWith(
+    expect( mainEventBusEmitMock ).toHaveBeenCalledWith(
       BusEventType.ACTIVITY_END,
       { activityInfo: activityInfoMock, aggregations: null, workflowDetails: workflowDetailsMock, outputActivityKind: 'step' }
     );
@@ -178,7 +178,7 @@ describe( 'ActivityExecutionInterceptor', () => {
       [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
     } );
 
-    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, expect.any( Object ) );
+    expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, expect.any( Object ) );
     expect( addEventEndMock ).toHaveBeenCalledWith( { id: 'act-1', details: { result: 'sync' }, traceInfo: traceInfoMock } );
     expect( addEventErrorMock ).not.toHaveBeenCalled();
   } );
@@ -198,7 +198,7 @@ describe( 'ActivityExecutionInterceptor', () => {
       [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
     } );
 
-    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, {
+    expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, {
       activityInfo: activityInfoMock,
       aggregations: httpRequestAggregations,
       workflowDetails: workflowDetailsMock,
@@ -226,7 +226,7 @@ describe( 'ActivityExecutionInterceptor', () => {
       } ],
       cause: error
     } );
-    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
+    expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
       activityInfo: activityInfoMock,
       aggregations: httpRequestAggregations,
       workflowDetails: workflowDetailsMock,
@@ -318,8 +318,8 @@ describe( 'ActivityExecutionInterceptor', () => {
     vi.advanceTimersByTime( 0 );
 
     await expect( promise ).rejects.toThrow( 'step failed' );
-    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_START, expect.any( Object ) );
-    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
+    expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_START, expect.any( Object ) );
+    expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
       activityInfo: activityInfoMock,
       aggregations: null,
       workflowDetails: workflowDetailsMock,

package/src/worker/interceptors/workflow.js

@@ -7,7 +7,7 @@ import { METADATA_ACCESS_SYMBOL, WorkflowSpecialOutput } from '#consts';
 import { createWorkflowDetails } from '#helpers/temporal_context';
 
 // this is a dynamic generated file with activity configs overwrites
-import stepOptions from '../temp/__activity_options.js';
+import activityOptionsMap from '../temp/__activity_options.js';
 
 /*
   This interceptor adds Memo and serialized workflowInfo() to the Activity invocation headers.
@@ -22,10 +22,10 @@ class HeadersInjectionInterceptor {
       ...memo,
       workflowDetails: createWorkflowDetails( info )
     } ) );
-    // apply per-invocation options passed as second argument by rewritten calls
-    const options = stepOptions[input.activityType];
-    if ( options ) {
-      input.options = deepMerge( memo.activityOptions, options );
+    // Apply component-level activity options on top of workflow options.
+    const activityOptionsOverrides = activityOptionsMap[input.activityType];
+    if ( activityOptionsOverrides ) {
+      input.options = deepMerge( input.options ?? {}, activityOptionsOverrides );
     }
     return next( input );
   }

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

@@ -56,12 +56,13 @@ vi.mock( './headers.js', () => ( { memoToHeaders: ( ...args ) => memoToHeadersMo
 const deepMergeMock = vi.fn( ( a, b ) => ( { ...( a || {} ), ...( b || {} ) } ) );
 vi.mock( '#helpers/object', () => ( { deepMerge: ( ...args ) => deepMergeMock( ...args ) } ) );
 
-const stepOptionsDefault = {};
-vi.mock( '../temp/__activity_options.js', () => ( { default: stepOptionsDefault } ) );
+const activityOptionsDefault = {};
+vi.mock( '../temp/__activity_options.js', () => ( { default: activityOptionsDefault } ) );
 
 describe( 'workflow interceptors', () => {
   beforeEach( () => {
     vi.clearAllMocks();
+    Object.keys( activityOptionsDefault ).forEach( key => delete activityOptionsDefault[key] );
     isCancellationMock.mockReturnValue( false );
     workflowInfoMock.mockReturnValue( workflowInfo );
   } );
@@ -91,11 +92,11 @@ describe( 'workflow interceptors', () => {
       expect( out ).toBe( 'result' );
     } );
 
-    it( 'merges stepOptions with memo.activityOptions when stepOptions exist for activityType', async () => {
-      stepOptionsDefault['MyWorkflow#step1'] = { scheduleToCloseTimeout: 60 };
+    it( 'merges component activity options over the scheduled activity input options', async () => {
+      activityOptionsDefault['MyWorkflow#step1'] = { scheduleToCloseTimeout: 60 };
       workflowInfoMock.mockReturnValue( {
         ...workflowInfo,
-        memo: { traceInfo: workflowInfo.memo.traceInfo, activityOptions: { heartbeatTimeout: 10 } }
+        memo: { traceInfo: workflowInfo.memo.traceInfo }
       } );
       memoToHeadersMock.mockReturnValue( {} );
       deepMergeMock.mockReturnValue( { heartbeatTimeout: 10, scheduleToCloseTimeout: 60 } );
@@ -103,14 +104,13 @@ describe( 'workflow interceptors', () => {
       const { interceptors } = await import( './workflow.js' );
       const { outbound } = interceptors();
       const interceptor = outbound[0];
-      const input = { headers: {}, activityType: 'MyWorkflow#step1' };
+      const input = { headers: {}, activityType: 'MyWorkflow#step1', options: { heartbeatTimeout: 10 } };
       const next = vi.fn().mockResolvedValue( undefined );
 
       await interceptor.scheduleActivity( input, next );
 
       expect( deepMergeMock ).toHaveBeenCalledWith( { heartbeatTimeout: 10 }, { scheduleToCloseTimeout: 60 } );
       expect( input.options ).toEqual( { heartbeatTimeout: 10, scheduleToCloseTimeout: 60 } );
-      delete stepOptionsDefault['MyWorkflow#step1'];
     } );
   } );
 

package/src/worker/loader/activities.js

@@ -2,74 +2,90 @@ import { dirname } from 'node:path';
 import { getTraceDestinations, sendHttpRequest } from '#internal_activities';
 import { findSharedActivitiesFromWorkflows, importComponents, matchFiles, writeFileInTempDir } from './tools.js';
 import { buildActivityMatcher, staticMatchers } from './matchers.js';
-import { ACTIVITY_SEND_HTTP_REQUEST, ACTIVITY_OPTIONS_FILENAME, SHARED_STEP_PREFIX, ACTIVITY_GET_TRACE_DESTINATIONS } from '#consts';
+import { ACTIVITY_SEND_HTTP_REQUEST, ACTIVITY_OPTIONS_FILENAME, ACTIVITY_GET_TRACE_DESTINATIONS } from '#consts';
 import { createChildLogger } from '#logger';
 import { ValidationError } from '#errors';
 
 const log = createChildLogger( 'Activities Loader' );
 
 /**
- * Load activities:
- * - Scans activities based on workflows, using each workflow folder as a point to lookup for steps, evaluators files;
- * - Scans shared activities in the rootDir;
- * - Loads internal activities as well;
+ * Load activities
+ * - Scan local project and external workflow npm packages and look for shared activities.
+ * - For each workflow, register shared activities under the workflow namespace.
+ * - For each workflow, load activities declared relative to that workflow directory.
  *
- * Builds a map of activities, where they is generated according to the type of activity and the value is the function itself and return it.
- * - Shared activity keys have a common prefix followed by the activity name;
- * - Internal activities are registered with a fixed key;
- * - Workflow activities keys are composed using the workflow name and the activity name;
+ * Builds a map of activities, key is workflowType#activityType, value is the component wrapper function.
  *
  * @param {string} rootDir
  * @param {import('./workflows.js').Workflow[]} workflows
  * @returns {object}
  */
 export async function loadActivities( rootDir, workflows ) {
-  const activities = {};
-  const activityOptionsMap = {};
+  const activities = new Map();
+  const activityOptions = new Map();
 
-  // Load workflow-based activities
-  for ( const { path: workflowPath, name: workflowName, external } of workflows ) {
-    const dir = dirname( workflowPath );
-    for await ( const { fn, metadata, path } of importComponents( matchFiles( dir, [ buildActivityMatcher( dir ) ] ) ) ) {
-      // Activities loaded from a workflow path will use the workflow name as a namespace, which is unique across the platform, avoiding collision
-      const activityKey = `${workflowName}#${metadata.name}`;
-
-      log.info( metadata.name, { workflow: workflowName, type: metadata.type, ...( external && { external } ), path } );
-
-      if ( activities[activityKey] ) {
-        throw new ValidationError( `Activity "${metadata.name}" in workflow "${workflowName}" conflicts with another \
-activity in the same workflow. Activity names must be unique within a workflow.` );
-      }
-      activities[activityKey] = fn;
-      // propagate the custom options set on the step()/evaluator() constructor
-      activityOptionsMap[activityKey] = metadata.options?.activityOptions ?? undefined;
-    }
-  }
+  const sharedActivities = new Map();
+  const sharedActivitiesOptions = new Map();
 
   // Load shared activities/evaluators from local and external npm modules
   const localSharedActivities = matchFiles( rootDir, [ staticMatchers.sharedStepsDir, staticMatchers.sharedEvaluatorsDir ] );
   const externalSharedActivities = findSharedActivitiesFromWorkflows( workflows.filter( w => w.external ) );
   for await ( const { fn, metadata, path } of importComponents( [ ...localSharedActivities, ...externalSharedActivities ] ) ) {
     const external = externalSharedActivities.some( a => a.path === path );
-    // Uses a global namespace for shared activities
-    const activityKey = `${SHARED_STEP_PREFIX}#${metadata.name}`;
 
+    if ( sharedActivities.has( metadata.name ) ) {
+      throw new ValidationError( `Shared activity "${metadata.name}" conflicts with another shared activity.` +
+        ' Shared activity names must be unique.' );
+    }
     log.info( metadata.name, { shared: true, type: metadata.type, ...( external && { external } ), path } );
 
-    if ( activities[activityKey] ) {
-      throw new ValidationError( `Shared activity "${metadata.name}" conflicts with another shared activity. \
-Shared activity names must be unique.` );
+    sharedActivities.set( metadata.name, fn );
+    if ( metadata.options?.activityOptions ) {
+      sharedActivitiesOptions.set( metadata.name, metadata.options.activityOptions );
+    }
+  }
+
+  // Discover and load workflow activities
+  for ( const { path: workflowPath, name: workflowName, external } of workflows ) {
+    const dir = dirname( workflowPath );
+
+    // Add shared activities to this workflow namespace
+    for ( const [ name, fn ] of sharedActivities ) {
+      const id = `${workflowName}#${name}`;
+      activities.set( id, fn );
+      if ( sharedActivitiesOptions.has( name ) ) {
+        activityOptions.set( id, sharedActivitiesOptions.get( name ) );
+      }
+    }
+
+    for await ( const { fn, metadata, path } of importComponents( matchFiles( dir, [ buildActivityMatcher( dir ) ] ) ) ) {
+      // Activities loaded from a workflow path will use the workflow name as a namespace, which is unique across the platform, avoiding collision
+      const id = `${workflowName}#${metadata.name}`;
+
+      if ( sharedActivities.has( metadata.name ) ) {
+        throw new ValidationError( `Activity "${metadata.name}" in workflow "${workflowName}" conflicts with a shared activity.` +
+          ' Workflow activity names must not overlap with shared activity names.' );
+      }
+
+      if ( activities.has( id ) ) {
+        throw new ValidationError( `Activity "${metadata.name}" in workflow "${workflowName}" conflicts with another activity in the same workflow.` +
+          ' Activity names must be unique within a workflow.' );
+      }
+
+      log.info( metadata.name, { workflow: workflowName, type: metadata.type, ...( external && { external } ), path } );
+      activities.set( id, fn );
+      if ( metadata.options?.activityOptions ) {
+        activityOptions.set( id, metadata.options.activityOptions );
+      }
     }
-    activities[activityKey] = fn;
-    activityOptionsMap[activityKey] = metadata.options?.activityOptions ?? undefined;
   }
 
   // writes down the activity option overrides
-  const optionsContent = `export default ${JSON.stringify( activityOptionsMap, undefined, 2 )};`;
+  const optionsContent = `export default ${JSON.stringify( Object.fromEntries( activityOptions ), undefined, 2 )};`;
   const optionsFile = writeFileInTempDir( optionsContent, ACTIVITY_OPTIONS_FILENAME );
 
   // system activities
-  activities[ACTIVITY_SEND_HTTP_REQUEST] = sendHttpRequest;
-  activities[ACTIVITY_GET_TRACE_DESTINATIONS] = getTraceDestinations;
-  return { activities, optionsFile };
+  activities.set( ACTIVITY_SEND_HTTP_REQUEST, sendHttpRequest );
+  activities.set( ACTIVITY_GET_TRACE_DESTINATIONS, getTraceDestinations );
+  return { activities: Object.fromEntries( activities ), optionsFile };
 };