@outputai/core 0.5.3-next.0eeffec.0 → 0.5.3-next.69060d7.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/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/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/interface/aggregations.js

@@ -1,24 +0,0 @@
-import { Attribute } from '#trace_attribute';
-import Decimal from 'decimal.js';
-
-export const aggregateAttributes = attributes => ( {
-  cost: {
-    total: attributes
-      .filter( a => [ Attribute.HTTPRequestCost.TYPE, Attribute.LLMUsage.TYPE ].includes( a.type ) )
-      .reduce( ( sum, a ) => sum.add( a.total ), Decimal( 0 ) ).toNumber()
-  },
-  tokens: {
-    total: attributes
-      .filter( a => Attribute.LLMUsage.TYPE === a.type )
-      .reduce( ( sum, a ) => sum.add( a.tokensUsed ), Decimal( 0 ) ).toNumber(),
-    ...Object.entries( attributes
-      .filter( a => Attribute.LLMUsage.TYPE === a.type )
-      .flatMap( a => a.usage )
-      .reduce( ( obj, a ) => Object.assign( obj, { [a.type]: ( obj[a.type] ?? Decimal( 0 ) ).add( a.amount ) } ), {} ) )
-      .reduce( ( obj, [ k, v ] ) => Object.assign( obj, { [k]: v.toNumber() } ), {} ) // convert all values to number
-
-  },
-  httpRequests: {
-    total: attributes.filter( a => Attribute.HTTPRequestCount.TYPE === a.type ).length
-  }
-} );