@outputai/core 0.6.1-next.fc6a93e.0 → 0.7.1-next.be9352c.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.6.1-next.fc6a93e.0",
+  "version": "0.7.1-next.be9352c.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/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 ) } ) );