@output.ai/core 0.5.10 → 0.5.11-dev.pr421-1996c13

package/bin/healthcheck.spec.js

@@ -5,9 +5,9 @@ const connectionMock = { close: closeMock };
 
 const queryMock = vi.fn();
 const getHandleMock = vi.fn().mockReturnValue( { query: queryMock } );
-const ClientMock = vi.fn().mockImplementation( () => ( {
-  workflow: { getHandle: getHandleMock }
-} ) );
+const ClientMock = vi.fn().mockImplementation( function () {
+  return { workflow: { getHandle: getHandleMock } };
+} );
 const connectMock = vi.fn().mockResolvedValue( connectionMock );
 
 vi.mock( '@temporalio/client', () => ( {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.5.10",
+  "version": "0.5.11-dev.pr421-1996c13",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {
@@ -19,6 +19,10 @@
     "./hooks": {
       "types": "./src/hooks/index.d.ts",
       "import": "./src/hooks/index.js"
+    },
+    "./context": {
+      "types": "./src/context/index.d.ts",
+      "import": "./src/context/index.js"
     }
   },
   "files": [
@@ -31,21 +35,21 @@
     "output-healthcheck": "./bin/healthcheck.mjs"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "3.913.0",
-    "@babel/generator": "7.28.3",
-    "@babel/parser": "7.28.4",
-    "@babel/traverse": "7.28.4",
-    "@babel/types": "7.28.4",
-    "@temporalio/activity": "1.13.1",
-    "@temporalio/client": "1.13.1",
-    "@temporalio/common": "1.13.1",
-    "@temporalio/worker": "1.13.1",
-    "@temporalio/workflow": "1.13.1",
-    "redis": "5.8.3",
+    "@aws-sdk/client-s3": "3.1000.0",
+    "@babel/generator": "7.29.1",
+    "@babel/parser": "7.29.0",
+    "@babel/traverse": "7.29.0",
+    "@babel/types": "7.29.0",
+    "@temporalio/activity": "1.15.0",
+    "@temporalio/client": "1.15.0",
+    "@temporalio/common": "1.15.0",
+    "@temporalio/worker": "1.15.0",
+    "@temporalio/workflow": "1.15.0",
+    "redis": "5.11.0",
     "stacktrace-parser": "0.1.11",
-    "undici": "7.18.2",
-    "winston": "3.17.0",
-    "zod": "^4.3.6"
+    "undici": "7.22.0",
+    "winston": "3.19.0",
+    "zod": "4.3.6"
   },
   "license": "Apache-2.0",
   "publishConfig": {

package/src/context/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Context returned by {@link getContext} when running inside a Temporal Activity (step or evaluator).
+ */
+export type Context = {
+  /** Information about the current workflow execution */
+  workflow: {
+    /** Temporal's workflow execution id */
+    id: string;
+    /** Workflow name (Temporal's workflow "type" value) */
+    name: string;
+    /** Path of the workflow file */
+    filename: string;
+  }
+};
+
+/**
+ * Returns information about the current Temporal execution.
+ *
+ * Only available when called from within a step or evaluator (Temporal Activities) running in the Temporal runtime.
+ *
+ * @remarks
+ * - Returns `null` when not called inside a Temporal Activity (steps/evaluators);
+ * - Returns `null` when not called from within a running Temporal worker, like in unit tests environment;
+ *
+ * @returns The workflow context, or `null` if unavailable or incomplete.
+ */
+export declare function getContext(): Context | null;

package/src/context/index.js

@@ -0,0 +1,17 @@
+import { Storage } from '#async_storage';
+
+/**
+ * Returns information trapped on AsyncStorage about the workflow invoking an activity
+ *
+ * @returns {object}
+ */
+export const getContext = () => {
+  const ctx = Storage.load();
+
+  if ( !ctx?.executionContext || !ctx?.workflowFilename ) {
+    return null;
+  }
+
+  const { workflowId: id, workflowName: name } = ctx.executionContext;
+  return { workflow: { id, name, filename: ctx.workflowFilename } };
+};

package/src/context/index.spec.js

@@ -0,0 +1,42 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const loadMock = vi.fn();
+vi.mock( '#async_storage', () => ( {
+  Storage: { load: loadMock }
+} ) );
+
+describe( 'context/getContext', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    vi.resetModules();
+  } );
+
+  it( 'returns null when no context is stored', async () => {
+    loadMock.mockReturnValue( undefined );
+    const { getContext } = await import( './index.js' );
+    expect( getContext() ).toBeNull();
+  } );
+
+  it( 'returns null when executionContext is missing', async () => {
+    loadMock.mockReturnValue( { workflowFilename: '/workflows/foo.js' } );
+    const { getContext } = await import( './index.js' );
+    expect( getContext() ).toBeNull();
+  } );
+
+  it( 'returns null when workflowFilename is missing', async () => {
+    loadMock.mockReturnValue( { executionContext: { workflowId: 'wf-1', workflowName: 'myWorkflow' } } );
+    const { getContext } = await import( './index.js' );
+    expect( getContext() ).toBeNull();
+  } );
+
+  it( 'returns workflow context when storage has full context', async () => {
+    loadMock.mockReturnValue( {
+      executionContext: { workflowId: 'wf-1', workflowName: 'myWorkflow' },
+      workflowFilename: '/workflows/myWorkflow.js'
+    } );
+    const { getContext } = await import( './index.js' );
+    expect( getContext() ).toEqual( {
+      workflow: { id: 'wf-1', name: 'myWorkflow', filename: '/workflows/myWorkflow.js' }
+    } );
+  } );
+} );

package/src/worker/index.js

@@ -59,7 +59,7 @@ const callerDir = process.argv[2];
     workflowsPath,
     activities,
     sinks,
-    interceptors: initInterceptors( { activities } ),
+    interceptors: initInterceptors( { activities, workflows } ),
     maxConcurrentWorkflowTaskExecutions,
     maxConcurrentActivityTaskExecutions,
     maxCachedWorkflows,

package/src/worker/index.spec.js

@@ -112,7 +112,7 @@ describe( 'worker/index', () => {
       maxConcurrentActivityTaskPolls: configValues.maxConcurrentActivityTaskPolls,
       maxConcurrentWorkflowTaskPolls: configValues.maxConcurrentWorkflowTaskPolls
     } ) );
-    expect( initInterceptorsMock ).toHaveBeenCalledWith( { activities: {} } );
+    expect( initInterceptorsMock ).toHaveBeenCalledWith( { activities: {}, workflows: [] } );
     expect( registerShutdownMock ).toHaveBeenCalledWith( { worker: mockWorker, log: mockLog } );
     expect( startCatalogMock ).toHaveBeenCalledWith( {
       connection: mockConnection,
@@ -140,6 +140,7 @@ describe( 'worker/index', () => {
         apiKey: 'secret'
       } ) );
     } );
+    runState.resolve();
     await vi.waitFor( () => expect( exitMock ).toHaveBeenCalled() );
   } );
 

package/src/worker/interceptors/activity.js

@@ -25,8 +25,9 @@ const log = createChildLogger( 'Activity' );
   - Headers injected by the workflow interceptor (executionContext)
 */
 export class ActivityExecutionInterceptor {
-  constructor( activities ) {
+  constructor( { activities, workflows } ) {
     this.activities = activities;
+    this.workflowsMap = workflows.reduce( ( map, w ) => map.set( w.name, w ), new Map() );
   };
 
   async execute( input, next ) {
@@ -46,7 +47,12 @@ export class ActivityExecutionInterceptor {
       // Sends heartbeat to communicate that activity is still alive
       intervals.heartbeat = activityHeartbeatEnabled && setInterval( () => Context.current().heartbeat(), activityHeartbeatIntervalMs );
 
-      const output = await Storage.runWithContext( async _ => next( input ), { parentId: activityId, executionContext } );
+      // Wraps the execution with accessible metadata for the activity
+      const output = await Storage.runWithContext( async _ => next( input ), {
+        parentId: activityId,
+        executionContext,
+        workflowFilename: this.workflowsMap.get( workflowName ).path
+      } );
 
       log.info( `Ended ${activityType} ${kind}`, { event: LifecycleEvent.END, kind, ...logContext, durationMs: Date.now() - startDate } );
       addEventEnd( { details: output, ...traceArguments } );

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

@@ -3,10 +3,12 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 const METADATA_ACCESS_SYMBOL = vi.hoisted( () => Symbol( '__metadata' ) );
 
 const heartbeatMock = vi.fn();
+const runWithContextMock = vi.hoisted( () => vi.fn().mockImplementation( async fn => fn() ) );
 const contextInfoMock = {
   workflowExecution: { workflowId: 'wf-1' },
   activityId: 'act-1',
-  activityType: 'myWorkflow#myStep'
+  activityType: 'myWorkflow#myStep',
+  workflowType: 'myWorkflow'
 };
 
 vi.mock( '@temporalio/activity', () => ( {
@@ -20,7 +22,7 @@ vi.mock( '@temporalio/activity', () => ( {
 
 vi.mock( '#async_storage', () => ( {
   Storage: {
-    runWithContext: async fn => fn()
+    runWithContext: runWithContextMock
   }
 } ) );
 
@@ -59,6 +61,8 @@ const makeActivities = () => ( {
   'myWorkflow#myStep': { [METADATA_ACCESS_SYMBOL]: { type: 'step' } }
 } );
 
+const makeWorkflows = () => [ { name: 'myWorkflow', path: '/workflows/myWorkflow.js' } ];
+
 const makeInput = () => ( {
   args: [ { someInput: 'data' } ],
   headers: {}
@@ -81,7 +85,7 @@ describe( 'ActivityExecutionInterceptor', () => {
 
   it( 'records trace start and end events on successful execution', async () => {
     const { ActivityExecutionInterceptor } = await import( './activity.js' );
-    const interceptor = new ActivityExecutionInterceptor( makeActivities() );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
     const next = vi.fn().mockResolvedValue( { result: 'ok' } );
 
     const promise = interceptor.execute( makeInput(), next );
@@ -92,11 +96,19 @@ describe( 'ActivityExecutionInterceptor', () => {
     expect( addEventStartMock ).toHaveBeenCalledOnce();
     expect( addEventEndMock ).toHaveBeenCalledOnce();
     expect( addEventErrorMock ).not.toHaveBeenCalled();
+    expect( runWithContextMock ).toHaveBeenCalledWith(
+      expect.any( Function ),
+      {
+        parentId: 'act-1',
+        executionContext: { workflowId: 'wf-1' },
+        workflowFilename: '/workflows/myWorkflow.js'
+      }
+    );
   } );
 
   it( 'records trace error event on failed execution', async () => {
     const { ActivityExecutionInterceptor } = await import( './activity.js' );
-    const interceptor = new ActivityExecutionInterceptor( makeActivities() );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
     const error = new Error( 'step failed' );
     const next = vi.fn().mockRejectedValue( error );
 
@@ -111,7 +123,7 @@ describe( 'ActivityExecutionInterceptor', () => {
 
   it( 'sends periodic heartbeats during activity execution', async () => {
     const { ActivityExecutionInterceptor } = await import( './activity.js' );
-    const interceptor = new ActivityExecutionInterceptor( makeActivities() );
+    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 };
@@ -138,7 +150,7 @@ describe( 'ActivityExecutionInterceptor', () => {
 
   it( 'clears heartbeat interval after activity completes', async () => {
     const { ActivityExecutionInterceptor } = await import( './activity.js' );
-    const interceptor = new ActivityExecutionInterceptor( makeActivities() );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
     const next = vi.fn().mockResolvedValue( { result: 'ok' } );
 
     const promise = interceptor.execute( makeInput(), next );
@@ -152,7 +164,7 @@ describe( 'ActivityExecutionInterceptor', () => {
 
   it( 'clears heartbeat interval after activity fails', async () => {
     const { ActivityExecutionInterceptor } = await import( './activity.js' );
-    const interceptor = new ActivityExecutionInterceptor( makeActivities() );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
     const next = vi.fn().mockRejectedValue( new Error( 'boom' ) );
 
     const promise = interceptor.execute( makeInput(), next );
@@ -167,7 +179,7 @@ describe( 'ActivityExecutionInterceptor', () => {
   it( 'does not heartbeat when OUTPUT_ACTIVITY_HEARTBEAT_ENABLED is false', async () => {
     vi.stubEnv( 'OUTPUT_ACTIVITY_HEARTBEAT_ENABLED', 'false' );
     const { ActivityExecutionInterceptor } = await import( './activity.js' );
-    const interceptor = new ActivityExecutionInterceptor( makeActivities() );
+    const interceptor = new ActivityExecutionInterceptor( { activities: makeActivities(), workflows: makeWorkflows() } );
 
     const deferred = { resolve: null };
     const next = vi.fn().mockImplementation( () => new Promise( r => {

package/src/worker/interceptors.js

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

package/src/worker/start_catalog.spec.js

@@ -17,12 +17,14 @@ vi.mock( '@temporalio/client', async importOriginal => {
   const actual = await importOriginal();
   return {
     ...actual,
-    Client: vi.fn().mockImplementation( () => ( {
-      workflow: {
-        start: workflowStartMock,
-        getHandle: () => ( { describe: describeMock, executeUpdate: executeUpdateMock } )
-      }
-    } ) )
+    Client: vi.fn().mockImplementation( function () {
+      return {
+        workflow: {
+          start: workflowStartMock,
+          getHandle: () => ( { describe: describeMock, executeUpdate: executeUpdateMock } )
+        }
+      };
+    } )
   };
 } );