@outputai/core 0.10.1-next.f6a7c1a.0 → 0.11.0

package/src/worker/index.spec.js

@@ -6,6 +6,7 @@ const {
   configValues,
   connectionMonitorInstance,
   createCatalogMock,
+  flushPendingHooksMock,
   initInterceptorsMock,
   mainEventBusMock,
   mockConnection,
@@ -13,7 +14,10 @@ const {
   mockWorker,
   promises,
   resetPromises,
+  serializeErrorMock,
+  setupClientConfigMock,
   setupInterruptionHandlerMock,
+  setupTemporalLoggerMock,
   setupTelemetryMock
 } = vi.hoisted( () => {
   const createDeferred = () => {
@@ -46,7 +50,6 @@ const {
     maxConcurrentActivityTaskPolls: 5,
     maxConcurrentWorkflowTaskPolls: 5,
     workerTuner: undefined,
-    processFailureShutdownDelay: 0,
     shutdownForceTime: undefined,
     shutdownGraceTime: undefined
   };
@@ -105,6 +108,7 @@ const {
     connectionMonitorInstance,
     createCatalogMock: vi.fn().mockReturnValue( { workflows: [], activities: {} } ),
     createWorkflowsEntryPointMock: vi.fn().mockReturnValue( '/fake/workflows/path.js' ),
+    flushPendingHooksMock: vi.fn().mockResolvedValue( undefined ),
     hashSourceCodeMock: vi.fn().mockResolvedValue( 'catalog-hash' ),
     initInterceptorsMock: vi.fn().mockReturnValue( [] ),
     loadActivitiesMock: vi.fn().mockResolvedValue( {} ),
@@ -116,19 +120,24 @@ const {
     mockWorker,
     promises,
     resetPromises,
+    serializeErrorMock: vi.fn( error => ( {
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    } ) ),
+    setupClientConfigMock: vi.fn(),
     setupInterruptionHandlerMock: vi.fn(),
+    setupTemporalLoggerMock: vi.fn(),
     setupTelemetryMock: vi.fn()
   };
 } );
 
 vi.mock( '#logger', () => ( { createChildLogger: () => mockLog } ) );
-vi.mock( '#consts', async importOriginal => {
-  const actual = await importOriginal();
-  return { ...actual };
-} );
+vi.mock( '#helpers/error_serializer', () => ( { serializeError: serializeErrorMock } ) );
 const initTracing = vi.fn().mockResolvedValue( undefined );
 vi.mock( '#tracing', () => ( { init: initTracing } ) );
 vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
+vi.mock( '#hooks/pending_hooks', () => ( { flushPendingHooks: flushPendingHooksMock } ) );
 
 const loadWorkflowsMock = vi.fn().mockResolvedValue( { workflows: [], entrypoint: '/fake/workflows/path.js' } );
 const loadActivitiesMock = vi.fn().mockResolvedValue( { activities: {} } );
@@ -145,7 +154,6 @@ vi.mock( './sinks.js', () => ( { sinks: {} } ) );
 vi.mock( './catalog_workflow/index.js', () => ( { createCatalog: createCatalogMock } ) );
 vi.mock( './bundler_options.js', () => ( { webpackConfigHook: vi.fn() } ) );
 vi.mock( './interceptors/index.js', () => ( { initInterceptors: initInterceptorsMock } ) );
-vi.mock( './proxy.js', () => ( { bootstrapFetchProxy: vi.fn() } ) );
 vi.mock( './telemetry.js', () => ( { setupTelemetry: setupTelemetryMock } ) );
 vi.mock( './interruption.js', () => ( { setupInterruptionHandler: setupInterruptionHandlerMock } ) );
 vi.mock( './global_functions.js', () => ( { bindGlobalFunctions: bindGlobalFunctionsMock } ) );
@@ -160,6 +168,8 @@ vi.mock( './catalog_workflow/catalog_job.js', () => ( {
   } )
 } ) );
 vi.mock( './log_hooks.js', () => ( {} ) );
+vi.mock( './temporal_logger.js', () => ( { setupTemporalLogger: setupTemporalLoggerMock } ) );
+vi.mock( '#temporal/client', () => ( { setupClientConfig: setupClientConfigMock } ) );
 vi.mock( '@temporalio/worker', () => ( {
   NativeConnection: { connect: vi.fn().mockResolvedValue( mockConnection ) },
   Worker: { create: vi.fn().mockResolvedValue( mockWorker ) }
@@ -216,6 +226,7 @@ describe( 'worker/index', () => {
     await vi.waitFor( () => expect( Worker.create ).toHaveBeenCalled() );
 
     expect( loadHooksMock ).toHaveBeenCalledWith( '/test/caller/dir' );
+    expect( setupTemporalLoggerMock ).toHaveBeenCalledOnce();
     expect( loadWorkflowsMock ).toHaveBeenCalledWith( '/test/caller/dir' );
     expect( loadActivitiesMock ).toHaveBeenCalledWith( '/test/caller/dir', [] );
     expect( initTracing ).toHaveBeenCalled();
@@ -227,6 +238,10 @@ describe( 'worker/index', () => {
       apiKey: undefined,
       proxy: undefined
     } );
+    expect( setupClientConfigMock ).toHaveBeenCalledWith( {
+      connection: mockConnection,
+      namespace: configValues.namespace
+    } );
     expect( bindGlobalFunctionsMock ).toHaveBeenCalledTimes( 1 );
     expect( bindGlobalFunctionsMock.mock.invocationCallOrder[0] ).toBeLessThan(
       NativeConnection.connect.mock.invocationCallOrder[0]
@@ -262,6 +277,7 @@ describe( 'worker/index', () => {
     expect( catalogJobInstance.run ).toHaveBeenCalled();
 
     await settleWorker();
+    await vi.waitFor( () => expect( flushPendingHooksMock ).toHaveBeenCalledOnce() );
     expect( mockLog.info ).toHaveBeenCalledWith( 'Bye' );
   } );
 
@@ -354,11 +370,15 @@ describe( 'worker/index', () => {
 
     await vi.waitFor( () => {
       expect( mockLog.error ).toHaveBeenCalledWith( 'Fatal error', expect.objectContaining( {
-        error: 'Big Failure'
+        error: expect.objectContaining( { message: 'Big Failure' } )
       } ) );
     } );
+    expect( serializeErrorMock ).toHaveBeenCalledWith( error );
     expect( mainEventBusMock.emit ).toHaveBeenCalledWith( expect.any( String ), { error } );
     await vi.waitFor( () => expect( exitMock ).toHaveBeenCalledWith( 1 ) );
+    expect( flushPendingHooksMock ).toHaveBeenCalledOnce();
+    expect( mainEventBusMock.emit.mock.invocationCallOrder[0] ).toBeLessThan( flushPendingHooksMock.mock.invocationCallOrder[0] );
+    expect( flushPendingHooksMock.mock.invocationCallOrder[0] ).toBeLessThan( exitMock.mock.invocationCallOrder[0] );
   } );
 
   it( 'throws connection monitor errors after graceful shutdown', async () => {
@@ -373,7 +393,7 @@ describe( 'worker/index', () => {
 
     await vi.waitFor( () => {
       expect( mockLog.error ).toHaveBeenCalledWith( 'Fatal error', expect.objectContaining( {
-        error: 'connection lost'
+        error: expect.objectContaining( { message: 'connection lost' } )
       } ) );
     } );
     expect( mockWorker.shutdown ).toHaveBeenCalledOnce();
@@ -393,7 +413,7 @@ describe( 'worker/index', () => {
 
     await vi.waitFor( () => {
       expect( mockLog.error ).toHaveBeenCalledWith( 'Fatal error', expect.objectContaining( {
-        error: 'catalog failed'
+        error: expect.objectContaining( { message: 'catalog failed' } )
       } ) );
     } );
     expect( mockWorker.shutdown ).toHaveBeenCalledOnce();
@@ -413,7 +433,7 @@ describe( 'worker/index', () => {
     expect( catalogJobInstance.interrupt ).not.toHaveBeenCalled();
     await vi.waitFor( () => {
       expect( mockLog.error ).toHaveBeenCalledWith( 'Fatal error', expect.objectContaining( {
-        error: 'worker create failed'
+        error: expect.objectContaining( { message: 'worker create failed' } )
       } ) );
     } );
   } );

package/src/worker/interceptors/activity.js

@@ -1,12 +1,14 @@
-import { Context, activityInfo as activityInfoFn } from '@temporalio/activity';
+import { Context, activityInfo as activityInfoFn, ApplicationFailure } from '@temporalio/activity';
+import { CompleteAsyncError, TemporalFailure } from '@temporalio/common';
 import { Storage } from '#async_storage';
 import * as Tracing from '#tracing';
 import { headersToObject } from './headers.js';
-import { ACTIVITY_WRAPPER_VERSION_FIELD, BusEventType, METADATA_ACCESS_SYMBOL } from '#consts';
+import { ActivitySpecialOutput, BusEventType, METADATA_ACCESS_SYMBOL } from '#consts';
 import { activityHeartbeatEnabled, activityHeartbeatIntervalMs } from '../configs.js';
 import { mainEventBus } from '#bus';
-import { aggregateAttributes } from '#helpers/aggregations';
-import { buildApplicationFailureWithDetails } from '#helpers/errors';
+import { inheritsFromAnyNamedType } from '#helpers/errors';
+import { serializeError } from '#helpers/error_serializer';
+import { FatalError, TransparentFatalError } from '#errors';
 
 /*
   This interceptor wraps every activity execution with cross-cutting concerns:
@@ -51,12 +53,9 @@ export class ActivityExecutionInterceptor {
     }
 
     const state = {
-      heartbeat: null,
-      attributes: []
+      heartbeat: null
     };
 
-    const addAttribute = attribute => state.attributes.push( attribute );
-
     // Adds context accessible information
     const storageContext = {
       parentId: activityId,
@@ -64,8 +63,7 @@ export class ActivityExecutionInterceptor {
       activityInfo,
       workflowDetails,
       workflowFilename,
-      traceInfo,
-      addAttribute
+      traceInfo
     };
 
     mainEventBus.emit( BusEventType.ACTIVITY_START, { activityInfo, workflowDetails, outputActivityKind } );
@@ -77,19 +75,34 @@ export class ActivityExecutionInterceptor {
 
       const output = await Storage.runWithContext( async _ => next( input ), storageContext );
 
-      const aggregations = state.attributes.length > 0 ? aggregateAttributes( state.attributes ) : null;
-
-      mainEventBus.emit( BusEventType.ACTIVITY_END, { activityInfo, aggregations, workflowDetails, outputActivityKind } );
+      mainEventBus.emit( BusEventType.ACTIVITY_END, { activityInfo, workflowDetails, outputActivityKind } );
       Tracing.addEventEnd( { id: activityId, details: output, traceInfo } );
 
-      return { [ACTIVITY_WRAPPER_VERSION_FIELD]: 1, output, aggregations };
+      return output;
 
     } catch ( error ) {
-      const aggregations = state.attributes.length > 0 ? aggregateAttributes( state.attributes ) : null;
-      mainEventBus.emit( BusEventType.ACTIVITY_ERROR, { activityInfo, aggregations, workflowDetails, outputActivityKind, error } );
-      Tracing.addEventError( { id: activityId, details: error, traceInfo } );
-
-      throw aggregations ? buildApplicationFailureWithDetails( error, { aggregations } ) : error;
+      // Record async completion handoff as a trace end without emitting a bus event.
+      if ( error instanceof CompleteAsyncError ) {
+        Tracing.addEventEnd( { id: activityId, details: ActivitySpecialOutput.ASYNC_HANDOFF, traceInfo } );
+        throw error;
+      }
+
+      const unwrappedError = error instanceof TransparentFatalError ? error.cause : error;
+
+      Tracing.addEventError( { id: activityId, details: unwrappedError, traceInfo } );
+      mainEventBus.emit( BusEventType.ACTIVITY_ERROR, { activityInfo, workflowDetails, outputActivityKind, error: unwrappedError } );
+
+      // Native Temporal errors are just re-thrown
+      if ( error instanceof TemporalFailure ) {
+        throw error;
+      }
+
+      const nonRetryable = error instanceof FatalError || inheritsFromAnyNamedType( error, activityInfo.retryPolicy?.nonRetryableErrorTypes ?? [] );
+      throw ApplicationFailure.fromError( unwrappedError, {
+        nonRetryable,
+        cause: unwrappedError,
+        details: [ { error: serializeError( unwrappedError, { dropKeys: [ 'stack' ] } ) } ]
+      } );
     } finally {
       clearInterval( state.heartbeat );
     }

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

@@ -1,9 +1,8 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { ApplicationFailure } from '@temporalio/common';
-import { ACTIVITY_WRAPPER_VERSION_FIELD, BusEventType } from '#consts';
-import { Attribute } from '#trace_attribute';
+import { ApplicationFailure, CompleteAsyncError } from '@temporalio/common';
+import { ActivitySpecialOutput, BusEventType, METADATA_ACCESS_SYMBOL } from '#consts';
+import { TransparentFatalError } from '#errors';
 
-const METADATA_ACCESS_SYMBOL = vi.hoisted( () => Symbol( '__metadata' ) );
 const heartbeatMock = vi.hoisted( () => vi.fn() );
 const runWithContextMock = vi.hoisted( () => vi.fn().mockImplementation( async fn => fn() ) );
 const activityInfoMock = vi.hoisted( () => ( {
@@ -64,15 +63,6 @@ vi.mock( './headers.js', () => ( {
 const mainEventBusEmitMock = vi.fn();
 vi.mock( '#bus', () => ( { mainEventBus: { emit: mainEventBusEmitMock } } ) );
 
-vi.mock( '#consts', async importOriginal => {
-  const actual = await importOriginal();
-  return {
-    ...actual, get METADATA_ACCESS_SYMBOL() {
-      return METADATA_ACCESS_SYMBOL;
-    }
-  };
-} );
-
 vi.mock( '../configs.js', () => ( {
   get activityHeartbeatEnabled() {
     return process.env.OUTPUT_ACTIVITY_HEARTBEAT_ENABLED !== 'false';
@@ -93,24 +83,12 @@ const makeInput = () => ( {
   headers: {}
 } );
 
-const httpRequestAttribute = {
-  type: Attribute.HTTPRequestCount.TYPE,
-  url: 'https://api.example.test/items',
-  requestId: 'req-1'
-};
-
-const httpRequestAggregations = {
-  cost: { total: 0 },
-  tokens: { total: 0 },
-  httpRequests: { total: 1 }
-};
-
 describe( 'ActivityExecutionInterceptor', () => {
   beforeEach( () => {
     vi.clearAllMocks();
     activityInfoMock.workflowType = 'myWorkflow';
+    delete activityInfoMock.retryPolicy;
     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' );
@@ -126,22 +104,14 @@ describe( 'ActivityExecutionInterceptor', () => {
     const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
     const next = vi.fn().mockResolvedValue( { result: 'ok' } );
 
-    const promise = interceptor.execute( makeInput(), next );
-    vi.advanceTimersByTime( 0 );
-    const output = await promise;
-
-    expect( output ).toEqual( {
-      output: { result: 'ok' },
-      aggregations: null,
-      [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
-    } );
+    await expect( interceptor.execute( makeInput(), next ) ).resolves.toEqual( { result: 'ok' } );
     expect( mainEventBusEmitMock ).toHaveBeenCalledWith(
       BusEventType.ACTIVITY_START,
       { activityInfo: activityInfoMock, workflowDetails: workflowDetailsMock, outputActivityKind: 'step' }
     );
     expect( mainEventBusEmitMock ).toHaveBeenCalledWith(
       BusEventType.ACTIVITY_END,
-      { activityInfo: activityInfoMock, aggregations: null, workflowDetails: workflowDetailsMock, outputActivityKind: 'step' }
+      { activityInfo: activityInfoMock, workflowDetails: workflowDetailsMock, outputActivityKind: 'step' }
     );
     expect( addEventStartMock ).toHaveBeenCalledWith( {
       id: 'act-1',
@@ -161,74 +131,36 @@ describe( 'ActivityExecutionInterceptor', () => {
         workflowDetails: workflowDetailsMock,
         outputActivityKind: 'step',
         workflowFilename: '/workflows/myWorkflow.js',
-        traceInfo: traceInfoMock,
-        addAttribute: expect.any( Function )
+        traceInfo: traceInfoMock
       } )
     );
   } );
 
-  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( {
-      output: { result: 'sync' },
-      aggregations: null,
-      [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
-    } );
-
-    expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, expect.any( Object ) );
-    expect( addEventEndMock ).toHaveBeenCalledWith( { id: 'act-1', details: { result: 'sync' }, traceInfo: traceInfoMock } );
-    expect( addEventErrorMock ).not.toHaveBeenCalled();
-  } );
-
-  it( 'returns collected aggregations 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( {
-      output: { result: 'ok' },
-      aggregations: httpRequestAggregations,
-      [ACTIVITY_WRAPPER_VERSION_FIELD]: 1
-    } );
-
-    expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_END, {
-      activityInfo: activityInfoMock,
-      aggregations: httpRequestAggregations,
-      workflowDetails: workflowDetailsMock,
-      outputActivityKind: 'step'
-    } );
-  } );
-
-  it( 'stores collected aggregations in ApplicationFailure details after failed execution', async () => {
-    runWithContextMock.mockImplementationOnce( async ( fn, ctx ) => {
-      ctx.addAttribute( httpRequestAttribute );
-      return fn();
-    } );
+  it( 'wraps native errors with serialized details', async () => {
     const { ActivityExecutionInterceptor } = await import( './activity.js' );
     const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
     const error = new Error( 'step failed' );
+    error.code = 'ESTEP';
     const next = vi.fn().mockRejectedValue( error );
 
     const thrown = await interceptor.execute( makeInput(), next ).catch( e => e );
+
     expect( thrown ).toBeInstanceOf( ApplicationFailure );
     expect( thrown ).toMatchObject( {
       message: 'step failed',
       type: 'Error',
       details: [ {
-        aggregations: httpRequestAggregations
+        error: {
+          name: 'Error',
+          message: 'step failed',
+          code: 'ESTEP'
+        }
       } ],
-      cause: error
+      cause: error,
+      nonRetryable: false
     } );
     expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
       activityInfo: activityInfoMock,
-      aggregations: httpRequestAggregations,
       workflowDetails: workflowDetailsMock,
       outputActivityKind: 'step',
       error
@@ -237,105 +169,93 @@ describe( 'ActivityExecutionInterceptor', () => {
     expect( addEventEndMock ).not.toHaveBeenCalled();
   } );
 
-  it( 'appends collected aggregations to existing failure details', async () => {
-    runWithContextMock.mockImplementationOnce( async ( fn, ctx ) => {
-      ctx.addAttribute( httpRequestAttribute );
-      return fn();
-    } );
+  it( 'marks inherited configured error types as non-retryable', async () => {
+    class ValidationError extends Error {}
+    class SpecificValidationError extends ValidationError {}
+    activityInfoMock.retryPolicy = { nonRetryableErrorTypes: [ 'ValidationError' ] };
     const { ActivityExecutionInterceptor } = await import( './activity.js' );
     const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
-    const error = new Error( 'step failed' );
-    error.details = [ { domain: { reason: 'bad-input' } } ];
+    const error = new SpecificValidationError( 'invalid input' );
     const next = vi.fn().mockRejectedValue( error );
 
     const thrown = await interceptor.execute( makeInput(), next ).catch( e => e );
 
-    expect( thrown.details ).toEqual( [
-      { domain: { reason: 'bad-input' } },
-      { aggregations: httpRequestAggregations }
-    ] );
-  } );
-
-  it( 'rethrows the original error when failed execution collected no attributes', async () => {
-    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.toBe( error );
-  } );
-
-  it( 'rethrows the original error with existing details when failed execution collected no attributes', async () => {
-    const { ActivityExecutionInterceptor } = await import( './activity.js' );
-    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
-    const error = new Error( 'step failed' );
-    error.details = [ { domain: { reason: 'bad-input' } } ];
-    const next = vi.fn().mockRejectedValue( error );
-
-    await expect( interceptor.execute( makeInput(), next ) ).rejects.toBe( error );
-    expect( error.details ).toEqual( [ { domain: { reason: 'bad-input' } } ] );
-  } );
-
-  it( 'wraps existing ApplicationFailure without creating a self-cause', async () => {
-    runWithContextMock.mockImplementationOnce( async ( fn, ctx ) => {
-      ctx.addAttribute( httpRequestAttribute );
-      return fn();
-    } );
-    const error = ApplicationFailure.create( {
-      message: 'application failed',
-      type: 'OriginalType',
+    expect( thrown ).toMatchObject( {
+      type: 'SpecificValidationError',
       nonRetryable: true,
-      details: [ { domain: { reason: 'bad-input' } } ]
+      cause: error
     } );
+  } );
+
+  it( 'uses a transparent error cause while remaining non-retryable without retry policy metadata', async () => {
     const { ActivityExecutionInterceptor } = await import( './activity.js' );
     const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
+    const cause = new TypeError( 'provider rejected request' );
+    cause.code = 'EAUTH';
+    const error = new TransparentFatalError( cause );
     const next = vi.fn().mockRejectedValue( error );
 
     const thrown = await interceptor.execute( makeInput(), next ).catch( e => e );
 
-    expect( thrown ).toBeInstanceOf( ApplicationFailure );
-    expect( thrown ).not.toBe( error );
-    expect( thrown.cause ).toBe( error );
-    expect( thrown.cause ).not.toBe( thrown );
     expect( thrown ).toMatchObject( {
-      message: 'application failed',
-      type: 'OriginalType',
+      message: 'provider rejected request',
+      type: 'TypeError',
       nonRetryable: true,
-      details: [
-        { domain: { reason: 'bad-input' } },
-        { aggregations: httpRequestAggregations }
-      ]
+      cause,
+      details: [ {
+        error: {
+          name: 'TypeError',
+          message: 'provider rejected request',
+          code: 'EAUTH'
+        }
+      } ]
+    } );
+    expect( addEventErrorMock ).toHaveBeenCalledWith( { id: 'act-1', details: cause, traceInfo: traceInfoMock } );
+    expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
+      activityInfo: activityInfoMock,
+      workflowDetails: workflowDetailsMock,
+      outputActivityKind: 'step',
+      error: cause
     } );
   } );
 
-  it( 'records trace error event on failed execution', async () => {
+  it( 'rethrows existing Temporal failures unchanged', async () => {
     const { ActivityExecutionInterceptor } = await import( './activity.js' );
     const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
-    const error = new Error( 'step failed' );
+    const error = ApplicationFailure.nonRetryable( 'domain failed', 'DomainFailure', { reason: 'invalid' } );
     const next = vi.fn().mockRejectedValue( error );
 
-    const promise = interceptor.execute( makeInput(), next );
-    vi.advanceTimersByTime( 0 );
-
-    await expect( promise ).rejects.toThrow( 'step failed' );
-    expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_START, expect.any( Object ) );
+    await expect( interceptor.execute( makeInput(), next ) ).rejects.toBe( error );
+    expect( addEventErrorMock ).toHaveBeenCalledWith( { id: 'act-1', details: error, traceInfo: traceInfoMock } );
     expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
       activityInfo: activityInfoMock,
-      aggregations: null,
       workflowDetails: workflowDetailsMock,
       outputActivityKind: 'step',
       error
     } );
-    expect( addEventStartMock ).toHaveBeenCalledOnce();
-    expect( addEventErrorMock ).toHaveBeenCalledWith( { id: 'act-1', details: error, traceInfo: traceInfoMock } );
-    expect( addEventEndMock ).not.toHaveBeenCalled();
   } );
 
-  it( 'sends periodic heartbeats during activity execution', async () => {
+  it( 'records async completion handoff as a trace end only', async () => {
+    const { ActivityExecutionInterceptor } = await import( './activity.js' );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
+    const error = new CompleteAsyncError();
+    const next = vi.fn().mockRejectedValue( error );
+
+    await expect( interceptor.execute( makeInput(), next ) ).rejects.toBe( error );
+    expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_START, expect.any( Object ) );
+    expect( mainEventBusEmitMock ).toHaveBeenCalledTimes( 1 );
+    expect( addEventEndMock ).toHaveBeenCalledWith( {
+      id: 'act-1',
+      details: ActivitySpecialOutput.ASYNC_HANDOFF,
+      traceInfo: traceInfoMock
+    } );
+    expect( addEventErrorMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'sends periodic heartbeats and stops after successful execution', async () => {
     const { ActivityExecutionInterceptor } = await import( './activity.js' );
     const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
 
-    // next() resolves only after we manually resolve it, simulating a long-running activity
     const deferred = { resolve: null };
     const next = vi.fn().mockImplementation( () => new Promise( r => {
       deferred.resolve = r;
@@ -356,16 +276,6 @@ describe( 'ActivityExecutionInterceptor', () => {
 
     deferred.resolve( { result: 'done' } );
     await promise;
-  } );
-
-  it( 'clears heartbeat interval after activity completes', async () => {
-    const { ActivityExecutionInterceptor } = await import( './activity.js' );
-    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
-    const next = vi.fn().mockResolvedValue( { result: 'ok' } );
-
-    const promise = interceptor.execute( makeInput(), next );
-    vi.advanceTimersByTime( 0 );
-    await promise;
 
     heartbeatMock.mockClear();
     vi.advanceTimersByTime( 500 );
@@ -379,7 +289,7 @@ describe( 'ActivityExecutionInterceptor', () => {
 
     const promise = interceptor.execute( makeInput(), next );
     vi.advanceTimersByTime( 0 );
-    await promise.catch( () => {} );
+    await expect( promise ).rejects.toBeInstanceOf( ApplicationFailure );
 
     heartbeatMock.mockClear();
     vi.advanceTimersByTime( 500 );
@@ -391,7 +301,6 @@ describe( 'ActivityExecutionInterceptor', () => {
     const workflows = [ { name: 'myWorkflow', path: '/workflows/myWorkflow.js', aliases: [ 'myWorkflowOld' ] } ];
     const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows } );
 
-    // Override context to use alias as workflowType
     activityInfoMock.workflowType = 'myWorkflowOld';
     const next = vi.fn().mockResolvedValue( { result: 'ok' } );
 
@@ -399,14 +308,10 @@ describe( 'ActivityExecutionInterceptor', () => {
     vi.advanceTimersByTime( 0 );
     await promise;
 
-    // Should resolve to the correct path despite using the alias
     expect( runWithContextMock ).toHaveBeenCalledWith(
       expect.any( Function ),
       expect.objectContaining( { workflowFilename: '/workflows/myWorkflow.js' } )
     );
-
-    // Restore for other tests
-    activityInfoMock.workflowType = 'myWorkflow';
   } );
 
   it( 'does not heartbeat when OUTPUT_ACTIVITY_HEARTBEAT_ENABLED is false', async () => {