@outputai/core 0.13.1-next.a28b894.0 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.13.1-next.a28b894.0",
+  "version": "0.14.0",
   "description": "The core module of the output framework",
   "type": "module",
   "engines": {

package/src/helpers/error_serializer.js

@@ -61,6 +61,18 @@ export const flattenPrototypeChain = ( target, depth = 0, result = [], maxDepth
   !target || depth >= maxDepth ? result :
     flattenPrototypeChain( Object.getPrototypeOf( target ), depth + 1, result.concat( target ), maxDepth );
 
+// Realm agnostic check for DOMException, works for AbortController errors even on environments without DOMExceptions
+export const isDomException = target => Object.prototype.toString.call( target ) === '[object DOMException]';
+
+const evaluateSpecialObjectsKeysList = target => {
+  // DOMException has a special serialization because it carries a bunch of legacy constant fields
+  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException
+  if ( isDomException( target ) ) {
+    return [ 'name', 'message', 'code', 'cause', 'stack' ];
+  }
+  return null;
+};
+
 /**
  * Define the best "name" for an Error object
  * Rules: Assigned .name property > inherited .name if not "Error" > constructor.name
@@ -176,6 +188,8 @@ const serializeValue = ( target, options, state = { depth: 0, seen: new GlobalCo
     const prototypes = flattenPrototypeChain( target );
     const receiver = target;
 
+    const strictKeysList = evaluateSpecialObjectsKeysList( target );
+
     const props = prototypes.reduce( ( projection, proto ) => {
       if ( Object.keys( projection ).length > MAX_OBJECT_KEYS ) {
         return projection;
@@ -187,6 +201,10 @@ const serializeValue = ( target, options, state = { depth: 0, seen: new GlobalCo
           continue;
         }
 
+        if ( Array.isArray( strictKeysList ) && !strictKeysList.includes( key ) ) {
+          continue;
+        }
+
         const sanitizedKey = truncateString( key, MAX_OBJECT_KEY_LEN );
         if ( Object.hasOwn( projection, sanitizedKey ) ) { // do not overwrite similar keys
           continue;
@@ -212,7 +230,7 @@ const serializeValue = ( target, options, state = { depth: 0, seen: new GlobalCo
     if ( !options.ignoredKeys.includes( 'name' ) && target instanceof Error ) {
       const name = resolveErrorName( target );
       if ( name !== undefined ) {
-        props.name = name;
+        props.name = typeof name === 'string' ? truncateString( name ) : serializeValue( name, options, nextState );
       }
     }
 

package/src/helpers/error_serializer.spec.js

@@ -1,6 +1,7 @@
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 import {
   flattenPrototypeChain,
+  isDomException,
   resolveErrorName,
   serializeError,
   truncateArray,
@@ -43,6 +44,33 @@ describe( 'error serializer helpers', () => {
     } );
   } );
 
+  describe( 'isDomException', () => {
+    afterEach( () => {
+      vi.unstubAllGlobals();
+    } );
+
+    it( 'detects DOMExceptions, including abort reasons, and rejects lookalikes', () => {
+      expect( isDomException( new DOMException( 'aborted', 'AbortError' ) ) ).toBe( true );
+      expect( isDomException( AbortSignal.abort().reason ) ).toBe( true );
+      expect( isDomException( new Error( 'aborted' ) ) ).toBe( false );
+      expect( isDomException( { name: 'AbortError', code: 20 } ) ).toBe( false );
+      expect( isDomException( undefined ) ).toBe( false );
+      expect( isDomException( null ) ).toBe( false );
+    } );
+
+    it( 'detects DOMExceptions where the global is unavailable, as in the workflow sandbox', () => {
+      const error = new DOMException( 'aborted', 'AbortError' );
+      vi.stubGlobal( 'DOMException', undefined );
+
+      expect( isDomException( error ) ).toBe( true );
+      expect( serializeError( error, { dropKeys: [ 'stack' ] } ) ).toEqual( {
+        name: 'AbortError',
+        message: 'aborted',
+        code: 20
+      } );
+    } );
+  } );
+
   describe( 'resolveErrorName', () => {
     it( 'uses explicit, inherited, and constructor names in precedence order', () => {
       class ConstructorNamedError extends Error {}
@@ -194,6 +222,33 @@ describe( 'serializeError', () => {
     expect( serializeError( /request-\d+/gi ) ).toBe( '/request-\\d+/gi' );
   } );
 
+  it( 'serializes DOMException values without the legacy prototype constants', () => {
+    const error = new DOMException( 'Cancelled by caller', 'AbortError' );
+
+    expect( serializeError( error ) ).toEqual( {
+      name: 'AbortError',
+      message: 'Cancelled by caller',
+      code: 20,
+      stack: expect.stringContaining( 'AbortError: Cancelled by caller' )
+    } );
+    expect( serializeError( error, { dropKeys: [ /stack/ ] } ) ).toEqual( {
+      name: 'AbortError',
+      message: 'Cancelled by caller',
+      code: 20
+    } );
+  } );
+
+  it( 'marks circular DOMException fields and drops properties outside the allowed list', () => {
+    const error = new DOMException( 'aborted', 'AbortError' );
+    Object.defineProperty( error, 'message', { value: error, enumerable: true } );
+    error.attempt = 2;
+
+    expect( serializeError( { reason: error, sibling: 'preserved' }, { dropKeys: [ 'stack' ] } ) ).toEqual( {
+      reason: { name: 'AbortError', message: '[Circular Reference]', code: 20 },
+      sibling: 'preserved'
+    } );
+  } );
+
   it( 'serializes bigint values with an n suffix', () => {
     expect( serializeError( 42n ) ).toBe( '42n' );
     expect( serializeError( -42n ) ).toBe( '-42n' );
@@ -298,6 +353,17 @@ describe( 'serializeError', () => {
     expect( serialized['...'] ).toBe( '[Maximum Object Properties Reached]' );
   } );
 
+  it( 'serializes the resolved error name instead of returning it raw', () => {
+    const circular = new Error( 'boom' );
+    circular.name = circular;
+    const oversized = new Error( 'boom' );
+    oversized.name = 'n'.repeat( 16_385 );
+
+    expect( serializeError( circular, { dropKeys: [ 'stack' ] } ).name ).toBe( '[Circular Reference]' );
+    expect( serializeError( oversized, { dropKeys: [ 'stack' ] } ).name )
+      .toBe( `${'n'.repeat( 16_384 )}... [1 more characters omitted]` );
+  } );
+
   it( 'retains error identity when properties reach the object limit', () => {
     class DetailedError extends Error {}
     const error = new DetailedError( 'failed' );

package/src/worker/interceptors/activity.js

@@ -40,10 +40,13 @@ export class ActivityExecutionInterceptor {
 
   async execute( input, next ) {
     const activityInfo = activityInfoFn();
-    const { workflowExecution: { runId }, activityId, activityType, workflowType } = activityInfo;
+    const { workflowExecution: { runId }, activityId, attempt, activityType, workflowType } = activityInfo;
     const { traceInfo, workflowDetails } = headersToObject( input.headers );
     const outputActivityKind = this.activityKindMap.get( activityType );
     const workflowFilename = this.workflowsPathMap.get( workflowType );
+    // Retries reuse the same activityId, so the attempt is appended to keep each attempt a discrete trace entry.
+    // Also prefix with the runId to avoid conflict with child workflows.
+    const traceId = `${runId}:${activityId}:${attempt}`;
 
     if ( !outputActivityKind ) {
       throw new Error( `Activity interceptor: activity "${activityType}" was not registered.` );
@@ -58,7 +61,7 @@ export class ActivityExecutionInterceptor {
 
     // Adds context accessible information
     const storageContext = {
-      parentId: activityId,
+      parentId: traceId,
       outputActivityKind,
       activityInfo,
       workflowDetails,
@@ -67,7 +70,7 @@ export class ActivityExecutionInterceptor {
     };
 
     mainEventBus.emit( BusEventType.ACTIVITY_START, { activityInfo, workflowDetails, outputActivityKind } );
-    Tracing.addEventStart( { id: activityId, name: activityType, kind: outputActivityKind, parentId: runId, details: input.args[0], traceInfo } );
+    Tracing.addEventStart( { id: traceId, name: activityType, kind: outputActivityKind, parentId: runId, details: input.args[0], traceInfo } );
 
     try {
       // Sends heartbeat to communicate that activity is still alive
@@ -76,20 +79,20 @@ export class ActivityExecutionInterceptor {
       const output = await Storage.runWithContext( async _ => next( input ), storageContext );
 
       mainEventBus.emit( BusEventType.ACTIVITY_END, { activityInfo, workflowDetails, outputActivityKind } );
-      Tracing.addEventEnd( { id: activityId, details: output, traceInfo } );
+      Tracing.addEventEnd( { id: traceId, details: output, traceInfo } );
 
       return output;
 
     } catch ( 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 } );
+        Tracing.addEventEnd( { id: traceId, details: ActivitySpecialOutput.ASYNC_HANDOFF, traceInfo } );
         throw error;
       }
 
       const unwrappedError = error instanceof TransparentFatalError ? error.cause : error;
 
-      Tracing.addEventError( { id: activityId, details: unwrappedError, traceInfo } );
+      Tracing.addEventError( { id: traceId, details: unwrappedError, traceInfo } );
       mainEventBus.emit( BusEventType.ACTIVITY_ERROR, { activityInfo, workflowDetails, outputActivityKind, error: unwrappedError } );
 
       // Native Temporal errors are just re-thrown

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

@@ -8,6 +8,7 @@ const runWithContextMock = vi.hoisted( () => vi.fn().mockImplementation( async f
 const activityInfoMock = vi.hoisted( () => ( {
   workflowExecution: { workflowId: 'wf-1', runId: 'run-1' },
   activityId: 'act-1',
+  attempt: 1,
   activityType: 'myWorkflow#myStep',
   workflowType: 'myWorkflow'
 } ) );
@@ -87,6 +88,8 @@ describe( 'ActivityExecutionInterceptor', () => {
   beforeEach( () => {
     vi.clearAllMocks();
     activityInfoMock.workflowType = 'myWorkflow';
+    activityInfoMock.workflowExecution.runId = 'run-1';
+    activityInfoMock.attempt = 1;
     delete activityInfoMock.retryPolicy;
     vi.useFakeTimers();
     // Default: heartbeat enabled with 50ms interval for fast tests
@@ -114,19 +117,19 @@ describe( 'ActivityExecutionInterceptor', () => {
       { activityInfo: activityInfoMock, workflowDetails: workflowDetailsMock, outputActivityKind: 'step' }
     );
     expect( addEventStartMock ).toHaveBeenCalledWith( {
-      id: 'act-1',
+      id: 'run-1:act-1:1',
       name: 'myWorkflow#myStep',
       kind: 'step',
       parentId: 'run-1',
       details: { someInput: 'data' },
       traceInfo: traceInfoMock
     } );
-    expect( addEventEndMock ).toHaveBeenCalledWith( { id: 'act-1', details: { result: 'ok' }, traceInfo: traceInfoMock } );
+    expect( addEventEndMock ).toHaveBeenCalledWith( { id: 'run-1:act-1:1', details: { result: 'ok' }, traceInfo: traceInfoMock } );
     expect( addEventErrorMock ).not.toHaveBeenCalled();
     expect( runWithContextMock ).toHaveBeenCalledWith(
       expect.any( Function ),
       expect.objectContaining( {
-        parentId: 'act-1',
+        parentId: 'run-1:act-1:1',
         activityInfo: activityInfoMock,
         workflowDetails: workflowDetailsMock,
         outputActivityKind: 'step',
@@ -136,6 +139,37 @@ describe( 'ActivityExecutionInterceptor', () => {
     );
   } );
 
+  it( 'scopes trace ids by attempt so retries do not reuse the same id', async () => {
+    const { ActivityExecutionInterceptor } = await import( './activity.js' );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
+    activityInfoMock.attempt = 3;
+    const next = vi.fn().mockResolvedValue( { result: 'ok' } );
+
+    await expect( interceptor.execute( makeInput(), next ) ).resolves.toEqual( { result: 'ok' } );
+    expect( addEventStartMock ).toHaveBeenCalledWith( expect.objectContaining( { id: 'run-1:act-1:3', parentId: 'run-1' } ) );
+    expect( addEventEndMock ).toHaveBeenCalledWith( expect.objectContaining( { id: 'run-1:act-1:3' } ) );
+    expect( runWithContextMock ).toHaveBeenCalledWith(
+      expect.any( Function ),
+      expect.objectContaining( { parentId: 'run-1:act-1:3' } )
+    );
+  } );
+
+  it( 'scopes trace ids by run so a child workflow reusing an activityId gets a distinct id', async () => {
+    const { ActivityExecutionInterceptor } = await import( './activity.js' );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
+    const next = vi.fn().mockResolvedValue( { result: 'ok' } );
+
+    // Temporal numbers activityIds per run, so a parent and its child both reach the same 'act-1' on attempt 1.
+    await interceptor.execute( makeInput(), next );
+    activityInfoMock.workflowExecution.runId = 'run-2';
+    await interceptor.execute( makeInput(), next );
+
+    expect( addEventStartMock.mock.calls.map( ( [ { id, parentId } ] ) => ( { id, parentId } ) ) ).toEqual( [
+      { id: 'run-1:act-1:1', parentId: 'run-1' },
+      { id: 'run-2:act-1:1', parentId: 'run-2' }
+    ] );
+  } );
+
   it( 'wraps native errors with serialized details', async () => {
     const { ActivityExecutionInterceptor } = await import( './activity.js' );
     const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
@@ -210,7 +244,7 @@ describe( 'ActivityExecutionInterceptor', () => {
         }
       } ]
     } );
-    expect( addEventErrorMock ).toHaveBeenCalledWith( { id: 'act-1', details: cause, traceInfo: traceInfoMock } );
+    expect( addEventErrorMock ).toHaveBeenCalledWith( { id: 'run-1:act-1:1', details: cause, traceInfo: traceInfoMock } );
     expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
       activityInfo: activityInfoMock,
       workflowDetails: workflowDetailsMock,
@@ -226,7 +260,7 @@ describe( 'ActivityExecutionInterceptor', () => {
     const next = vi.fn().mockRejectedValue( error );
 
     await expect( interceptor.execute( makeInput(), next ) ).rejects.toBe( error );
-    expect( addEventErrorMock ).toHaveBeenCalledWith( { id: 'act-1', details: error, traceInfo: traceInfoMock } );
+    expect( addEventErrorMock ).toHaveBeenCalledWith( { id: 'run-1:act-1:1', details: error, traceInfo: traceInfoMock } );
     expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_ERROR, {
       activityInfo: activityInfoMock,
       workflowDetails: workflowDetailsMock,
@@ -245,7 +279,7 @@ describe( 'ActivityExecutionInterceptor', () => {
     expect( mainEventBusEmitMock ).toHaveBeenCalledWith( BusEventType.ACTIVITY_START, expect.any( Object ) );
     expect( mainEventBusEmitMock ).toHaveBeenCalledTimes( 1 );
     expect( addEventEndMock ).toHaveBeenCalledWith( {
-      id: 'act-1',
+      id: 'run-1:act-1:1',
       details: ActivitySpecialOutput.ASYNC_HANDOFF,
       traceInfo: traceInfoMock
     } );

package/src/worker/sinks.js

@@ -65,7 +65,7 @@ export const sinks = {
   trace: {
     start: {
       fn: ( workflowInfo, { id, name, kind, details } ) =>
-        Tracing.addEventStart( { id, kind, name, details, parentId: workflowInfo.parent?.runId, traceInfo: workflowInfo.memo.traceInfo } ),
+        Tracing.addEventStart( { id, kind, name, details, parentId: workflowInfo.runId, traceInfo: workflowInfo.memo.traceInfo } ),
       callDuringReplay: false
     },
 

package/src/worker/sinks.spec.js

@@ -167,7 +167,7 @@ describe( 'worker/sinks', () => {
     expect( addEventErrorMock ).not.toHaveBeenCalled();
   } );
 
-  it( 'trace.start records trace start events with workflow parent context', async () => {
+  it( 'trace.start parents trace start events on the current workflow, not its parent workflow', async () => {
     const { sinks } = await import( './sinks.js' );
 
     sinks.trace.start.fn( workflowInfo, {
@@ -182,7 +182,7 @@ describe( 'worker/sinks', () => {
       kind: ComponentType.STEP,
       name: 'myStep',
       details: { input: true },
-      parentId: 'parent-run-1',
+      parentId: 'run-1',
       traceInfo: { traceId: 'trace-1' }
     } );
   } );