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

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 () => {

package/src/worker/interceptors/workflow.js

@@ -1,13 +1,17 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
-import { workflowInfo, proxySinks, ContinueAsNew, isCancellation } from '@temporalio/workflow';
+import { workflowInfo, proxySinks, ContinueAsNew, isCancellation, ApplicationFailure, TemporalFailure, upsertMemo } from '@temporalio/workflow';
 import { memoToHeaders } from './headers.js';
 import { deepMerge } from '#helpers/object';
-import { buildApplicationFailureWithDetails } from '#helpers/errors';
-import { METADATA_ACCESS_SYMBOL, WorkflowSpecialOutput } from '#consts';
+import { WorkflowSpecialOutput } from '#consts';
 import { createWorkflowDetails } from '#helpers/temporal_context';
+import { TraceInfo } from '#helpers/trace_info';
+import { FatalError, TransparentFatalError } from '#errors';
+import { serializeError } from '#helpers/error_serializer';
+import { enforceActivityOptions } from '#helpers/activity_options';
 
-// this is a dynamic generated file with activity configs overwrites
+// these are a dynamic generated file with activity configs overwrites and workflow options
 import activityOptionsMap from '../temp/__activity_options.js';
+import workflowOptionsMap from '../temp/__workflow_options.js';
 
 /*
   This interceptor adds Memo and serialized workflowInfo() to the Activity invocation headers.
@@ -27,6 +31,8 @@ class HeadersInjectionInterceptor {
     if ( activityOptionsOverrides ) {
       input.options = deepMerge( input.options ?? {}, activityOptionsOverrides );
     }
+    // Re-enforce framework options after component overrides
+    input.options = enforceActivityOptions( input.options );
     return next( input );
   }
 };
@@ -35,6 +41,15 @@ const sinks = proxySinks();
 
 class WorkflowExecutionInterceptor {
   async execute( input, next ) {
+    const { workflowType, root } = workflowInfo();
+    const traceEnabled = workflowOptionsMap[workflowType]?.disableTrace !== true;
+    const isRoot = !root; // root workflow doesn't have the root block
+
+    upsertMemo( {
+      payloadVersion: '2',
+      ...( isRoot && traceEnabled && { traceInfo: TraceInfo.build() } )
+    } );
+
     sinks.workflow.start( input.args[0] );
     try {
       const output = await next( input );
@@ -51,19 +66,46 @@ class WorkflowExecutionInterceptor {
         throw error;
       }
 
+      /**
+       * We send serialized error to the sink, because temporal loses Error meta-information, like name, type, etc
+       * when crossing the workflow sandbox barrier. The plain object doesn't lose anything.
+       */
+      /**
+       * This happens when the workflow is cancelled.
+       * Re-throw the error as it is.
+       * Sink back the error without stack (not necessary for this).
+       */
       if ( isCancellation( error ) ) {
-        sinks.workflow.error( error );
+        sinks.workflow.error( serializeError( error, { dropKeys: [ 'stack' ] } ) );
         throw error;
       }
 
-      sinks.workflow.error( error );
+      /**
+       * This represents an error in the workflow itself, in this case the sink receives the error serialize with stack
+       * An Application failure is constructed to finish the workflow run and the serialized error is added to its details
+       * so the API or other consumers can read it. Stack is omitted
+       */
+      if ( error instanceof FatalError ) {
+        const unwrappedError = error instanceof TransparentFatalError ? error.cause : error;
+        sinks.workflow.error( serializeError( unwrappedError ) );
+        throw ApplicationFailure.fromError( unwrappedError, {
+          cause: unwrappedError,
+          nonRetryable: true,
+          details: [ { error: serializeError( unwrappedError, { dropKeys: [ 'stack' ] } ) } ]
+        } );
+      };
 
-      /*
-       * Add internal error .details to Temporal's ApplicationFailure .details
-       * This make it possible for this information be retrieved by Temporal's client instance.
-       * Ref: https://typescript.temporal.io/api/classes/common.ApplicationFailure#details
+      /**
+       * This is mostly likely an error in one Activity (or other Temporal parts)
+       * Re-throw as it is and sink back the error without failure, for the same reason as in cancellation.
        */
-      throw error[METADATA_ACCESS_SYMBOL] ? buildApplicationFailureWithDetails( error, error[METADATA_ACCESS_SYMBOL] ) : error;
+      if ( error instanceof TemporalFailure ) {
+        sinks.workflow.error( serializeError( error ) );
+        throw error;
+      }
+
+      // Workflow Task failure, do not sink as this retries the Task only,  not the Workflow
+      throw error;
     }
   }
 };