@outputai/core 0.8.1-next.e92f632.0 → 0.8.2-dev.e78f6b4.0

package/src/worker/index.spec.js

@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 const {
   catalogJobInstance,
+  bindGlobalFunctionsMock,
   configValues,
   connectionMonitorInstance,
   createCatalogMock,
@@ -44,7 +45,9 @@ const {
     maxCachedWorkflows: 1000,
     maxConcurrentActivityTaskPolls: 5,
     maxConcurrentWorkflowTaskPolls: 5,
-    processFailureShutdownDelay: 0
+    processFailureShutdownDelay: 0,
+    shutdownForceTime: undefined,
+    shutdownGraceTime: undefined
   };
 
   const connectionMonitorInstance = {
@@ -96,6 +99,7 @@ const {
 
   return {
     catalogJobInstance,
+    bindGlobalFunctionsMock: vi.fn(),
     configValues,
     connectionMonitorInstance,
     createCatalogMock: vi.fn().mockReturnValue( { workflows: [], activities: {} } ),
@@ -143,6 +147,7 @@ vi.mock( './interceptors/index.js', () => ( { initInterceptors: initInterceptors
 vi.mock( './proxy.js', () => ( { bootstrapFetchProxy: vi.fn() } ) );
 vi.mock( './telemetry.js', () => ( { setupTelemetry: setupTelemetryMock } ) );
 vi.mock( './interruption.js', () => ( { setupInterruptionHandler: setupInterruptionHandlerMock } ) );
+vi.mock( './global_functions.js', () => ( { bindGlobalFunctions: bindGlobalFunctionsMock } ) );
 vi.mock( './connection_monitor.js', () => ( {
   TemporalConnectionMonitor: vi.fn( function () {
     return connectionMonitorInstance;
@@ -180,6 +185,8 @@ describe( 'worker/index', () => {
     resetPromises();
     configValues.apiKey = undefined;
     configValues.grpcProxy = undefined;
+    configValues.shutdownForceTime = undefined;
+    configValues.shutdownGraceTime = undefined;
     catalogJobInstance.error = null;
     catalogJobInstance.errorCb = null;
     catalogJobInstance.running = false;
@@ -218,6 +225,10 @@ describe( 'worker/index', () => {
       apiKey: undefined,
       proxy: undefined
     } );
+    expect( bindGlobalFunctionsMock ).toHaveBeenCalledTimes( 1 );
+    expect( bindGlobalFunctionsMock.mock.invocationCallOrder[0] ).toBeLessThan(
+      NativeConnection.connect.mock.invocationCallOrder[0]
+    );
     expect( TemporalConnectionMonitor ).toHaveBeenCalledWith( mockConnection );
     expect( CatalogJob ).toHaveBeenCalledWith( {
       connection: mockConnection,
@@ -237,6 +248,8 @@ describe( 'worker/index', () => {
       maxConcurrentActivityTaskPolls: configValues.maxConcurrentActivityTaskPolls,
       maxConcurrentWorkflowTaskPolls: configValues.maxConcurrentWorkflowTaskPolls
     } ) );
+    expect( Worker.create.mock.calls[0][0] ).not.toHaveProperty( 'shutdownForceTime' );
+    expect( Worker.create.mock.calls[0][0] ).not.toHaveProperty( 'shutdownGraceTime' );
     expect( initInterceptorsMock ).toHaveBeenCalledWith( { activities: {}, workflows: [] } );
     expect( setupTelemetryMock ).toHaveBeenCalledWith( { worker: mockWorker } );
     expect( setupInterruptionHandlerMock ).toHaveBeenCalledWith( expect.any( Function ) );
@@ -264,6 +277,21 @@ describe( 'worker/index', () => {
     await settleWorker();
   } );
 
+  it( 'passes configured shutdown durations to the worker', async () => {
+    configValues.shutdownForceTime = '30s';
+    configValues.shutdownGraceTime = '10s';
+    const { Worker } = await import( '@temporalio/worker' );
+
+    await importWorker();
+
+    await vi.waitFor( () => expect( Worker.create ).toHaveBeenCalledWith( expect.objectContaining( {
+      shutdownForceTime: '30s',
+      shutdownGraceTime: '10s'
+    } ) ) );
+
+    await settleWorker();
+  } );
+
   it( 'runs graceful shutdown when interrupted', async () => {
     await importWorker();
 

package/src/worker/interceptors/activity.js

@@ -5,8 +5,8 @@ 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 { aggregateAttributes } from '#internal_utils/aggregations';
-import { buildApplicationFailureWithDetails } from '#internal_utils/errors';
+import { aggregateAttributes } from '#helpers/aggregations';
+import { buildApplicationFailureWithDetails } from '#helpers/errors';
 
 /*
   This interceptor wraps every activity execution with cross-cutting concerns:

package/src/worker/interceptors/workflow.js

@@ -1,10 +1,10 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
 import { workflowInfo, proxySinks, ContinueAsNew, isCancellation } from '@temporalio/workflow';
 import { memoToHeaders } from './headers.js';
-import { deepMerge } from '#utils';
-import { buildApplicationFailureWithDetails } from '#internal_utils/errors';
+import { deepMerge } from '#helpers/object';
+import { buildApplicationFailureWithDetails } from '#helpers/errors';
 import { METADATA_ACCESS_SYMBOL, WorkflowSpecialOutput } from '#consts';
-import { createWorkflowDetails } from '#internal_utils/temporal_context';
+import { createWorkflowDetails } from '#helpers/temporal_context';
 
 // this is a dynamic generated file with activity configs overwrites
 import stepOptions from '../temp/__activity_options.js';

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

@@ -54,7 +54,7 @@ const memoToHeadersMock = vi.fn( memo => ( memo ? { ...memo, __asHeaders: true }
 vi.mock( './headers.js', () => ( { memoToHeaders: ( ...args ) => memoToHeadersMock( ...args ) } ) );
 
 const deepMergeMock = vi.fn( ( a, b ) => ( { ...( a || {} ), ...( b || {} ) } ) );
-vi.mock( '#utils', () => ( { deepMerge: ( ...args ) => deepMergeMock( ...args ) } ) );
+vi.mock( '#helpers/object', () => ( { deepMerge: ( ...args ) => deepMergeMock( ...args ) } ) );
 
 const stepOptionsDefault = {};
 vi.mock( '../temp/__activity_options.js', () => ( { default: stepOptionsDefault } ) );

package/src/worker/loader/matchers.js

@@ -1,5 +1,5 @@
 import { sep } from 'node:path';
-import { rxEscape } from '#utils';
+import { rxEscape } from '#helpers/string';
 
 /**
  * Creates a matcher function that based on "path", matches:

package/src/worker/loader/tools.js

@@ -252,7 +252,7 @@ export const hashSourceCode = async rootDir => {
   try {
     const { hash } = await hashElement( rootDir, {
       folders: {
-        exclude: [ '.*', 'node_modules', 'test_coverage', 'vendor', 'test', 'logs', 'dist' ],
+        exclude: [ '.*', 'node_modules', 'test_coverage', 'vendor', 'test', 'logs', 'temp' ],
         ignoreRootName: true
       },
       files: {

package/src/worker/loader/tools.spec.js

@@ -574,7 +574,7 @@ describe( 'hashSourceCode', () => {
 
     // The cruft tree is identical source plus large excluded artifacts that
     // boot must not walk: local trace dumps under logs/ and build output under dist/.
-    for ( const excluded of [ 'logs', 'logs/runs', 'dist', 'node_modules' ] ) {
+    for ( const excluded of [ 'logs', 'logs/runs', 'node_modules' ] ) {
       const dir = join( withCruft, excluded );
       mkdirSync( dir, { recursive: true } );
       writeFileSync( join( dir, 'dump.json' ), JSON.stringify( { blob: 'x'.repeat( 50_000 ) } ) );

package/src/worker/log_hooks.js

@@ -47,6 +47,13 @@ messageBus.on( BusEventType.ACTIVITY_ERROR, ( { activityInfo, outputActivityKind
   } )
 );
 
+messageBus.on( BusEventType.ACTIVITY_LOG, ( { level, message, metadata, activityInfo } ) =>
+  activityLog[level]( message, {
+    ...metadata ?? {},
+    ...serializedActivityFields( activityInfo )
+  } )
+);
+
 /*
 ╔═════════════════╗
 ║ Workflow events ║
@@ -82,3 +89,10 @@ messageBus.on( BusEventType.WORKFLOW_ERROR, ( { workflowDetails, error } ) =>
     error: error.message
   } )
 );
+
+messageBus.on( BusEventType.WORKFLOW_LOG, ( { level, message, metadata, workflowDetails } ) =>
+  workflowLog[level]( message, {
+    ...metadata ?? {},
+    ...serializeWorkflowFields( workflowDetails )
+  } )
+);

package/src/worker/log_hooks.spec.js

@@ -6,8 +6,17 @@ import {
   WORKFLOW_CATALOG
 } from '#consts';
 
-const activityLogMock = vi.hoisted( () => ( { info: vi.fn(), error: vi.fn() } ) );
-const workflowLogMock = vi.hoisted( () => ( { info: vi.fn(), error: vi.fn() } ) );
+const createLoggerMock = vi.hoisted( () => () => ( {
+  error: vi.fn(),
+  warn: vi.fn(),
+  info: vi.fn(),
+  http: vi.fn(),
+  verbose: vi.fn(),
+  debug: vi.fn(),
+  silly: vi.fn()
+} ) );
+const activityLogMock = vi.hoisted( () => createLoggerMock() );
+const workflowLogMock = vi.hoisted( () => createLoggerMock() );
 const createChildLoggerMock = vi.hoisted( () =>
   vi.fn( name => ( name === 'Activity' ? activityLogMock : workflowLogMock ) )
 );
@@ -125,6 +134,44 @@ describe( 'log_hooks', () => {
 
       expect( activityLogMock.error ).not.toHaveBeenCalled();
     } );
+
+    it( 'ACTIVITY_LOG logs dynamic levels with metadata and serialized activity fields', () => {
+      onHandlers[BusEventType.ACTIVITY_LOG]( {
+        activityInfo,
+        level: 'debug',
+        message: 'activity detail',
+        metadata: {
+          custom: 'value',
+          workflowId: 'metadata-workflow-id'
+        }
+      } );
+
+      expect( activityLogMock.debug ).toHaveBeenCalledTimes( 1 );
+      expect( activityLogMock.debug ).toHaveBeenCalledWith( 'activity detail', {
+        custom: 'value',
+        activityId: 'act-1',
+        activityType: 'myWorkflow#myStep',
+        workflowId: 'wf-1',
+        workflowType: 'myWorkflow',
+        runId: 'run-1'
+      } );
+    } );
+
+    it( 'ACTIVITY_LOG accepts omitted metadata', () => {
+      onHandlers[BusEventType.ACTIVITY_LOG]( {
+        activityInfo,
+        level: 'info',
+        message: 'activity detail'
+      } );
+
+      expect( activityLogMock.info ).toHaveBeenCalledWith( 'activity detail', {
+        activityId: 'act-1',
+        activityType: 'myWorkflow#myStep',
+        workflowId: 'wf-1',
+        workflowType: 'myWorkflow',
+        runId: 'run-1'
+      } );
+    } );
   } );
 
   describe( 'workflow events', () => {
@@ -210,5 +257,39 @@ describe( 'log_hooks', () => {
 
       expect( workflowLogMock.error ).not.toHaveBeenCalled();
     } );
+
+    it( 'WORKFLOW_LOG logs dynamic levels with metadata and serialized workflow fields', () => {
+      onHandlers[BusEventType.WORKFLOW_LOG]( {
+        workflowDetails,
+        level: 'warn',
+        message: 'workflow detail',
+        metadata: {
+          custom: 'value',
+          runId: 'metadata-run-id'
+        }
+      } );
+
+      expect( workflowLogMock.warn ).toHaveBeenCalledTimes( 1 );
+      expect( workflowLogMock.warn ).toHaveBeenCalledWith( 'workflow detail', {
+        custom: 'value',
+        workflowId: 'wf-1',
+        workflowType: 'myWorkflow',
+        runId: 'run-1'
+      } );
+    } );
+
+    it( 'WORKFLOW_LOG accepts omitted metadata', () => {
+      onHandlers[BusEventType.WORKFLOW_LOG]( {
+        workflowDetails,
+        level: 'info',
+        message: 'workflow detail'
+      } );
+
+      expect( workflowLogMock.info ).toHaveBeenCalledWith( 'workflow detail', {
+        workflowId: 'wf-1',
+        workflowType: 'myWorkflow',
+        runId: 'run-1'
+      } );
+    } );
   } );
 } );

package/src/worker/sinks.js

@@ -1,7 +1,7 @@
 import { BusEventType, ComponentType } from '#consts';
 import * as Tracing from '#tracing';
 import { messageBus } from '#bus';
-import { createWorkflowDetails } from '#internal_utils/temporal_context';
+import { createWorkflowDetails } from '#helpers/temporal_context';
 
 // This sink allow for sandbox Temporal environment to send trace logs back to the main thread.
 export const sinks = {
@@ -10,6 +10,12 @@ export const sinks = {
    * Workflow lifecycle sinks
    */
   workflow: {
+    log: {
+      fn: ( workflowInfo, { level, message, metadata } ) => {
+        messageBus.emit( BusEventType.WORKFLOW_LOG, { level, message, metadata, workflowDetails: createWorkflowDetails( workflowInfo ) } );
+      },
+      callDuringReplay: false
+    },
     start: {
       fn: ( workflowInfo, input ) => {
         const { runId, workflowType, memo: { traceInfo }, parent } = workflowInfo;

package/src/worker/sinks.spec.js

@@ -0,0 +1,203 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { BusEventType, ComponentType } from '#consts';
+
+const messageBusMock = vi.hoisted( () => ( {
+  emit: vi.fn()
+} ) );
+
+const addEventStartMock = vi.hoisted( () => vi.fn() );
+const addEventEndMock = vi.hoisted( () => vi.fn() );
+const addEventErrorMock = vi.hoisted( () => vi.fn() );
+
+const createWorkflowDetailsMock = vi.hoisted( () => vi.fn( workflowInfo => ( {
+  workflowId: workflowInfo.workflowId,
+  workflowType: workflowInfo.workflowType,
+  runId: workflowInfo.runId
+} ) ) );
+
+vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+vi.mock( '#tracing', () => ( {
+  addEventStart: addEventStartMock,
+  addEventEnd: addEventEndMock,
+  addEventError: addEventErrorMock
+} ) );
+vi.mock( '#helpers/temporal_context', () => ( {
+  createWorkflowDetails: createWorkflowDetailsMock
+} ) );
+
+describe( 'worker/sinks', () => {
+  const workflowInfo = {
+    workflowId: 'wf-1',
+    workflowType: 'myWorkflow',
+    runId: 'run-1',
+    memo: {
+      traceInfo: { traceId: 'trace-1' }
+    },
+    parent: {
+      runId: 'parent-run-1'
+    }
+  };
+  const workflowDetails = {
+    workflowId: 'wf-1',
+    workflowType: 'myWorkflow',
+    runId: 'run-1'
+  };
+
+  beforeEach( () => {
+    vi.clearAllMocks();
+  } );
+
+  it( 'disables replay calls for side-effecting sinks', async () => {
+    const { sinks } = await import( './sinks.js' );
+
+    expect( sinks.workflow.start.callDuringReplay ).toBe( false );
+    expect( sinks.workflow.end.callDuringReplay ).toBe( false );
+    expect( sinks.workflow.error.callDuringReplay ).toBe( false );
+    expect( sinks.trace.start.callDuringReplay ).toBe( false );
+    expect( sinks.trace.end.callDuringReplay ).toBe( false );
+    expect( sinks.trace.error.callDuringReplay ).toBe( false );
+  } );
+
+  it( 'workflow.log emits workflow log events with metadata and workflow details', async () => {
+    const { sinks } = await import( './sinks.js' );
+    const metadata = { requestId: 'req-1' };
+
+    sinks.workflow.log.fn( workflowInfo, {
+      level: 'info',
+      message: 'workflow detail',
+      metadata
+    } );
+
+    expect( createWorkflowDetailsMock ).toHaveBeenCalledWith( workflowInfo );
+    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_LOG, {
+      level: 'info',
+      message: 'workflow detail',
+      metadata,
+      workflowDetails
+    } );
+  } );
+
+  it( 'workflow.start emits workflow start events and trace start events', async () => {
+    const { sinks } = await import( './sinks.js' );
+    const input = { value: 'input' };
+
+    sinks.workflow.start.fn( workflowInfo, input );
+
+    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_START, { workflowDetails } );
+    expect( addEventStartMock ).toHaveBeenCalledWith( {
+      id: 'run-1',
+      kind: ComponentType.WORKFLOW,
+      name: 'myWorkflow',
+      details: input,
+      parentId: 'parent-run-1',
+      traceInfo: { traceId: 'trace-1' }
+    } );
+  } );
+
+  it( 'workflow.start skips tracing when trace info is absent', async () => {
+    const { sinks } = await import( './sinks.js' );
+
+    sinks.workflow.start.fn( { ...workflowInfo, memo: {} }, { value: 'input' } );
+
+    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_START, { workflowDetails } );
+    expect( addEventStartMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'workflow.end emits workflow end events and trace end events', async () => {
+    const { sinks } = await import( './sinks.js' );
+    const output = { value: 'output' };
+
+    sinks.workflow.end.fn( workflowInfo, output );
+
+    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_END, { workflowDetails } );
+    expect( addEventEndMock ).toHaveBeenCalledWith( {
+      id: 'run-1',
+      details: output,
+      traceInfo: { traceId: 'trace-1' }
+    } );
+  } );
+
+  it( 'workflow.end skips tracing when trace info is absent', async () => {
+    const { sinks } = await import( './sinks.js' );
+
+    sinks.workflow.end.fn( { ...workflowInfo, memo: {} }, { value: 'output' } );
+
+    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_END, { workflowDetails } );
+    expect( addEventEndMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'workflow.error emits workflow error events and trace error events', async () => {
+    const { sinks } = await import( './sinks.js' );
+    const error = new Error( 'workflow failed' );
+
+    sinks.workflow.error.fn( workflowInfo, error );
+
+    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, { workflowDetails, error } );
+    expect( addEventErrorMock ).toHaveBeenCalledWith( {
+      id: 'run-1',
+      details: error,
+      traceInfo: { traceId: 'trace-1' }
+    } );
+  } );
+
+  it( 'workflow.error skips tracing when trace info is absent', async () => {
+    const { sinks } = await import( './sinks.js' );
+    const error = new Error( 'workflow failed' );
+
+    sinks.workflow.error.fn( { ...workflowInfo, memo: {} }, error );
+
+    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, { workflowDetails, error } );
+    expect( addEventErrorMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'trace.start records trace start events with workflow parent context', async () => {
+    const { sinks } = await import( './sinks.js' );
+
+    sinks.trace.start.fn( workflowInfo, {
+      id: 'step-1',
+      kind: ComponentType.STEP,
+      name: 'myStep',
+      details: { input: true }
+    } );
+
+    expect( addEventStartMock ).toHaveBeenCalledWith( {
+      id: 'step-1',
+      kind: ComponentType.STEP,
+      name: 'myStep',
+      details: { input: true },
+      parentId: 'parent-run-1',
+      traceInfo: { traceId: 'trace-1' }
+    } );
+  } );
+
+  it( 'trace.end records trace end events', async () => {
+    const { sinks } = await import( './sinks.js' );
+
+    sinks.trace.end.fn( workflowInfo, {
+      id: 'step-1',
+      details: { output: true }
+    } );
+
+    expect( addEventEndMock ).toHaveBeenCalledWith( {
+      id: 'step-1',
+      details: { output: true },
+      traceInfo: { traceId: 'trace-1' }
+    } );
+  } );
+
+  it( 'trace.error records trace error events', async () => {
+    const { sinks } = await import( './sinks.js' );
+    const error = new Error( 'step failed' );
+
+    sinks.trace.error.fn( workflowInfo, {
+      id: 'step-1',
+      details: error
+    } );
+
+    expect( addEventErrorMock ).toHaveBeenCalledWith( {
+      id: 'step-1',
+      details: error,
+      traceInfo: { traceId: 'trace-1' }
+    } );
+  } );
+} );

package/src/activity_integration/context.d.ts

@@ -1,23 +0,0 @@
-import type { Info } from '@temporalio/activity';
-/**
- * Context returned by {@link getContext} when running inside a Temporal Activity (step or evaluator).
- */
-export type Context = {
-  /** Temporal info about the current activity */
-  activityInfo: Info,
-  /** Path of the workflow file */
-  workflowFilename: string
-};
-
-/**
- * Returns information about the current Temporal execution.
- *
- * Only available when called from within a step or evaluator (Temporal Activities) running in the Temporal runtime.
- *
- * @remarks
- * - Returns `null` when not called inside a Temporal Activity (steps/evaluators);
- * - Returns `null` when not called from within a running Temporal worker, like in unit tests environment;
- *
- * @returns The workflow context, or `null` if unavailable or incomplete.
- */
-export declare function getExecutionContext(): Context | null;

package/src/activity_integration/context.js

@@ -1,18 +0,0 @@
-import { Storage } from '#async_storage';
-
-/**
- * Returns information trapped on AsyncStorage about the workflow invoking an activity
- *
- * @returns {object}
- */
-export const getExecutionContext = () => {
-  const ctx = Storage.load();
-  if ( !ctx ) {
-    return null;
-  }
-
-  return {
-    workflowFilename: ctx.workflowFilename,
-    activityInfo: ctx.activityInfo
-  };
-};

package/src/activity_integration/event_id_integration.spec.js

@@ -1,52 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { messageBus } from '#bus';
-import { emitEvent } from './events.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;
-
-describe( 'eventId integration', () => {
-  beforeEach( () => {
-    messageBus.removeAllListeners();
-  } );
-
-  it( 'stamps a UUID v4 eventId on every emit (end-to-end via messageBus)', () => {
-    const handler = vi.fn();
-    messageBus.on( 'external:cost:llm:request', handler );
-
-    emitEvent( 'cost:llm:request', { modelId: 'gpt-4o' } );
-
-    expect( handler ).toHaveBeenCalledWith( expect.objectContaining( {
-      eventId: expect.stringMatching( UUID_V4_REGEX ),
-      modelId: 'gpt-4o'
-    } ) );
-  } );
-
-  it( 'cost:http:request and http:request for the same fetch get distinct eventIds', () => {
-    const costHandler = vi.fn();
-    const reqHandler = vi.fn();
-    messageBus.on( 'external:cost:http:request', costHandler );
-    messageBus.on( 'external:http:request', reqHandler );
-
-    const sharedRequestId = 'req-xyz';
-    emitEvent( 'cost:http:request', { requestId: sharedRequestId, url: 'https://x.test', cost: 1 } );
-    emitEvent( 'http:request', { requestId: sharedRequestId, url: 'https://x.test', status: 200 } );
-
-    const costEventId = costHandler.mock.calls[0][0].eventId;
-    const reqEventId = reqHandler.mock.calls[0][0].eventId;
-    expect( costEventId ).toMatch( UUID_V4_REGEX );
-    expect( reqEventId ).toMatch( UUID_V4_REGEX );
-    expect( costEventId ).not.toBe( reqEventId );
-  } );
-
-  it( 'honors a caller-supplied eventId end-to-end', () => {
-    const handler = vi.fn();
-    messageBus.on( 'external:custom:event', handler );
-
-    emitEvent( 'custom:event', { eventId: 'fixed-id-123', payload: 'hi' } );
-
-    expect( handler ).toHaveBeenCalledWith( expect.objectContaining( {
-      eventId: 'fixed-id-123',
-      payload: 'hi'
-    } ) );
-  } );
-} );

package/src/activity_integration/events.d.ts

@@ -1,10 +0,0 @@
-/**
- * Emits a custom event on the in-process message bus.
- *
- * When called inside an Output activity context, the framework automatically
- * attaches `activityInfo`, `workflowDetails`, and `outputActivityKind` onto the emitted payload.
- *
- * @param eventName - The name of the event to emit
- * @param payload - An optional payload to send to the event
- */
-export declare function emitEvent( eventName: string, payload?: unknown ): void;

package/src/activity_integration/events.js

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

package/src/activity_integration/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * > [!WARNING]
- * > **Internal use only.** Not part of the public API; may change without notice.
- *
- * @packageDocumentation
- */
-export { getExecutionContext } from './context';
-export { emitEvent } from './events';
-export * as Tracing from './tracing';

package/src/activity_integration/index.js

@@ -1,3 +0,0 @@
-export { getExecutionContext } from './context.js';
-export { emitEvent } from './events.js';
-export * as Tracing from './tracing.js';