@outputai/core 0.5.1-next.93f660c.0 → 0.5.2-next.17d8711.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.5.1-next.93f660c.0",
+  "version": "0.5.2-next.17d8711.0",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {

package/src/activity_integration/event_id_integration.spec.js

@@ -0,0 +1,52 @@
+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.spec.js

@@ -13,6 +13,9 @@ vi.mock( '#bus', () => ( {
 
 import { emitEvent } from './events.js';
 
+// `eventId` stamping is the bus layer's responsibility (see bus.spec.js + the
+// integration tests in event_id_integration.spec.js). Assertions here use
+// `objectContaining` so they don't have to know about that enrichment.
 describe( 'emitEvent', () => {
   beforeEach( () => {
     vi.clearAllMocks();
@@ -26,12 +29,12 @@ describe( 'emitEvent', () => {
 
     emitEvent( 'cost:llm:request', { modelId: 'gpt-4o' } );
 
-    expect( emitMock ).toHaveBeenCalledWith( 'external:cost:llm:request', {
+    expect( emitMock ).toHaveBeenCalledWith( 'external:cost:llm:request', expect.objectContaining( {
       workflowId: 'wf-1',
       runId: 'run-1',
       activityId: 'act-1',
       modelId: 'gpt-4o'
-    } );
+    } ) );
   } );
 
   it( 'handles missing executionContext gracefully', () => {
@@ -39,12 +42,12 @@ describe( 'emitEvent', () => {
 
     emitEvent( 'foo:bar', { x: 1 } );
 
-    expect( emitMock ).toHaveBeenCalledWith( 'external:foo:bar', {
+    expect( emitMock ).toHaveBeenCalledWith( 'external:foo:bar', expect.objectContaining( {
       workflowId: undefined,
       runId: undefined,
       activityId: undefined,
       x: 1
-    } );
+    } ) );
   } );
 
   it( 'handles missing payload', () => {
@@ -55,11 +58,11 @@ describe( 'emitEvent', () => {
 
     emitEvent( 'lifecycle:start' );
 
-    expect( emitMock ).toHaveBeenCalledWith( 'external:lifecycle:start', {
+    expect( emitMock ).toHaveBeenCalledWith( 'external:lifecycle:start', expect.objectContaining( {
       workflowId: 'wf-2',
       runId: 'run-2',
       activityId: 'act-2'
-    } );
+    } ) );
   } );
 
   it( 'does not let payload override workflowId / runId / activityId', () => {
@@ -77,11 +80,11 @@ describe( 'emitEvent', () => {
 
     // Context fields are spread after the payload, so caller-supplied
     // workflowId / runId / activityId cannot escape the executionContext.
-    expect( emitMock ).toHaveBeenCalledWith( 'external:cost:http:request', {
+    expect( emitMock ).toHaveBeenCalledWith( 'external:cost:http:request', expect.objectContaining( {
       workflowId: 'wf-3',
       runId: 'run-3',
       activityId: 'act-3',
       url: 'https://example.com'
-    } );
+    } ) );
   } );
 } );

package/src/bus.js

@@ -1,3 +1,21 @@
 import { EventEmitter } from 'node:events';
+import { randomUUID } from 'node:crypto';
+import { isPlainObject } from '#utils';
 
-export const messageBus = new EventEmitter();
+const emitter = new EventEmitter();
+const originalEmit = emitter.emit.bind( emitter );
+
+const attachEventId = payload => ( { ...payload, eventId: payload.eventId ?? randomUUID() } );
+
+/**
+ * Every object payload emitted through `messageBus` is stamped with a UUID v4 `eventId`.
+ */
+emitter.emit = ( event, ...args ) => {
+  const [ payload, ...rest ] = args;
+  if ( !isPlainObject( payload ) ) {
+    return originalEmit( event, ...args );
+  }
+  return originalEmit( event, attachEventId( payload ), ...rest );
+};
+
+export const messageBus = emitter;

package/src/bus.spec.js

@@ -0,0 +1,108 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { messageBus } 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;
+
+describe( 'messageBus', () => {
+  beforeEach( () => {
+    messageBus.removeAllListeners();
+  } );
+
+  describe( 'eventId stamping', () => {
+    it( 'stamps a UUID v4 eventId on every object payload', () => {
+      const handler = vi.fn();
+      messageBus.on( 'test:event', handler );
+
+      messageBus.emit( 'test:event', { foo: 'bar' } );
+
+      expect( handler ).toHaveBeenCalledWith( expect.objectContaining( {
+        foo: 'bar',
+        eventId: expect.stringMatching( UUID_V4_REGEX )
+      } ) );
+    } );
+
+    it( 'gives distinct emits distinct eventIds', () => {
+      const handler = vi.fn();
+      messageBus.on( 'test:event', handler );
+
+      messageBus.emit( 'test:event', { i: 1 } );
+      messageBus.emit( 'test:event', { i: 2 } );
+
+      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( 'preserves a caller-supplied eventId (deterministic retry case)', () => {
+      const handler = vi.fn();
+      messageBus.on( 'test:event', handler );
+
+      messageBus.emit( 'test:event', { eventId: 'fixed-id', foo: 'bar' } );
+
+      expect( handler ).toHaveBeenCalledWith( expect.objectContaining( {
+        eventId: 'fixed-id',
+        foo: 'bar'
+      } ) );
+    } );
+
+    it( 'does not mutate the caller-supplied payload object', () => {
+      const handler = vi.fn();
+      messageBus.on( 'test:event', handler );
+
+      const payload = { foo: 'bar' };
+      messageBus.emit( 'test:event', payload );
+
+      expect( payload ).not.toHaveProperty( 'eventId' );
+    } );
+  } );
+
+  describe( 'pass-through behavior', () => {
+    it( 'passes primitive payloads through unchanged', () => {
+      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 );
+    } );
+
+    it( 'passes null and undefined payloads through unchanged', () => {
+      const handler = vi.fn();
+      messageBus.on( 'test:event', handler );
+
+      messageBus.emit( 'test:event', null );
+      messageBus.emit( 'test:event' );
+
+      expect( handler ).toHaveBeenNthCalledWith( 1, null );
+      expect( handler ).toHaveBeenNthCalledWith( 2 );
+    } );
+
+    it( 'passes array payloads through unchanged (no key injection)', () => {
+      const handler = vi.fn();
+      messageBus.on( 'test:event', handler );
+
+      messageBus.emit( 'test:event', [ 1, 2, 3 ] );
+
+      expect( handler ).toHaveBeenCalledWith( [ 1, 2, 3 ] );
+    } );
+
+    it( 'forwards additional positional args untouched', () => {
+      const handler = vi.fn();
+      messageBus.on( 'test:event', handler );
+
+      messageBus.emit( 'test:event', { foo: 'bar' }, 'extra', 99 );
+
+      expect( handler ).toHaveBeenCalledWith(
+        expect.objectContaining( { foo: 'bar', eventId: expect.stringMatching( UUID_V4_REGEX ) } ),
+        'extra',
+        99
+      );
+    } );
+  } );
+} );

package/src/hooks/index.d.ts

@@ -2,6 +2,8 @@
  * Payload passed to the onError handler when a workflow, activity or runtime error occurs.
  */
 export interface ErrorHookPayload {
+  /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
+  eventId: string;
   /** Origin of the error: workflow execution, activity execution, or runtime. */
   source: 'workflow' | 'activity' | 'runtime';
   /** Name of the workflow, when the error is scoped to a workflow or activity. */
@@ -16,6 +18,8 @@ export interface ErrorHookPayload {
  * Payload passed to the onWorkflowStart handler when a workflow run begins.
  */
 export interface WorkflowStartHookPayload {
+  /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
+  eventId: string;
   /** Workflow id (stable across retries / continue-as-new). */
   id: string;
   /** Temporal run id for the current execution attempt. */
@@ -28,6 +32,8 @@ export interface WorkflowStartHookPayload {
  * Payload passed to the onWorkflowEnd handler when a workflow run completes successfully.
  */
 export interface WorkflowEndHookPayload {
+  /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
+  eventId: string;
   /** Workflow id (stable across retries / continue-as-new). */
   id: string;
   /** Temporal run id for the current execution attempt. */
@@ -42,6 +48,8 @@ export interface WorkflowEndHookPayload {
  * Payload passed to the onWorkflowError handler when a workflow run fails.
  */
 export interface WorkflowErrorHookPayload {
+  /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
+  eventId: string;
   /** Workflow id (stable across retries / continue-as-new). */
   id: string;
   /** Temporal run id for the current execution attempt. */
@@ -107,6 +115,8 @@ export declare function onWorkflowError( handler: ( payload: WorkflowErrorHookPa
  * to the fields listed here.
  */
 export interface HttpRequestHookPayload {
+  /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
+  eventId: string;
   /** Workflow id (stable across retries / continue-as-new). */
   workflowId: string;
   /** Temporal run id for the current execution attempt. */

package/src/hooks/index.js

@@ -21,12 +21,12 @@ const safeInvoke = async ( fn, args, hookName ) => {
 
 /** Triggers on any errors: workflow, activity and runtime */
 export const onError = handler => {
-  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 } ) =>
-    safeInvoke( handler, { source: 'runtime', error }, 'onError' ) );
+  messageBus.on( BusEventType.ACTIVITY_ERROR, async ( { eventId, id, name, workflowId, workflowName, error } ) =>
+    safeInvoke( handler, { eventId, source: 'activity', activityId: id, activityName: name, workflowId, workflowName, error }, 'onError' ) );
+  messageBus.on( BusEventType.WORKFLOW_ERROR, async ( { eventId, id, name, error } ) =>
+    safeInvoke( handler, { eventId, source: 'workflow', workflowId: id, workflowName: name, error }, 'onError' ) );
+  messageBus.on( BusEventType.RUNTIME_ERROR, async ( { eventId, error } ) =>
+    safeInvoke( handler, { eventId, source: 'runtime', error }, 'onError' ) );
 };
 
 /** Listen to worker before start events */
@@ -34,16 +34,16 @@ export const onBeforeWorkerStart = handler => messageBus.on( BusEventType.WORKER
   safeInvoke( handler, undefined, 'onBeforeWorkerStart' ) );
 
 /** Listen to workflow start events, excludes catalog workflow */
-export const onWorkflowStart = handler => messageBus.on( BusEventType.WORKFLOW_START, ( { id, runId, name } ) =>
-  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { id, runId, name }, 'onWorkflowStart' ) : null );
+export const onWorkflowStart = handler => messageBus.on( BusEventType.WORKFLOW_START, ( { eventId, id, runId, name } ) =>
+  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { eventId, id, runId, name }, 'onWorkflowStart' ) : null );
 
 /** Listen to workflow end events, excludes catalog workflow */
-export const onWorkflowEnd = handler => messageBus.on( BusEventType.WORKFLOW_END, ( { id, runId, name, duration } ) =>
-  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { id, runId, name, duration }, 'onWorkflowEnd' ) : null );
+export const onWorkflowEnd = handler => messageBus.on( BusEventType.WORKFLOW_END, ( { eventId, id, runId, name, duration } ) =>
+  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { eventId, id, runId, name, duration }, 'onWorkflowEnd' ) : null );
 
 /** Listen to workflow error events, excludes catalog workflow */
-export const onWorkflowError = handler => messageBus.on( BusEventType.WORKFLOW_ERROR, ( { id, runId, name, duration, error } ) =>
-  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { id, runId, name, duration, error }, 'onWorkflowError' ) : null );
+export const onWorkflowError = handler => messageBus.on( BusEventType.WORKFLOW_ERROR, ( { eventId, id, runId, name, duration, error } ) =>
+  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { eventId, id, runId, name, duration, error }, 'onWorkflowError' ) : null );
 
 /** Generic listener for events emitted elsewhere (outside core) */
 export const on = ( eventName, handler ) => messageBus.on( `external:${eventName}`, payload =>

package/src/hooks/index.spec.js

@@ -43,12 +43,13 @@ describe( 'hooks/index', () => {
       expect( messageBusMock.on ).toHaveBeenCalledWith( BusEventType.RUNTIME_ERROR, expect.any( Function ) );
     } );
 
-    it( 'invokes handler with activity-shaped payload', async () => {
+    it( 'invokes handler with activity-shaped payload, forwarding eventId', async () => {
       const handler = vi.fn().mockResolvedValue( undefined );
       onError( handler );
 
       const err = new Error( 'act-fail' );
       await onHandlers[BusEventType.ACTIVITY_ERROR]( {
+        eventId: 'evt-act-1',
         id: 'act-1',
         name: 'wf#step',
         workflowId: 'wf-run-1',
@@ -57,6 +58,7 @@ describe( 'hooks/index', () => {
       } );
 
       expect( handler ).toHaveBeenCalledWith( {
+        eventId: 'evt-act-1',
         source: 'activity',
         activityId: 'act-1',
         activityName: 'wf#step',
@@ -66,18 +68,20 @@ describe( 'hooks/index', () => {
       } );
     } );
 
-    it( 'invokes handler with workflow-shaped payload', async () => {
+    it( 'invokes handler with workflow-shaped payload, forwarding eventId', async () => {
       const handler = vi.fn().mockResolvedValue( undefined );
       onError( handler );
 
       const err = new Error( 'wf-fail' );
       await onHandlers[BusEventType.WORKFLOW_ERROR]( {
+        eventId: 'evt-wf-1',
         id: 'wf-run-2',
         name: 'myWorkflow',
         error: err
       } );
 
       expect( handler ).toHaveBeenCalledWith( {
+        eventId: 'evt-wf-1',
         source: 'workflow',
         workflowId: 'wf-run-2',
         workflowName: 'myWorkflow',
@@ -90,9 +94,9 @@ describe( 'hooks/index', () => {
       onError( handler );
 
       const error = new Error( 'rt' );
-      await onHandlers[BusEventType.RUNTIME_ERROR]( { error } );
+      await onHandlers[BusEventType.RUNTIME_ERROR]( { eventId: 'evt-rt-1', error } );
 
-      expect( handler ).toHaveBeenCalledWith( { source: 'runtime', error } );
+      expect( handler ).toHaveBeenCalledWith( { eventId: 'evt-rt-1', source: 'runtime', error } );
     } );
   } );
 
@@ -109,56 +113,60 @@ describe( 'hooks/index', () => {
   } );
 
   describe( 'onWorkflowStart', () => {
-    it( 'skips catalog workflow name', async () => {
+    it( 'skips catalog workflow and forwards eventId for real workflows', async () => {
       const handler = vi.fn().mockResolvedValue( undefined );
       onWorkflowStart( handler );
 
-      await Promise.resolve( onHandlers[BusEventType.WORKFLOW_START]( { id: '1', name: WORKFLOW_CATALOG } ) );
+      await Promise.resolve( onHandlers[BusEventType.WORKFLOW_START]( {
+        eventId: 'evt-ignored', 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' } );
+      await Promise.resolve( onHandlers[BusEventType.WORKFLOW_START]( {
+        eventId: 'evt-start-1', id: '2', runId: 'run-2', name: 'myWorkflow'
+      } ) );
+      expect( handler ).toHaveBeenCalledWith( {
+        eventId: 'evt-start-1', id: '2', runId: 'run-2', name: 'myWorkflow'
+      } );
     } );
   } );
 
   describe( 'onWorkflowEnd', () => {
-    it( 'skips catalog workflow name', async () => {
+    it( 'skips catalog workflow and forwards eventId for real workflows', async () => {
       const handler = vi.fn().mockResolvedValue( undefined );
       onWorkflowEnd( handler );
 
       await Promise.resolve( onHandlers[BusEventType.WORKFLOW_END]( {
-        id: '1',
-        name: WORKFLOW_CATALOG,
-        duration: 10
+        eventId: 'evt-ignored', 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 } );
+      await Promise.resolve( onHandlers[BusEventType.WORKFLOW_END]( {
+        eventId: 'evt-end-1', id: '2', runId: 'run-2', name: 'myWorkflow', duration: 5
+      } ) );
+      expect( handler ).toHaveBeenCalledWith( {
+        eventId: 'evt-end-1', id: '2', runId: 'run-2', name: 'myWorkflow', duration: 5
+      } );
     } );
   } );
 
   describe( 'onWorkflowError', () => {
-    it( 'skips catalog workflow name', async () => {
+    it( 'skips catalog workflow and forwards eventId for real workflows', 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
+        eventId: 'evt-ignored', 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
+        eventId: 'evt-err-1', id: '2', runId: 'run-2', name: 'myWorkflow', duration: 2, error: err
       } ) );
-      expect( handler ).toHaveBeenCalledWith( { id: '2', name: 'myWorkflow', duration: 2, error: err } );
+      expect( handler ).toHaveBeenCalledWith( {
+        eventId: 'evt-err-1', id: '2', runId: 'run-2', name: 'myWorkflow', duration: 2, error: err
+      } );
     } );
   } );
 

package/src/tracing/trace_engine.js

@@ -4,7 +4,7 @@ import { serializeError } from './tools/utils.js';
 import { isStringboolTrue } from '#utils';
 import * as localProcessor from './processors/local/index.js';
 import * as s3Processor from './processors/s3/index.js';
-import { ComponentType, Signal } from '#consts';
+import { ComponentType } from '#consts';
 import { createChildLogger } from '#logger';
 import { EventAction } from './trace_consts.js';
 import { BaseAttribute } from './trace_attribute.js';
@@ -93,14 +93,14 @@ export const addEventAction = ( action, { kind, name, id, parentId, details, exe
 export function addEventActionWithContext( action, options ) {
   const storeContent = Storage.load();
   if ( storeContent ) { // If there is no storageContext this was not called from a Temporal environment
-    const { parentId, parentName, executionContext, workflowHandle } = storeContent;
+    const { parentId, executionContext, sendAttributeSignal } = storeContent;
     if ( action === EventAction.ADD_ATTR ) {
       const attribute = options.details;
       if ( !( attribute instanceof BaseAttribute ) ) {
-        throw new Error( `${EventAction.ADD_ATTR} called argument that is not a BaseAttribute instance` );
+        throw new Error( `Event ${EventAction.ADD_ATTR} argument is not a BaseAttribute instance` );
+      } else {
+        sendAttributeSignal( options.details );
       }
-      attribute.setActivity( parentId, parentName );
-      workflowHandle.signal( Signal.ADD_ATTRIBUTE, attribute );
     }
     addEventAction( action, { ...options, parentId, executionContext } );
   }

package/src/tracing/trace_engine.spec.js

@@ -5,6 +5,12 @@ vi.mock( '#async_storage', () => ( {
   Storage: { load: storageLoadMock }
 } ) );
 
+const logWarnMock = vi.fn();
+const logErrorMock = vi.fn();
+vi.mock( '#logger', () => ( {
+  createChildLogger: () => ( { warn: logWarnMock, error: logErrorMock } )
+} ) );
+
 const localInitMock = vi.fn( async () => {} );
 const localExecMock = vi.fn();
 const localGetDestinationMock = vi.fn( () => '/local/path.json' );
@@ -117,6 +123,62 @@ describe( 'tracing/trace_engine', () => {
     expect( payload.entry.action ).toBe( 'tick' );
   } );
 
+  it( 'addEventActionWithContext() sends ADD_ATTR attributes through storage context', async () => {
+    process.env.OUTPUT_TRACE_LOCAL_ON = 'true';
+    const sendAttributeSignalMock = vi.fn();
+    const executionContext = { runId: 'r1', disableTrace: false };
+    storageLoadMock.mockReturnValue( {
+      parentId: 'ctx-p',
+      executionContext,
+      sendAttributeSignal: sendAttributeSignalMock
+    } );
+    const { init, addEventActionWithContext } = await loadTraceEngine();
+    const { EventAction } = await import( './trace_consts.js' );
+    const { Attribute } = await import( './trace_attribute.js' );
+    await init();
+
+    const attribute = new Attribute.HTTPRequestCount( 'https://example.test', 'req-1' );
+    addEventActionWithContext( EventAction.ADD_ATTR, { kind: 'http', name: 'request', id: 'req-1', details: attribute } );
+
+    expect( sendAttributeSignalMock ).toHaveBeenCalledTimes( 1 );
+    expect( sendAttributeSignalMock ).toHaveBeenCalledWith( attribute );
+    expect( localExecMock ).toHaveBeenCalledTimes( 1 );
+    expect( localExecMock.mock.calls[0][0] ).toEqual( {
+      executionContext,
+      entry: {
+        kind: 'http',
+        action: EventAction.ADD_ATTR,
+        name: 'request',
+        id: 'req-1',
+        parentId: 'ctx-p',
+        timestamp: expect.any( Number ),
+        details: attribute
+      }
+    } );
+  } );
+
+  it( 'addEventActionWithContext() throws on invalid ADD_ATTR signal payloads', async () => {
+    process.env.OUTPUT_TRACE_LOCAL_ON = 'true';
+    const sendAttributeSignalMock = vi.fn();
+    storageLoadMock.mockReturnValue( {
+      parentId: 'ctx-p',
+      executionContext: { runId: 'r1', disableTrace: false },
+      sendAttributeSignal: sendAttributeSignalMock
+    } );
+    const { init, addEventActionWithContext } = await loadTraceEngine();
+    const { EventAction } = await import( './trace_consts.js' );
+    await init();
+
+    const invalidAttribute = { type: 'not-a-base-attribute' };
+    expect( () => addEventActionWithContext(
+      EventAction.ADD_ATTR,
+      { kind: 'http', name: 'request', id: 'req-1', details: invalidAttribute }
+    ) ).toThrow( /not a BaseAttribute instance/ );
+
+    expect( sendAttributeSignalMock ).not.toHaveBeenCalled();
+    expect( localExecMock ).not.toHaveBeenCalled();
+  } );
+
   it( 'addEventActionWithContext() does not emit when storage executionContext.disableTrace is true', async () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = '1';
     storageLoadMock.mockReturnValue( {

package/src/utils/index.d.ts

@@ -132,3 +132,16 @@ export function deepMerge( a: object, b: object ): object;
  * @returns Short string using A–Z, a–z, 0–9, `_`, `-` (typically 21–22 chars).
  */
 export function toUrlSafeBase64( uuid: string ): string;
+
+/**
+ * Similar to native Promise.allSettled, but rejects with `{ isTimeout: true }`
+ * if the execution exceeds the given timeout.
+ *
+ * @param promises - Values or promises to wait for.
+ * @param timeoutMs - Maximum wait time in milliseconds.
+ * @returns Native Promise.allSettled-style results.
+ */
+export function allSettledWithTimeout<T>(
+  promises: Array<T | PromiseLike<T>>,
+  timeoutMs: number
+): Promise<PromiseSettledResult<Awaited<T>>[]>;

package/src/utils/utils.js

@@ -209,3 +209,42 @@ export const toUrlSafeBase64 = uuid => {
   const toDigits = n => n <= 0n ? [] : toDigits( n / base ).concat( alphabet[Number( n % base )] );
   return toDigits( BigInt( '0x' + hex ) ).join( '' );
 };
+
+/**
+ * Similar to native Promise.allSettled but throws an Error if the execution exceeds a given time.
+ *
+ * The error thrown will have attribute `.isTimeout` as `true`.
+ *
+ * @template T
+ * @param {Array<T | PromiseLike<T>>} promises
+ * @param {number} timeoutMs
+ * @returns {Promise<PromiseSettledResult<Awaited<T>>[]>}
+ * @throws {Error & { isTimeout: true }}
+ */
+export const allSettledWithTimeout = ( () => {
+  class TimeoutError extends Error {
+    isTimeout = true;
+    constructor() {
+      super( 'Timed out before completing all promises' );
+    }
+  }
+
+  return async ( promises, timeoutMs ) => {
+    if ( promises.length === 0 ) {
+      return [];
+    }
+
+    const state = { timeoutMonitor: null };
+
+    try {
+      return await Promise.race( [
+        Promise.allSettled( promises ),
+        new Promise( ( _, reject ) => {
+          state.timeoutMonitor = setTimeout( () => reject( new TimeoutError() ), timeoutMs );
+        } )
+      ] );
+    } finally {
+      clearTimeout( state.timeoutMonitor );
+    }
+  };
+} )();

package/src/utils/utils.spec.js

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import { Readable } from 'node:stream';
 import {
   clone,
@@ -6,7 +6,8 @@ import {
   serializeFetchResponse,
   deepMerge,
   isPlainObject,
-  toUrlSafeBase64
+  toUrlSafeBase64,
+  allSettledWithTimeout
 } from './utils.js';
 
 describe( 'clone', () => {
@@ -22,6 +23,44 @@ describe( 'clone', () => {
   } );
 } );
 
+describe( 'allSettledWithTimeout', () => {
+  it( 'returns an empty array when no promises are provided', async () => {
+    await expect( allSettledWithTimeout( [], 100 ) ).resolves.toEqual( [] );
+  } );
+
+  it( 'returns native allSettled results when all promises settle before timeout', async () => {
+    const error = new Error( 'boom' );
+    const result = await allSettledWithTimeout( [
+      Promise.resolve( 'ok' ),
+      Promise.reject( error ),
+      42
+    ], 100 );
+
+    expect( result ).toEqual( [
+      { status: 'fulfilled', value: 'ok' },
+      { status: 'rejected', reason: error },
+      { status: 'fulfilled', value: 42 }
+    ] );
+  } );
+
+  it( 'rejects with a timeout-shaped error when promises do not settle in time', async () => {
+    vi.useFakeTimers();
+    try {
+      const pending = new Promise( () => {} );
+      const result = allSettledWithTimeout( [ pending ], 1000 );
+      const assertion = expect( result ).rejects.toMatchObject( {
+        isTimeout: true,
+        message: 'Timed out before completing all promises'
+      } );
+
+      await vi.advanceTimersByTimeAsync( 1000 );
+      await assertion;
+    } finally {
+      vi.useRealTimers();
+    }
+  } );
+} );
+
 describe( 'serializeFetchResponse', () => {
   it( 'serializes JSON response body and flattens headers', async () => {
     const payload = { a: 1, b: 'two' };

package/src/worker/interceptors/activity.js

@@ -2,10 +2,16 @@ import { Context } from '@temporalio/activity';
 import { Storage } from '#async_storage';
 import * as Tracing from '#tracing';
 import { headersToObject } from '../sandboxed_utils.js';
-import { BusEventType, METADATA_ACCESS_SYMBOL } from '#consts';
+import { BusEventType, METADATA_ACCESS_SYMBOL, Signal } from '#consts';
 import { activityHeartbeatEnabled, activityHeartbeatIntervalMs, namespace } from '../configs.js';
 import { messageBus } from '#bus';
 import { Client } from '@temporalio/client';
+import { createChildLogger } from '#logger';
+import { allSettledWithTimeout } from '#utils';
+
+const log = createChildLogger( 'ActivityInterceptor' );
+
+const IN_FLIGHT_SIGNALS_TIMEOUT_MS = 30_000;
 
 /*
   This interceptor wraps every activity execution with cross-cutting concerns:
@@ -36,6 +42,20 @@ export class ActivityExecutionInterceptor {
     this.connection = connection;
   };
 
+  /**
+   * Returns a workflow entry by its name or throws error
+   * @param {string} workflowName
+   * @returns {object} Workflow entry
+   * @throws {Error}
+   */
+  getWorkflowEntry( workflowName ) {
+    const workflowEntry = this.workflowsMap.get( workflowName );
+    if ( !workflowEntry ) {
+      throw new Error( `Activity interceptor: workflow "${workflowName}" not found in workflowsMap.` );
+    }
+    return workflowEntry;
+  }
+
   async execute( input, next ) {
     const startDate = Date.now();
     const client = new Client( { connection: this.connection, namespace } );
@@ -43,31 +63,66 @@ export class ActivityExecutionInterceptor {
     const { workflowExecution: { workflowId }, activityId: id, activityType: name, workflowType: workflowName } = Context.current().info;
     const { executionContext } = headersToObject( input.headers );
     const { type: kind } = this.activities?.[name]?.[METADATA_ACCESS_SYMBOL];
+    const { path: workflowFilename } = this.getWorkflowEntry( workflowName );
 
     const workflowHandle = client.workflow.getHandle( workflowId );
 
+    const state = {
+      heartbeat: null,
+      activityOutput: undefined,
+      signals: []
+    };
+
+    const errorContext = {
+      workflowId,
+      workflowName,
+      activityId: id,
+      activityName: name
+    };
+
+    const sendAttributeSignal = attribute => {
+      attribute.setActivity( id, name );
+      state.signals.push(
+        workflowHandle
+          .signal( Signal.ADD_ATTRIBUTE, attribute )
+          .catch( e =>
+            log.warn( `Signal "${Signal.ADD_ATTRIBUTE}" failed`, { message: e.message, stack: e.stack, activityId: id, ...errorContext } )
+          )
+      );
+    };
+
+    const flushSignals = async signals => {
+      try {
+        await allSettledWithTimeout( signals, IN_FLIGHT_SIGNALS_TIMEOUT_MS );
+      } catch ( error ) {
+        if ( error.isTimeout ) {
+          log.warn( 'Some usage/cost attributes were missed because not all activity signals were sent to the workflow', errorContext );
+        } else {
+          throw error;
+        }
+      }
+    };
+
+    // Wraps the execution with accessible metadata for the activity
+    const ctx = { parentId: id, executionContext, workflowFilename, sendAttributeSignal };
+
     messageBus.emit( BusEventType.ACTIVITY_START, { id, name, kind, workflowId, workflowName } );
     Tracing.addEventStart( { id, name, kind, parentId: workflowId, details: input.args[0], executionContext } );
 
-    const workflowEntry = this.workflowsMap.get( workflowName );
-    if ( !workflowEntry ) {
-      const availableWorkflows = [ ...this.workflowsMap.keys() ].join( ', ' );
-      throw new Error( `Activity interceptor: workflow "${workflowName}" not found in workflowsMap. Available: [${availableWorkflows}]` );
-    }
-    const workflowFilename = workflowEntry.path;
-
-    const intervals = { heartbeat: null };
     try {
       // Sends heartbeat to communicate that activity is still alive
-      intervals.heartbeat = activityHeartbeatEnabled && setInterval( () => Context.current().heartbeat(), activityHeartbeatIntervalMs );
+      state.heartbeat = activityHeartbeatEnabled && setInterval( () => Context.current().heartbeat(), activityHeartbeatIntervalMs );
 
-      // Wraps the execution with accessible metadata for the activity
-      const ctx = { parentId: id, parentName: name, executionContext, workflowFilename, workflowHandle };
-      const output = await Storage.runWithContext( async _ => next( input ), ctx );
+      try {
+        state.activityOutput = await Storage.runWithContext( async _ => next( input ), ctx );
+      } finally {
+        // Ensure in-flight signals are delivered (up to a reasonable time) before handling errors
+        await flushSignals( state.signals );
+      }
 
       messageBus.emit( BusEventType.ACTIVITY_END, { id, name, kind, workflowId, workflowName, duration: Date.now() - startDate } );
-      Tracing.addEventEnd( { id, details: output, executionContext } );
-      return output;
+      Tracing.addEventEnd( { id, details: state.activityOutput, executionContext } );
+      return state.activityOutput;
 
     } catch ( error ) {
       messageBus.emit( BusEventType.ACTIVITY_ERROR, { id, name, kind, workflowId, workflowName, duration: Date.now() - startDate, error } );
@@ -75,7 +130,7 @@ export class ActivityExecutionInterceptor {
 
       throw error;
     } finally {
-      clearInterval( intervals.heartbeat );
+      clearInterval( state.heartbeat );
     }
   }
 };

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

@@ -1,10 +1,12 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { BusEventType } from '#consts';
+import { BusEventType, Signal } from '#consts';
 
 const METADATA_ACCESS_SYMBOL = vi.hoisted( () => Symbol( '__metadata' ) );
 const workflowHandleMock = vi.hoisted( () => ( { signal: vi.fn() } ) );
 const getHandleMock = vi.hoisted( () => vi.fn( () => workflowHandleMock ) );
 const clientConstructorMock = vi.hoisted( () => vi.fn() );
+const allSettledWithTimeoutMock = vi.hoisted( () => vi.fn().mockResolvedValue( [] ) );
+const logWarnMock = vi.hoisted( () => vi.fn() );
 
 const heartbeatMock = vi.fn();
 const runWithContextMock = vi.hoisted( () => vi.fn().mockImplementation( async fn => fn() ) );
@@ -42,6 +44,15 @@ vi.mock( '#async_storage', () => ( {
   }
 } ) );
 
+vi.mock( '#utils', async importOriginal => {
+  const actual = await importOriginal();
+  return { ...actual, allSettledWithTimeout: allSettledWithTimeoutMock };
+} );
+
+vi.mock( '#logger', () => ( {
+  createChildLogger: () => ( { warn: logWarnMock } )
+} ) );
+
 const addEventStartMock = vi.fn();
 const addEventEndMock = vi.fn();
 const addEventErrorMock = vi.fn();
@@ -93,6 +104,8 @@ const makeInput = () => ( {
 describe( 'ActivityExecutionInterceptor', () => {
   beforeEach( () => {
     vi.clearAllMocks();
+    allSettledWithTimeoutMock.mockResolvedValue( [] );
+    workflowHandleMock.signal.mockResolvedValue( undefined );
     vi.useFakeTimers();
     vi.resetModules();
     // Default: heartbeat enabled with 50ms interval for fast tests
@@ -129,15 +142,83 @@ describe( 'ActivityExecutionInterceptor', () => {
       expect.any( Function ),
       expect.objectContaining( {
         parentId: 'act-1',
-        parentName: 'myWorkflow#myStep',
         executionContext: { workflowId: 'wf-1' },
         workflowFilename: '/workflows/myWorkflow.js',
-        workflowHandle: workflowHandleMock
+        sendAttributeSignal: expect.any( Function )
       } )
     );
     expect( getHandleMock ).toHaveBeenCalledWith( 'wf-1' );
   } );
 
+  it( 'handles next returning a non-Promise value', async () => {
+    const { ActivityExecutionInterceptor } = await import( './activity.js' );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
+    const next = vi.fn( () => ( { result: 'sync' } ) );
+
+    await expect( interceptor.execute( makeInput(), next ) ).resolves.toEqual( { result: 'sync' } );
+
+    expect( allSettledWithTimeoutMock ).toHaveBeenCalledWith( [], 30_000 );
+    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, expect.any( Object ) );
+    expect( addEventEndMock ).toHaveBeenCalledWith( { id: 'act-1', details: { result: 'sync' }, executionContext: { workflowId: 'wf-1' } } );
+    expect( addEventErrorMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'handles signal flush timeout after successful execution', async () => {
+    const timeoutError = Object.assign( new Error( 'timeout' ), { isTimeout: true } );
+    allSettledWithTimeoutMock.mockRejectedValueOnce( timeoutError );
+    const { ActivityExecutionInterceptor } = await import( './activity.js' );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
+    const next = vi.fn().mockResolvedValue( { result: 'ok' } );
+
+    await expect( interceptor.execute( makeInput(), next ) ).resolves.toEqual( { result: 'ok' } );
+
+    expect( allSettledWithTimeoutMock ).toHaveBeenCalledWith( [], 30_000 );
+    expect( logWarnMock ).toHaveBeenCalledWith(
+      'Some usage/cost attributes were missed because not all activity signals were sent to the workflow',
+      { workflowId: 'wf-1', workflowName: 'myWorkflow', activityId: 'act-1', activityName: 'myWorkflow#myStep' }
+    );
+    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, expect.any( Object ) );
+    expect( addEventEndMock ).toHaveBeenCalledOnce();
+    expect( addEventErrorMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'handles signal flush timeout after failed execution', async () => {
+    const timeoutError = Object.assign( new Error( 'timeout' ), { isTimeout: true } );
+    allSettledWithTimeoutMock.mockRejectedValueOnce( timeoutError );
+    const { ActivityExecutionInterceptor } = await import( './activity.js' );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
+    const error = new Error( 'step failed' );
+    const next = vi.fn().mockRejectedValue( error );
+
+    await expect( interceptor.execute( makeInput(), next ) ).rejects.toThrow( 'step failed' );
+
+    expect( allSettledWithTimeoutMock ).toHaveBeenCalledWith( [], 30_000 );
+    expect( logWarnMock ).toHaveBeenCalledWith(
+      'Some usage/cost attributes were missed because not all activity signals were sent to the workflow',
+      { workflowId: 'wf-1', workflowName: 'myWorkflow', activityId: 'act-1', activityName: 'myWorkflow#myStep' }
+    );
+    expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, expect.objectContaining( { error } ) );
+    expect( addEventErrorMock ).toHaveBeenCalledOnce();
+    expect( addEventEndMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'exposes sendAttributeSignal in activity context', async () => {
+    const attribute = { setActivity: vi.fn() };
+    runWithContextMock.mockImplementationOnce( async ( fn, ctx ) => {
+      ctx.sendAttributeSignal( attribute );
+      return fn();
+    } );
+    const { ActivityExecutionInterceptor } = await import( './activity.js' );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
+    const next = vi.fn().mockResolvedValue( { result: 'ok' } );
+
+    await expect( interceptor.execute( makeInput(), next ) ).resolves.toEqual( { result: 'ok' } );
+
+    expect( attribute.setActivity ).toHaveBeenCalledWith( 'act-1', 'myWorkflow#myStep' );
+    expect( workflowHandleMock.signal ).toHaveBeenCalledWith( Signal.ADD_ATTRIBUTE, attribute );
+    expect( allSettledWithTimeoutMock ).toHaveBeenCalledWith( [ expect.any( Promise ) ], 30_000 );
+  } );
+
   it( 'records trace error event on failed execution', async () => {
     const { ActivityExecutionInterceptor } = await import( './activity.js' );
     const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );