@outputai/core 0.5.3-next.0eeffec.0 → 0.5.3-next.bdf47aa.0

package/src/utils/utils.spec.js

@@ -5,6 +5,7 @@ import {
   serializeBodyAndInferContentType,
   serializeFetchResponse,
   deepMerge,
+  deepMergeWithResolver,
   isPlainObject,
   toUrlSafeBase64,
   allSettledWithTimeout
@@ -21,6 +22,86 @@ describe( 'clone', () => {
     expect( copied.nested.b ).toBe( 3 );
     expect( copied ).not.toBe( original );
   } );
+
+  it( 'deep copies JSON-compatible arrays and objects', () => {
+    const original = {
+      arr: [ 1, { nested: true } ],
+      str: 'value',
+      bool: false,
+      nil: null
+    };
+    const copied = clone( original );
+
+    copied.arr[1].nested = false;
+
+    expect( copied ).toEqual( {
+      arr: [ 1, { nested: false } ],
+      str: 'value',
+      bool: false,
+      nil: null
+    } );
+    expect( original.arr[1].nested ).toBe( true );
+    expect( copied ).not.toBe( original );
+    expect( copied.arr ).not.toBe( original.arr );
+  } );
+
+  it( 'returns primitive JSON values when they can be parsed', () => {
+    expect( clone( null ) ).toBeNull();
+    expect( clone( true ) ).toBe( true );
+    expect( clone( false ) ).toBe( false );
+    expect( clone( 123 ) ).toBe( 123 );
+    expect( clone( 'hello' ) ).toBe( 'hello' );
+  } );
+
+  it( 'returns original values when JSON serialization produces no parseable payload', () => {
+    const sym = Symbol( 'x' );
+    const fn = () => {};
+    class Foo {}
+
+    expect( clone( undefined ) ).toBeUndefined();
+    expect( clone( sym ) ).toBe( sym );
+    expect( clone( fn ) ).toBe( fn );
+    expect( clone( Foo ) ).toBe( Foo );
+    expect( clone( Date ) ).toBe( Date );
+    expect( clone( Object ) ).toBe( Object );
+    expect( clone( Number ) ).toBe( Number );
+  } );
+
+  it( 'returns original values when JSON serialization throws', () => {
+    const circular = { name: 'circular' };
+    circular.self = circular;
+    const bigint = 1n;
+
+    expect( clone( circular ) ).toBe( circular );
+    expect( clone( bigint ) ).toBe( bigint );
+  } );
+
+  it( 'keeps JSON.stringify semantics for special numeric values', () => {
+    expect( clone( NaN ) ).toBeNull();
+    expect( clone( Infinity ) ).toBeNull();
+    expect( clone( -Infinity ) ).toBeNull();
+  } );
+
+  it( 'keeps JSON.stringify semantics for non-plain object instances', () => {
+    const date = new Date( '2025-01-01T00:00:00.000Z' );
+
+    expect( clone( date ) ).toBe( '2025-01-01T00:00:00.000Z' );
+    expect( clone( /abc/ ) ).toEqual( {} );
+    expect( clone( new Map( [ [ 'a', 1 ] ] ) ) ).toEqual( {} );
+    expect( clone( new Set( [ 1, 2 ] ) ) ).toEqual( {} );
+  } );
+
+  it( 'drops object properties that JSON.stringify omits', () => {
+    const sym = Symbol( 'x' );
+    const original = {
+      kept: 'yes',
+      missing: undefined,
+      fn: () => {},
+      sym
+    };
+
+    expect( clone( original ) ).toEqual( { kept: 'yes' } );
+  } );
 } );
 
 describe( 'allSettledWithTimeout', () => {
@@ -353,6 +434,57 @@ describe( 'deepMerge', () => {
   } );
 } );
 
+describe( 'deepMergeWithResolver', () => {
+  it( 'uses resolver for existing leaf values, including nested leaves', () => {
+    const a = {
+      cost: { total: 1 },
+      tokens: { total: 2, input: 3 }
+    };
+    const b = {
+      cost: { total: 4 },
+      tokens: { total: 5, input: 6, output: 7 }
+    };
+
+    expect( deepMergeWithResolver( a, b, ( x, y ) => x + y ) ).toEqual( {
+      cost: { total: 5 },
+      tokens: { total: 7, input: 9, output: 7 }
+    } );
+  } );
+
+  it( 'copies values from "b" when they do not exist in "a"', () => {
+    const resolver = vi.fn( ( x, y ) => x + y );
+
+    expect( deepMergeWithResolver( { a: 1 }, { b: 2, nested: { c: 3 } }, resolver ) ).toEqual( {
+      a: 1,
+      b: 2,
+      nested: { c: 3 }
+    } );
+    expect( resolver ).not.toHaveBeenCalled();
+  } );
+
+  it( 'keeps extra values from "a" when absent from "b"', () => {
+    expect( deepMergeWithResolver( { a: 1, nested: { kept: 2 } }, { b: 3 }, ( x, y ) => x + y ) ).toEqual( {
+      a: 1,
+      nested: { kept: 2 },
+      b: 3
+    } );
+  } );
+
+  it( 'returns a clone of "a" when "b" is not an object', () => {
+    const a = { nested: { value: 1 } };
+    const result = deepMergeWithResolver( a, null, ( x, y ) => x + y );
+
+    a.nested.value = 2;
+    expect( result ).toEqual( { nested: { value: 1 } } );
+  } );
+
+  it( 'throws when first argument is not a plain object', () => {
+    expect( () => deepMergeWithResolver( null, {}, ( x, y ) => x + y ) ).toThrow( Error );
+    expect( () => deepMergeWithResolver( [], {}, ( x, y ) => x + y ) ).toThrow( Error );
+    expect( () => deepMergeWithResolver( 'a', {}, ( x, y ) => x + y ) ).toThrow( Error );
+  } );
+} );
+
 describe( 'isPlainObject', () => {
   it( 'Detects plain objects', () => {
     expect( isPlainObject( {} ) ).toBe( true );

package/src/worker/catalog_workflow/workflow.js

@@ -7,12 +7,15 @@ import { defineQuery, setHandler, condition, defineUpdate } from '@temporalio/wo
  *
  * @param {object} catalog - The catalog information
  */
-export default async function catalogWorkflow( catalog ) {
+export default async function catalogWorkflow( catalog, catalogHash ) {
   const state = { canEnd: false };
 
   // Returns the catalog
   setHandler( defineQuery( 'get' ), () => catalog );
 
+  // Returns the catalog hash
+  setHandler( defineQuery( 'get_hash' ), () => catalogHash );
+
   // Politely respond to a ping
   setHandler( defineQuery( 'ping' ), () => 'pong' );
 

package/src/worker/configs.js

@@ -25,11 +25,6 @@ const envVarSchema = z.object( {
   OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 2 * 60 * 1000 ) ), // 2min
   // Whether to send activity heartbeats (enabled by default)
   OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: z.transform( v => v === undefined ? true : isStringboolTrue( v ) ),
-  // When true, activities fire Temporal signals carrying attribute/event data (LLM usage,
-  // HTTP request count/cost) back to the workflow for aggregation in the result.
-  // Defaulted OFF: the current emission architecture bloats Temporal history.
-  // Set to "true" to opt in to per-event attribute collection and aggregations.
-  OUTPUT_ENABLE_ATTRIBUTE_SIGNAL_EMISSION: z.transform( v => v === undefined ? false : isStringboolTrue( v ) ),
   // Time to allow for hooks to flush before shutdown
   OUTPUT_PROCESS_FAILURE_SHUTDOWN_DELAY: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 3000 ) ),
   // HTTP CONNECT proxy for Temporal gRPC connections (e.g. "proxy-host:8080").
@@ -58,6 +53,5 @@ export const taskQueue = envVars.OUTPUT_CATALOG_ID;
 export const catalogId = envVars.OUTPUT_CATALOG_ID;
 export const activityHeartbeatIntervalMs = envVars.OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS;
 export const activityHeartbeatEnabled = envVars.OUTPUT_ACTIVITY_HEARTBEAT_ENABLED;
-export const enableAttributeSignalEmission = envVars.OUTPUT_ENABLE_ATTRIBUTE_SIGNAL_EMISSION;
 export const processFailureShutdownDelay = envVars.OUTPUT_PROCESS_FAILURE_SHUTDOWN_DELAY;
 export const grpcProxy = envVars.TEMPORAL_GRPC_PROXY;

package/src/worker/configs.spec.js

@@ -11,8 +11,7 @@ const CONFIG_KEYS = [
   'TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_POLLS',
   'TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASK_POLLS',
   'OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS',
-  'OUTPUT_ACTIVITY_HEARTBEAT_ENABLED',
-  'OUTPUT_ENABLE_ATTRIBUTE_SIGNAL_EMISSION'
+  'OUTPUT_ACTIVITY_HEARTBEAT_ENABLED'
 ];
 
 const setEnv = ( overrides = {} ) => {
@@ -64,7 +63,6 @@ describe( 'worker/configs', () => {
     expect( configs.maxConcurrentWorkflowTaskPolls ).toBe( 5 );
     expect( configs.activityHeartbeatIntervalMs ).toBe( 2 * 60 * 1000 );
     expect( configs.activityHeartbeatEnabled ).toBe( true );
-    expect( configs.enableAttributeSignalEmission ).toBe( false );
     expect( configs.taskQueue ).toBe( 'test-catalog' );
     expect( configs.catalogId ).toBe( 'test-catalog' );
   } );
@@ -122,30 +120,6 @@ describe( 'worker/configs', () => {
     expect( configsDefault.activityHeartbeatEnabled ).toBe( true );
   } );
 
-  it( 'OUTPUT_ENABLE_ATTRIBUTE_SIGNAL_EMISSION: "true"|"1"|"on" → true', async () => {
-    for ( const val of [ 'true', '1', 'on' ] ) {
-      setEnv( { OUTPUT_ENABLE_ATTRIBUTE_SIGNAL_EMISSION: val } );
-      const configs = await loadConfigs();
-      expect( configs.enableAttributeSignalEmission ).toBe( true );
-      clearEnv();
-    }
-  } );
-
-  it( 'OUTPUT_ENABLE_ATTRIBUTE_SIGNAL_EMISSION: "false"|other → false, undefined → false (default off)', async () => {
-    setEnv( { OUTPUT_ENABLE_ATTRIBUTE_SIGNAL_EMISSION: 'false' } );
-    const configsFalse = await loadConfigs();
-    expect( configsFalse.enableAttributeSignalEmission ).toBe( false );
-
-    setEnv( { OUTPUT_ENABLE_ATTRIBUTE_SIGNAL_EMISSION: '0' } );
-    const configsZero = await loadConfigs();
-    expect( configsZero.enableAttributeSignalEmission ).toBe( false );
-
-    clearEnv();
-    setEnv(); // only OUTPUT_CATALOG_ID; OUTPUT_ENABLE_ATTRIBUTE_SIGNAL_EMISSION absent → default false
-    const configsDefault = await loadConfigs();
-    expect( configsDefault.enableAttributeSignalEmission ).toBe( false );
-  } );
-
   it( 'parses TEMPORAL_ADDRESS and TEMPORAL_NAMESPACE', async () => {
     setEnv( { TEMPORAL_ADDRESS: 'temporal:7233', TEMPORAL_NAMESPACE: 'my-ns' } );
     const configs = await loadConfigs();

package/src/worker/index.js

@@ -13,6 +13,7 @@ import { bootstrapFetchProxy } from './proxy.js';
 import { messageBus } from '#bus';
 import './log_hooks.js';
 import { BusEventType } from '#consts';
+import { hashSourceCode } from './loader_tools.js';
 
 const log = createChildLogger( 'Worker' );
 
@@ -54,6 +55,9 @@ const callerDir = process.argv[2];
   log.info( 'Creating workflows catalog...' );
   const catalog = createCatalog( { workflows, activities } );
 
+  log.info( 'Computing catalog source code hash...' );
+  const catalogHash = await hashSourceCode( callerDir );
+
   log.info( 'Connecting Temporal...' );
   const proxy = grpcProxy ? { type: 'http-connect', targetHost: grpcProxy } : undefined;
   if ( proxy ) {
@@ -81,7 +85,7 @@ const callerDir = process.argv[2];
   registerShutdown( { worker, log } );
 
   log.info( 'Running worker...' );
-  await Promise.all( [ worker.run(), startCatalog( { connection, namespace, catalog } ) ] );
+  await Promise.all( [ worker.run(), startCatalog( { connection, namespace, catalog, catalogHash } ) ] );
 
   log.info( 'Closing connection...' );
   await connection.close();

package/src/worker/index.spec.js

@@ -40,6 +40,9 @@ vi.mock( './loader.js', () => ( {
   createWorkflowsEntryPoint: createWorkflowsEntryPointMock
 } ) );
 
+const hashSourceCodeMock = vi.fn().mockResolvedValue( 'catalog-hash' );
+vi.mock( './loader_tools.js', () => ( { hashSourceCode: hashSourceCodeMock } ) );
+
 vi.mock( './sinks.js', () => ( { sinks: {} } ) );
 
 const createCatalogMock = vi.fn().mockReturnValue( { workflows: [], activities: {} } );
@@ -105,6 +108,7 @@ describe( 'worker/index', () => {
     expect( createWorkflowsEntryPointMock ).toHaveBeenCalledWith( [] );
     expect( initTracing ).toHaveBeenCalled();
     expect( createCatalogMock ).toHaveBeenCalledWith( { workflows: [], activities: {} } );
+    expect( hashSourceCodeMock ).toHaveBeenCalledWith( '/test/caller/dir' );
     expect( bootstrapFetchProxyMock ).toHaveBeenCalled();
     expect( NativeConnection.connect ).toHaveBeenCalledWith( {
       address: configValues.address,
@@ -128,7 +132,8 @@ describe( 'worker/index', () => {
     expect( startCatalogMock ).toHaveBeenCalledWith( {
       connection: mockConnection,
       namespace: configValues.namespace,
-      catalog: { workflows: [], activities: {} }
+      catalog: { workflows: [], activities: {} },
+      catalogHash: 'catalog-hash'
     } );
 
     runState.resolve();

package/src/worker/interceptors/activity.js

@@ -2,17 +2,15 @@ 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, Signal } from '#consts';
-import { activityHeartbeatEnabled, activityHeartbeatIntervalMs, enableAttributeSignalEmission, namespace } from '../configs.js';
+import { ACTIVITY_WRAPPER_VERSION_FIELD, 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';
+import { aggregateAttributes } from '#internal_utils/aggregations';
 
 const log = createChildLogger( 'ActivityInterceptor' );
 
-const IN_FLIGHT_SIGNALS_TIMEOUT_MS = 30_000;
-
 /*
   This interceptor wraps every activity execution with cross-cutting concerns:
 
@@ -58,56 +56,40 @@ export class ActivityExecutionInterceptor {
 
   async execute( input, next ) {
     const startDate = Date.now();
-    const client = new Client( { connection: this.connection, namespace } );
 
     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: []
+      attributes: []
     };
 
-    const errorContext = {
-      workflowId,
-      workflowName,
-      activityId: id,
-      activityName: name
-    };
-
-    const sendAttributeSignal = attribute => {
-      if ( !enableAttributeSignalEmission ) {
-        return;
-      }
-      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;
+    const addAttribute = attribute => state.attributes.push( attribute );
+
+    const sendAggregationsViaSignal = async () => {
+      if ( state.attributes.length > 0 ) {
+        try {
+          const client = new Client( { connection: this.connection, namespace } );
+          const workflowHandle = client.workflow.getHandle( workflowId );
+          await workflowHandle.signal( Signal.SEND_AGGREGATIONS, aggregateAttributes( state.attributes ) );
+        } catch ( error ) {
+          log.warn( `Signal "${Signal.SEND_AGGREGATIONS}" failed`, {
+            message: error.message,
+            stack: error.stack,
+            activityId: id,
+            activityName: name,
+            workflowId,
+            workflowName
+          } );
         }
       }
     };
 
     // Wraps the execution with accessible metadata for the activity
-    const ctx = { parentId: id, executionContext, workflowFilename, sendAttributeSignal };
+    const ctx = { parentId: id, executionContext, workflowFilename, addAttribute };
 
     messageBus.emit( BusEventType.ACTIVITY_START, { id, name, kind, workflowId, workflowName } );
     Tracing.addEventStart( { id, name, kind, parentId: workflowId, details: input.args[0], executionContext } );
@@ -116,21 +98,22 @@ export class ActivityExecutionInterceptor {
       // Sends heartbeat to communicate that activity is still alive
       state.heartbeat = activityHeartbeatEnabled && setInterval( () => Context.current().heartbeat(), activityHeartbeatIntervalMs );
 
-      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 );
-      }
+      const output = await Storage.runWithContext( async _ => next( input ), ctx );
 
       messageBus.emit( BusEventType.ACTIVITY_END, { id, name, kind, workflowId, workflowName, duration: Date.now() - startDate } );
-      Tracing.addEventEnd( { id, details: state.activityOutput, executionContext } );
-      return state.activityOutput;
+      Tracing.addEventEnd( { id, details: output, executionContext } );
+      return {
+        [ACTIVITY_WRAPPER_VERSION_FIELD]: 1,
+        output,
+        aggregations: state.attributes.length > 0 ? aggregateAttributes( state.attributes ) : null
+      };
 
     } catch ( error ) {
       messageBus.emit( BusEventType.ACTIVITY_ERROR, { id, name, kind, workflowId, workflowName, duration: Date.now() - startDate, error } );
       Tracing.addEventError( { id, details: error, executionContext } );
 
+      await sendAggregationsViaSignal();
+
       throw error;
     } finally {
       clearInterval( state.heartbeat );

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

@@ -1,11 +1,11 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { BusEventType, Signal } from '#consts';
+import { ACTIVITY_WRAPPER_VERSION_FIELD, BusEventType, Signal } from '#consts';
+import { Attribute } from '#trace_attribute';
 
 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();
@@ -44,11 +44,6 @@ vi.mock( '#async_storage', () => ( {
   }
 } ) );
 
-vi.mock( '#utils', async importOriginal => {
-  const actual = await importOriginal();
-  return { ...actual, allSettledWithTimeout: allSettledWithTimeoutMock };
-} );
-
 vi.mock( '#logger', () => ( {
   createChildLogger: () => ( { warn: logWarnMock } )
 } ) );
@@ -85,9 +80,6 @@ vi.mock( '../configs.js', () => ( {
   get activityHeartbeatIntervalMs() {
     return parseInt( process.env.OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS || '120000', 10 );
   },
-  get enableAttributeSignalEmission() {
-    return process.env.OUTPUT_ENABLE_ATTRIBUTE_SIGNAL_EMISSION === 'true';
-  },
   get namespace() {
     return process.env.TEMPORAL_NAMESPACE || 'default';
   }
@@ -104,18 +96,21 @@ const makeInput = () => ( {
   headers: {}
 } );
 
+const httpRequestAttribute = {
+  type: Attribute.HTTPRequestCount.TYPE,
+  url: 'https://api.example.test/items',
+  requestId: 'req-1'
+};
+
 describe( 'ActivityExecutionInterceptor', () => {
   beforeEach( () => {
     vi.clearAllMocks();
-    allSettledWithTimeoutMock.mockResolvedValue( [] );
     workflowHandleMock.signal.mockResolvedValue( undefined );
     vi.useFakeTimers();
     vi.resetModules();
     // Default: heartbeat enabled with 50ms interval for fast tests
     vi.stubEnv( 'OUTPUT_ACTIVITY_HEARTBEAT_ENABLED', 'true' );
     vi.stubEnv( 'OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS', '50' );
-    // Default: attribute signal emission enabled so existing tests can verify signal-sending behaviour
-    vi.stubEnv( 'OUTPUT_ENABLE_ATTRIBUTE_SIGNAL_EMISSION', 'true' );
   } );
 
   afterEach( () => {
@@ -132,7 +127,11 @@ describe( 'ActivityExecutionInterceptor', () => {
     vi.advanceTimersByTime( 0 );
     const output = await promise;
 
-    expect( output ).toEqual( { result: 'ok' } );
+    expect( output ).toEqual( {
+      output: { result: 'ok' },
+      aggregations: null,
+      [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
+    } );
     expect( messageBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_START, expect.objectContaining( {
       id: 'act-1', name: 'myWorkflow#myStep', kind: 'step', workflowId: 'wf-1', workflowName: 'myWorkflow'
     } ) );
@@ -142,17 +141,17 @@ describe( 'ActivityExecutionInterceptor', () => {
     expect( addEventStartMock ).toHaveBeenCalledOnce();
     expect( addEventEndMock ).toHaveBeenCalledOnce();
     expect( addEventErrorMock ).not.toHaveBeenCalled();
-    expect( clientConstructorMock ).toHaveBeenCalledWith( { connection: undefined, namespace: 'default' } );
+    expect( clientConstructorMock ).not.toHaveBeenCalled();
     expect( runWithContextMock ).toHaveBeenCalledWith(
       expect.any( Function ),
       expect.objectContaining( {
         parentId: 'act-1',
         executionContext: { workflowId: 'wf-1' },
         workflowFilename: '/workflows/myWorkflow.js',
-        sendAttributeSignal: expect.any( Function )
+        addAttribute: expect.any( Function )
       } )
     );
-    expect( getHandleMock ).toHaveBeenCalledWith( 'wf-1' );
+    expect( getHandleMock ).not.toHaveBeenCalled();
   } );
 
   it( 'handles next returning a non-Promise value', async () => {
@@ -160,36 +159,45 @@ describe( 'ActivityExecutionInterceptor', () => {
     const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
     const next = vi.fn( () => ( { result: 'sync' } ) );
 
-    await expect( interceptor.execute( makeInput(), next ) ).resolves.toEqual( { result: 'sync' } );
+    await expect( interceptor.execute( makeInput(), next ) ).resolves.toEqual( {
+      output: { result: 'sync' },
+      aggregations: null,
+      [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
+    } );
 
-    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 );
+  it( 'does not signal collected attributes after successful execution', async () => {
+    runWithContextMock.mockImplementationOnce( async ( fn, ctx ) => {
+      ctx.addAttribute( httpRequestAttribute );
+      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' } );
+    await expect( interceptor.execute( makeInput(), next ) ).resolves.toEqual( {
+      output: { result: 'ok' },
+      aggregations: {
+        cost: { total: 0 },
+        tokens: { total: 0 },
+        httpRequests: { total: 1 }
+      },
+      [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
+    } );
 
-    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();
+    expect( workflowHandleMock.signal ).not.toHaveBeenCalled();
+    expect( clientConstructorMock ).not.toHaveBeenCalled();
   } );
 
-  it( 'handles signal flush timeout after failed execution', async () => {
-    const timeoutError = Object.assign( new Error( 'timeout' ), { isTimeout: true } );
-    allSettledWithTimeoutMock.mockRejectedValueOnce( timeoutError );
+  it( 'signals collected aggregations after failed execution', async () => {
+    runWithContextMock.mockImplementationOnce( async ( fn, ctx ) => {
+      ctx.addAttribute( httpRequestAttribute );
+      return fn();
+    } );
     const { ActivityExecutionInterceptor } = await import( './activity.js' );
     const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
     const error = new Error( 'step failed' );
@@ -197,49 +205,49 @@ describe( 'ActivityExecutionInterceptor', () => {
 
     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( clientConstructorMock ).toHaveBeenCalledWith( { connection: undefined, namespace: 'default' } );
+    expect( getHandleMock ).toHaveBeenCalledWith( 'wf-1' );
+    expect( workflowHandleMock.signal ).toHaveBeenCalledWith( Signal.SEND_AGGREGATIONS, {
+      cost: { total: 0 },
+      tokens: { total: 0 },
+      httpRequests: { total: 1 }
+    } );
     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();
-    } );
+  it( 'does not send fallback signal when failed execution collected no attributes', async () => {
     const { ActivityExecutionInterceptor } = await import( './activity.js' );
     const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
-    const next = vi.fn().mockResolvedValue( { result: 'ok' } );
+    const next = vi.fn().mockRejectedValue( new Error( 'step failed' ) );
 
-    await expect( interceptor.execute( makeInput(), next ) ).resolves.toEqual( { result: 'ok' } );
+    await expect( interceptor.execute( makeInput(), next ) ).rejects.toThrow( 'step failed' );
 
-    expect( attribute.setActivity ).toHaveBeenCalledWith( 'act-1', 'myWorkflow#myStep' );
-    expect( workflowHandleMock.signal ).toHaveBeenCalledWith( Signal.ADD_ATTRIBUTE, attribute );
-    expect( allSettledWithTimeoutMock ).toHaveBeenCalledWith( [ expect.any( Promise ) ], 30_000 );
+    expect( workflowHandleMock.signal ).not.toHaveBeenCalled();
+    expect( clientConstructorMock ).not.toHaveBeenCalled();
   } );
 
-  it( 'does not signal when OUTPUT_ENABLE_ATTRIBUTE_SIGNAL_EMISSION is false', async () => {
-    vi.stubEnv( 'OUTPUT_ENABLE_ATTRIBUTE_SIGNAL_EMISSION', 'false' );
-    const attribute = { setActivity: vi.fn() };
+  it( 'logs when fallback attribute signal fails', async () => {
+    const signalError = new Error( 'signal failed' );
+    workflowHandleMock.signal.mockRejectedValueOnce( signalError );
     runWithContextMock.mockImplementationOnce( async ( fn, ctx ) => {
-      ctx.sendAttributeSignal( attribute );
+      ctx.addAttribute( httpRequestAttribute );
       return fn();
     } );
     const { ActivityExecutionInterceptor } = await import( './activity.js' );
     const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
-    const next = vi.fn().mockResolvedValue( { result: 'ok' } );
+    const next = vi.fn().mockRejectedValue( new Error( 'step failed' ) );
 
-    await expect( interceptor.execute( makeInput(), next ) ).resolves.toEqual( { result: 'ok' } );
+    await expect( interceptor.execute( makeInput(), next ) ).rejects.toThrow( 'step failed' );
 
-    expect( attribute.setActivity ).not.toHaveBeenCalled();
-    expect( workflowHandleMock.signal ).not.toHaveBeenCalled();
-    expect( allSettledWithTimeoutMock ).toHaveBeenCalledWith( [], 30_000 );
+    expect( logWarnMock ).toHaveBeenCalledWith( `Signal "${Signal.SEND_AGGREGATIONS}" failed`, expect.objectContaining( {
+      message: 'signal failed',
+      activityId: 'act-1',
+      activityName: 'myWorkflow#myStep',
+      workflowId: 'wf-1',
+      workflowName: 'myWorkflow'
+    } ) );
   } );
 
   it( 'records trace error event on failed execution', async () => {

package/src/worker/interceptors.js

@@ -6,5 +6,9 @@ const __dirname = dirname( fileURLToPath( import.meta.url ) );
 
 export const initInterceptors = ( { activities, workflows, connection } ) => ( {
   workflowModules: [ join( __dirname, './interceptors/workflow.js' ) ],
-  activityInbound: [ () => new ActivityExecutionInterceptor( { activities, workflows, connection } ) ]
+  activity: [
+    () => ( {
+      inbound: new ActivityExecutionInterceptor( { activities, workflows, connection } )
+    } )
+  ]
 } );