@outputai/core 0.6.1-next.d3c9b1f.0 → 0.6.1-next.f8d698e.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.6.1-next.d3c9b1f.0",
+  "version": "0.6.1-next.f8d698e.0",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {
@@ -52,7 +52,7 @@
     "winston": "3.19.0"
   },
   "peerDependencies": {
-    "zod": "^4.3.6"
+    "zod": ">=4.3 <5"
   },
   "devDependencies": {
     "zod": "4.3.6"

package/src/interface/webhook.js

@@ -24,7 +24,7 @@ export async function sendHttpRequest( { url, method = 'GET', payload = undefine
       nonRetryableErrorTypes: [ FatalError.name ]
     }
   } )[ACTIVITY_SEND_HTTP_REQUEST]( { method, url, payload, headers } );
-  return res;
+  return res.output;
 };
 
 /**

package/src/interface/webhook.spec.js

@@ -10,6 +10,12 @@ vi.mock( './validations/static.js', () => ( {
   validateRequestPayload: validateRequestPayloadMock
 } ) );
 
+const activityEnvelope = output => ( {
+  __output_activity_wrapper_version: 1,
+  output,
+  aggregations: null
+} );
+
 // Minimal, legible mock of @temporalio/workflow APIs used by webhook.js
 const activityFnMock = vi.fn();
 const proxyActivitiesMock = vi.fn( () => ( { ['__internal#sendHttpRequest']: activityFnMock } ) );
@@ -70,7 +76,7 @@ describe( 'interface/webhook', () => {
       headers: { 'content-type': 'application/json' },
       body: { ok: true }
     };
-    activityFnMock.mockResolvedValueOnce( fakeSerializedResponse );
+    activityFnMock.mockResolvedValueOnce( activityEnvelope( fakeSerializedResponse ) );
 
     const args = { url: 'https://example.com/api', method: 'GET' };
     const res = await sendHttpRequest( args );
@@ -97,14 +103,14 @@ describe( 'interface/webhook', () => {
     const { sendPostRequestAndAwaitWebhook } = await import( './webhook.js' );
 
     // Make the inner activity resolve (through sendHttpRequest)
-    activityFnMock.mockResolvedValueOnce( {
+    activityFnMock.mockResolvedValueOnce( activityEnvelope( {
       url: 'https://webhook.site',
       status: 200,
       statusText: 'OK',
       ok: true,
       headers: {},
       body: null
-    } );
+    } ) );
 
     const url = 'https://webhook.site/ingest';
     const promise = sendPostRequestAndAwaitWebhook( { url, payload: { x: 1 }, headers: { a: 'b' } } );

package/src/internal_utils/errors.spec.js

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import { extractErrorDetail } from './errors.js';
+
+describe( 'extractErrorDetail', () => {
+  it( 'returns a matching value from error details', () => {
+    const error = new Error( 'failed' );
+    error.details = [
+      { requestId: 'req-1' },
+      { workflowId: 'workflow-1' }
+    ];
+
+    expect( extractErrorDetail( error, 'workflowId' ) ).toBe( 'workflow-1' );
+  } );
+
+  it( 'walks the cause chain until it finds matching details', () => {
+    const root = new Error( 'root' );
+    root.details = [ { traceId: 'trace-1' } ];
+    const wrapped = new Error( 'wrapped', { cause: root } );
+
+    expect( extractErrorDetail( wrapped, 'traceId' ) ).toBe( 'trace-1' );
+  } );
+
+  it( 'prefers details from the current error over causes', () => {
+    const root = new Error( 'root' );
+    root.details = [ { traceId: 'root-trace' } ];
+    const wrapped = new Error( 'wrapped', { cause: root } );
+    wrapped.details = [ { traceId: 'wrapped-trace' } ];
+
+    expect( extractErrorDetail( wrapped, 'traceId' ) ).toBe( 'wrapped-trace' );
+  } );
+
+  it( 'returns null when the key is not found', () => {
+    const root = new Error( 'root' );
+    root.details = [ { traceId: 'trace-1' } ];
+    const wrapped = new Error( 'wrapped', { cause: root } );
+
+    expect( extractErrorDetail( wrapped, 'missing' ) ).toBeNull();
+  } );
+
+  it( 'returns null for empty errors', () => {
+    expect( extractErrorDetail( null, 'traceId' ) ).toBeNull();
+  } );
+} );

package/src/tracing/tools/utils.js

@@ -1,3 +1,5 @@
+import { inspect } from 'node:util';
+
 /**
  * @typedef {object} SerializedError
  * @property {string} name - The error constructor name
@@ -6,16 +8,35 @@
  */
 
 /**
- * Serialize an error object.
+ * Recursively Serialize an error object. Navigate using "cause" property.
  *
- * If it has ".cause", recursive serialize its cause until finally found an error without it.
+ * Goes up 10 levels deep.
  *
  * @param {Error} error
  * @returns {SerializedError}
  */
-export const serializeError = error =>
-  error.cause ? serializeError( error.cause ) : {
-    name: error.constructor.name,
-    message: error.message,
-    stack: error.stack
+export const serializeError = ( () => {
+
+  const serializeValue = v => {
+    try {
+      return JSON.parse( JSON.stringify( v ) );
+    } catch {
+      return inspect( v, { depth: 5, breakLength: Infinity, colors: false } );
+    }
+  };
+
+  return ( error, depth = 0 ) => {
+    if ( depth > 10 ) {
+      return { name: 'Error', message: 'Cause chain too deep' };
+    }
+    if ( error instanceof Error ) {
+      return {
+        name: error.constructor.name,
+        message: error.message,
+        stack: error.stack,
+        ...( error.cause !== undefined ? { cause: serializeError( error.cause, depth + 1 ) } : {} )
+      };
+    }
+    return serializeValue( error );
   };
+} )();

package/src/tracing/tools/utils.spec.js

@@ -1,14 +1,83 @@
-import { describe, it, expect } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import { serializeError } from './utils.js';
 
-describe( 'tracing/utils', () => {
-  it( 'serializeError unwraps causes and keeps message/stack', () => {
-    const inner = new Error( 'inner' );
-    const outer = new Error( 'outer', { cause: inner } );
+describe( 'serializeError', () => {
+  it( 'serializes basic Error fields', () => {
+    const error = new Error( 'boom' );
 
-    const out = serializeError( outer );
-    expect( out.name ).toBe( 'Error' );
-    expect( out.message ).toBe( 'inner' );
-    expect( typeof out.stack ).toBe( 'string' );
+    const result = serializeError( error );
+
+    expect( result ).toMatchObject( {
+      name: 'Error',
+      message: 'boom'
+    } );
+    expect( typeof result.stack ).toBe( 'string' );
+    expect( result ).not.toHaveProperty( 'cause' );
+  } );
+
+  it( 'preserves custom error constructor names', () => {
+    class CustomError extends Error {}
+    const error = new CustomError( 'custom boom' );
+
+    expect( serializeError( error ) ).toMatchObject( {
+      name: 'CustomError',
+      message: 'custom boom'
+    } );
+  } );
+
+  it( 'recursively serializes Error causes', () => {
+    const root = new TypeError( 'root failure' );
+    const wrapped = new Error( 'wrapped failure', { cause: root } );
+
+    expect( serializeError( wrapped ) ).toMatchObject( {
+      name: 'Error',
+      message: 'wrapped failure',
+      cause: {
+        name: 'TypeError',
+        message: 'root failure'
+      }
+    } );
+  } );
+
+  it( 'preserves JSON-serializable non-Error causes', () => {
+    const cause = {
+      code: 'bad_input',
+      path: [ 'items', 0, 'title' ],
+      message: 'Expected title'
+    };
+    const error = new Error( 'validation failed', { cause } );
+
+    expect( serializeError( error ) ).toMatchObject( {
+      name: 'Error',
+      message: 'validation failed',
+      cause
+    } );
+  } );
+
+  it( 'falls back to inspect for non-JSON-serializable causes', () => {
+    const cause = { name: 'circular' };
+    cause.self = cause;
+    const error = new Error( 'failed', { cause } );
+
+    const result = serializeError( error );
+
+    expect( result.cause ).toContain( 'circular' );
+    expect( result.cause ).toContain( 'Circular' );
+  } );
+
+  it( 'falls back to inspect for primitive values JSON cannot serialize', () => {
+    expect( serializeError( 1n ) ).toBe( '1n' );
+  } );
+
+  it( 'stops serializing cause chains after the depth limit', () => {
+    const makeErrorChain = depth => depth === 0 ?
+      new Error( 'leaf' ) :
+      new Error( `level ${depth}`, { cause: makeErrorChain( depth - 1 ) } );
+    const getCauseAtDepth = ( error, depth ) => depth === 0 ?
+      error :
+      getCauseAtDepth( error.cause, depth - 1 );
+
+    expect( getCauseAtDepth( serializeError( makeErrorChain( 11 ) ), 11 ) )
+      .toEqual( { name: 'Error', message: 'Cause chain too deep' } );
   } );
 } );

package/src/worker/index.js

@@ -5,7 +5,7 @@ import { sinks } from './sinks.js';
 import { createCatalog } from './catalog_workflow/index.js';
 import { init as initTracing } from '#tracing';
 import { webpackConfigHook } from './bundler_options.js';
-import { initInterceptors } from './interceptors.js';
+import { initInterceptors } from './interceptors/index.js';
 import { createChildLogger } from '#logger';
 import { registerShutdown } from './shutdown.js';
 import { startCatalog } from './start_catalog.js';

package/src/worker/index.spec.js

@@ -51,7 +51,7 @@ vi.mock( './catalog_workflow/index.js', () => ( { createCatalog: createCatalogMo
 vi.mock( './bundler_options.js', () => ( { webpackConfigHook: vi.fn() } ) );
 
 const initInterceptorsMock = vi.fn().mockReturnValue( [] );
-vi.mock( './interceptors.js', () => ( { initInterceptors: initInterceptorsMock } ) );
+vi.mock( './interceptors/index.js', () => ( { initInterceptors: initInterceptorsMock } ) );
 
 const startCatalogMock = vi.fn().mockResolvedValue( undefined );
 vi.mock( './start_catalog.js', () => ( { startCatalog: startCatalogMock } ) );

package/src/worker/interceptors/activity.js

@@ -1,7 +1,7 @@
 import { Context, activityInfo as activityInfoFn } from '@temporalio/activity';
 import { Storage } from '#async_storage';
 import * as Tracing from '#tracing';
-import { headersToObject } from '../sandboxed_utils.js';
+import { headersToObject } from './headers.js';
 import { ACTIVITY_WRAPPER_VERSION_FIELD, BusEventType, METADATA_ACCESS_SYMBOL, Signal } from '#consts';
 import { activityHeartbeatEnabled, activityHeartbeatIntervalMs, namespace } from '../configs.js';
 import { messageBus } from '#bus';
@@ -29,37 +29,30 @@ const log = createChildLogger( 'ActivityInterceptor' );
 */
 export class ActivityExecutionInterceptor {
   constructor( { activities, workflows, connection } ) {
-    this.activities = activities;
-    this.workflowsMap = workflows.reduce( ( map, w ) => {
-      map.set( w.name, w );
-      for ( const alias of w.aliases ?? [] ) {
-        map.set( alias, w );
-      }
-      return map;
-    }, new Map() );
+    // convert activities{} object to a map: activityType:kind
+    this.activityKindMap = new Map( Object.entries( activities )
+      .map( ( [ type, fn ] ) => ( [ type, fn[METADATA_ACCESS_SYMBOL].type ] ) ) );
+
+    // convert workflows[] array to a map: workflowType/alias.n:path
+    this.workflowsPathMap = new Map( workflows.flatMap( ( { name, aliases, path } ) =>
+      [ name, ...aliases ?? [] ].map( a => ( [ a, path ] ) )
+    ) );
     this.connection = connection;
   };
 
-  /**
-   * Returns a workflow entry by its name or throws error
-   * @param {string} workflowType
-   * @returns {object} Workflow entry
-   * @throws {Error}
-   */
-  getWorkflowEntry( workflowType ) {
-    const workflowEntry = this.workflowsMap.get( workflowType );
-    if ( !workflowEntry ) {
-      throw new Error( `Activity interceptor: workflow "${workflowType}" not found in workflowsMap.` );
-    }
-    return workflowEntry;
-  }
-
   async execute( input, next ) {
     const activityInfo = activityInfoFn();
     const { workflowExecution: { workflowId, runId }, activityId, activityType, workflowType } = activityInfo;
     const { traceInfo, workflowDetails } = headersToObject( input.headers );
-    const { type: outputActivityKind } = this.activities?.[activityType]?.[METADATA_ACCESS_SYMBOL];
-    const { path: workflowFilename } = this.getWorkflowEntry( workflowType );
+    const outputActivityKind = this.activityKindMap.get( activityType );
+    const workflowFilename = this.workflowsPathMap.get( workflowType );
+
+    if ( !outputActivityKind ) {
+      throw new Error( `Activity interceptor: activity "${activityType}" was not registered.` );
+    }
+    if ( !workflowFilename ) {
+      throw new Error( `Activity interceptor: workflow "${workflowType}" was not registered.` );
+    }
 
     const state = {
       heartbeat: null,

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

@@ -73,7 +73,7 @@ vi.mock( '#tracing', () => ( {
   addEventError: addEventErrorMock
 } ) );
 
-vi.mock( '../sandboxed_utils.js', () => ( {
+vi.mock( './headers.js', () => ( {
   headersToObject: () => ( { traceInfo: traceInfoMock, workflowDetails: workflowDetailsMock } )
 } ) );
 

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

@@ -0,0 +1,73 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const toPayloadMock = vi.hoisted( () => vi.fn( value => ( { encoded: value } ) ) );
+const fromPayloadMock = vi.hoisted( () => vi.fn( payload => payload.encoded ) );
+
+vi.mock( '@temporalio/common', () => ( {
+  defaultPayloadConverter: {
+    toPayload: toPayloadMock,
+    fromPayload: fromPayloadMock
+  }
+} ) );
+
+describe( 'headers utils', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+  } );
+
+  describe( 'memoToHeaders', () => {
+    it( 'converts memo entries into Temporal payload headers', async () => {
+      const { memoToHeaders } = await import( './headers.js' );
+      const memo = {
+        traceInfo: { runId: 'run-1' },
+        workflowDetails: { workflowId: 'workflow-1' }
+      };
+
+      const headers = memoToHeaders( memo );
+
+      expect( headers ).toEqual( {
+        traceInfo: { encoded: memo.traceInfo },
+        workflowDetails: { encoded: memo.workflowDetails }
+      } );
+      expect( toPayloadMock ).toHaveBeenCalledTimes( 2 );
+      expect( toPayloadMock ).toHaveBeenCalledWith( memo.traceInfo );
+      expect( toPayloadMock ).toHaveBeenCalledWith( memo.workflowDetails );
+    } );
+
+    it( 'returns an empty object for nullish memo', async () => {
+      const { memoToHeaders } = await import( './headers.js' );
+
+      expect( memoToHeaders() ).toEqual( {} );
+      expect( memoToHeaders( null ) ).toEqual( {} );
+      expect( toPayloadMock ).not.toHaveBeenCalled();
+    } );
+  } );
+
+  describe( 'headersToObject', () => {
+    it( 'converts Temporal payload headers into plain object values', async () => {
+      const { headersToObject } = await import( './headers.js' );
+      const headers = {
+        traceInfo: { encoded: { runId: 'run-1' } },
+        workflowDetails: { encoded: { workflowId: 'workflow-1' } }
+      };
+
+      const object = headersToObject( headers );
+
+      expect( object ).toEqual( {
+        traceInfo: headers.traceInfo.encoded,
+        workflowDetails: headers.workflowDetails.encoded
+      } );
+      expect( fromPayloadMock ).toHaveBeenCalledTimes( 2 );
+      expect( fromPayloadMock ).toHaveBeenCalledWith( headers.traceInfo );
+      expect( fromPayloadMock ).toHaveBeenCalledWith( headers.workflowDetails );
+    } );
+
+    it( 'returns an empty object for nullish headers', async () => {
+      const { headersToObject } = await import( './headers.js' );
+
+      expect( headersToObject() ).toEqual( {} );
+      expect( headersToObject( null ) ).toEqual( {} );
+      expect( fromPayloadMock ).not.toHaveBeenCalled();
+    } );
+  } );
+} );

package/src/worker/{interceptors.js → interceptors/index.js}

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

package/src/worker/interceptors/workflow.js

@@ -1,6 +1,6 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
 import { workflowInfo, proxySinks, ApplicationFailure, ContinueAsNew, isCancellation } from '@temporalio/workflow';
-import { memoToHeaders } from '../sandboxed_utils.js';
+import { memoToHeaders } from './headers.js';
 import { deepMerge } from '#utils';
 import { METADATA_ACCESS_SYMBOL, WorkflowSpecialOutput } from '#consts';
 // this is a dynamic generated file with activity configs overwrites
@@ -8,13 +8,9 @@ import stepOptions from '../temp/__activity_options.js';
 import { createWorkflowDetails } from '#internal_utils/temporal_context';
 
 /*
-  This is not an AI comment!
-
-  This interceptor adds information value from workflowInfo().memo as Activity invocation headers.
-
+  This interceptor adds Memo and serialized workflowInfo() to the Activity invocation headers.
   This is a strategy to share values between the workflow context and activity context.
-
-  We also want to preserve existing headers that might have been inject somewhere else and
+  We also want to preserve existing headers that might have been inject somewhere else.
 */
 class HeadersInjectionInterceptor {
   async scheduleActivity( input, next ) {

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

@@ -61,7 +61,7 @@ vi.mock( '@temporalio/workflow', () => ( {
 } ) );
 
 const memoToHeadersMock = vi.fn( memo => ( memo ? { ...memo, __asHeaders: true } : {} ) );
-vi.mock( '../sandboxed_utils.js', () => ( { memoToHeaders: ( ...args ) => memoToHeadersMock( ...args ) } ) );
+vi.mock( './headers.js', () => ( { memoToHeaders: ( ...args ) => memoToHeadersMock( ...args ) } ) );
 
 const deepMergeMock = vi.fn( ( a, b ) => ( { ...( a || {} ), ...( b || {} ) } ) );
 vi.mock( '#utils', () => ( { deepMerge: ( ...args ) => deepMergeMock( ...args ) } ) );