@output.ai/core 0.0.14 → 0.0.16

package/src/internal_activities/index.js

@@ -1,6 +1,8 @@
 import { FatalError } from '#errors';
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { setMetadata } from '../interface/metadata.js';
+import { ComponentType } from '#consts';
 
 const callerDir = process.argv[2];
 
@@ -38,6 +40,8 @@ export const sendWebhookPost = async ( { url, workflowId, payload } ) => {
   }
 };
 
+setMetadata( sendWebhookPost, { type: ComponentType.INTERNAL_STEP } );
+
 /**
  * Read the trace file of a given execution and returns the content
  *
@@ -65,3 +69,5 @@ export const readTraceFile = async ( { workflowType, workflowId } ) => {
   const file = join( dir, matchingFile );
   return existsSync( file ) ? readFileSync( file, 'utf-8' ).split( '\n' ) : [];
 };
+
+setMetadata( readTraceFile, { type: ComponentType.INTERNAL_STEP, skipTrace: true } );

package/src/worker/catalog_workflow/catalog.js

@@ -73,6 +73,18 @@ class CatalogEntry {
   };
 }
 
+/**
+ * Describes a single activity within a workflow.
+ *
+ * @class
+ * @extends CatalogEntry
+ */
+export class CatalogActivity extends CatalogEntry {}
+
+/**
+ * @param { CatalogWorkflowOptions}
+ */
+
 /**
  * Describes a single workflow within the catalog.
  *
@@ -87,19 +99,16 @@ export class CatalogWorkflow extends CatalogEntry {
   activities;
 
   /**
-   * @inheritdoc
-   * @param {Array<CatalogActivity>} params.activities - Activities referenced by this workflow.
+   * @param {Object} params - Entry parameters.
+   * @param {string} params.name - Name of the entry.
+   * @param {string} [params.description] - Optional description.
+   * @param {object} [params.inputSchema] - JSON schema describing the expected input.
+   * @param {object} [params.outputSchema] - JSON schema describing the produced output.
+   * @param {string} params.path - Absolute path of the entity in the file system.
+   * @param {Array<CatalogActivity>} params.activities - Each activity of this workflow
    */
   constructor( { activities, ...args } ) {
     super( args );
     this.activities = activities;
   };
 };
-
-/**
- * Describes a single activity within a workflow.
- *
- * @class
- * @extends CatalogEntry
- */
-export class CatalogActivity extends CatalogEntry {}

package/src/worker/catalog_workflow/index.js

@@ -1,6 +1,26 @@
+import { z } from 'zod';
 import { METADATA_ACCESS_SYMBOL } from '#consts';
 import { Catalog, CatalogActivity, CatalogWorkflow } from './catalog.js';
 
+/**
+ * Converts a Zod schema to JSON Schema format.
+ *
+ * @param {any} schema - A zod schema
+ * @returns {object|null} JSON Schema object, or null if schema is invalid
+ */
+const convertToJsonSchema = schema => {
+  if ( !schema ) {
+    return null;
+  }
+
+  try {
+    return z.toJSONSchema( schema );
+  } catch ( error ) {
+    console.warn( 'Invalid schema provided (expected Zod schema):', schema, error );
+    return null;
+  }
+};
+
 /**
  * Converts the list of workflows and the activities into the catalog information.
  *
@@ -14,8 +34,17 @@ export const createCatalog = ( { workflows, activities } ) =>
   workflows.reduce( ( catalog, workflow ) =>
     catalog.addWorkflow( new CatalogWorkflow( {
       ...workflow,
+      inputSchema: convertToJsonSchema( workflow.inputSchema ),
+      outputSchema: convertToJsonSchema( workflow.outputSchema ),
       activities: Object.entries( activities )
         .filter( ( [ k ] ) => k.startsWith( `${workflow.path}#` ) )
-        .map( ( [ _, v ] ) => new CatalogActivity( v[METADATA_ACCESS_SYMBOL] ) )
+        .map( ( [ _, v ] ) => {
+          const metadata = v[METADATA_ACCESS_SYMBOL];
+          return new CatalogActivity( {
+            ...metadata,
+            inputSchema: convertToJsonSchema( metadata.inputSchema ),
+            outputSchema: convertToJsonSchema( metadata.outputSchema )
+          } );
+        } )
     } ) )
   , new Catalog() );

package/src/worker/catalog_workflow/index.spec.js

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
+import { z } from 'zod';
 
 // Provide the same symbol to the module under test and to the test
 const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
@@ -19,16 +20,16 @@ describe( 'createCatalog', () => {
         path: '/flows/flow1',
         pathname: '/flows/flow1/workflow.js',
         description: 'desc-flow1',
-        inputSchema: { in: 'f1' },
-        outputSchema: { out: 'f1' }
+        inputSchema: z.object( { in: z.literal( 'f1' ) } ),
+        outputSchema: z.object( { out: z.literal( 'f1' ) } )
       },
       {
         name: 'flow2',
         path: '/flows/flow2',
         pathname: '/flows/flow2/workflow.js',
         description: 'desc-flow2',
-        inputSchema: { in: 'f2' },
-        outputSchema: { out: 'f2' }
+        inputSchema: z.object( { in: z.literal( 'f2' ) } ),
+        outputSchema: z.object( { out: z.literal( 'f2' ) } )
       }
     ];
 
@@ -37,8 +38,8 @@ describe( 'createCatalog', () => {
       name: 'A1',
       path: '/flows/flow1#A1',
       description: 'desc-a1',
-      inputSchema: { in: 'a1' },
-      outputSchema: { out: 'a1' }
+      inputSchema: z.object( { in: z.literal( 'a1' ) } ),
+      outputSchema: z.object( { out: z.literal( 'a1' ) } )
     } );
 
     const activity2 = () => {};
@@ -46,8 +47,8 @@ describe( 'createCatalog', () => {
       name: 'A2',
       path: '/flows/flow1#A2',
       description: 'desc-a2',
-      inputSchema: { in: 'a2' },
-      outputSchema: { out: 'a2' }
+      inputSchema: z.object( { in: z.literal( 'a2' ) } ),
+      outputSchema: z.object( { out: z.literal( 'a2' ) } )
     } );
 
     const activity3 = () => {};
@@ -55,8 +56,8 @@ describe( 'createCatalog', () => {
       name: 'B1',
       path: '/flows/flow2#B1',
       description: 'desc-b1',
-      inputSchema: { in: 'b1' },
-      outputSchema: { out: 'b1' }
+      inputSchema: z.object( { in: z.literal( 'b1' ) } ),
+      outputSchema: z.object( { out: z.literal( 'b1' ) } )
     } );
 
     const activity4 = () => {};
@@ -64,8 +65,8 @@ describe( 'createCatalog', () => {
       name: 'X',
       path: '/other#X',
       description: 'desc-x',
-      inputSchema: { in: 'x' },
-      outputSchema: { out: 'x' }
+      inputSchema: z.object( { in: z.literal( 'x' ) } ),
+      outputSchema: z.object( { out: z.literal( 'x' ) } )
     } );
 
     const activities = {
@@ -96,20 +97,56 @@ describe( 'createCatalog', () => {
         name: 'flow1',
         path: '/flows/flow1',
         description: 'desc-flow1',
-        inputSchema: { in: 'f1' },
-        outputSchema: { out: 'f1' },
+        inputSchema: {
+          $schema: 'https://json-schema.org/draft/2020-12/schema',
+          type: 'object',
+          properties: { in: { type: 'string', const: 'f1' } },
+          required: [ 'in' ],
+          additionalProperties: false
+        },
+        outputSchema: {
+          $schema: 'https://json-schema.org/draft/2020-12/schema',
+          type: 'object',
+          properties: { out: { type: 'string', const: 'f1' } },
+          required: [ 'out' ],
+          additionalProperties: false
+        },
         activities: [
           {
             name: 'A1',
             description: 'desc-a1',
-            inputSchema: { in: 'a1' },
-            outputSchema: { out: 'a1' }
+            inputSchema: {
+              $schema: 'https://json-schema.org/draft/2020-12/schema',
+              type: 'object',
+              properties: { in: { type: 'string', const: 'a1' } },
+              required: [ 'in' ],
+              additionalProperties: false
+            },
+            outputSchema: {
+              $schema: 'https://json-schema.org/draft/2020-12/schema',
+              type: 'object',
+              properties: { out: { type: 'string', const: 'a1' } },
+              required: [ 'out' ],
+              additionalProperties: false
+            }
           },
           {
             name: 'A2',
             description: 'desc-a2',
-            inputSchema: { in: 'a2' },
-            outputSchema: { out: 'a2' }
+            inputSchema: {
+              $schema: 'https://json-schema.org/draft/2020-12/schema',
+              type: 'object',
+              properties: { in: { type: 'string', const: 'a2' } },
+              required: [ 'in' ],
+              additionalProperties: false
+            },
+            outputSchema: {
+              $schema: 'https://json-schema.org/draft/2020-12/schema',
+              type: 'object',
+              properties: { out: { type: 'string', const: 'a2' } },
+              required: [ 'out' ],
+              additionalProperties: false
+            }
           }
         ]
       },
@@ -117,14 +154,38 @@ describe( 'createCatalog', () => {
         name: 'flow2',
         path: '/flows/flow2',
         description: 'desc-flow2',
-        inputSchema: { in: 'f2' },
-        outputSchema: { out: 'f2' },
+        inputSchema: {
+          $schema: 'https://json-schema.org/draft/2020-12/schema',
+          type: 'object',
+          properties: { in: { type: 'string', const: 'f2' } },
+          required: [ 'in' ],
+          additionalProperties: false
+        },
+        outputSchema: {
+          $schema: 'https://json-schema.org/draft/2020-12/schema',
+          type: 'object',
+          properties: { out: { type: 'string', const: 'f2' } },
+          required: [ 'out' ],
+          additionalProperties: false
+        },
         activities: [
           {
             name: 'B1',
             description: 'desc-b1',
-            inputSchema: { in: 'b1' },
-            outputSchema: { out: 'b1' }
+            inputSchema: {
+              $schema: 'https://json-schema.org/draft/2020-12/schema',
+              type: 'object',
+              properties: { in: { type: 'string', const: 'b1' } },
+              required: [ 'in' ],
+              additionalProperties: false
+            },
+            outputSchema: {
+              $schema: 'https://json-schema.org/draft/2020-12/schema',
+              type: 'object',
+              properties: { out: { type: 'string', const: 'b1' } },
+              required: [ 'out' ],
+              additionalProperties: false
+            }
           }
         ]
       }

package/src/worker/index.js

@@ -47,7 +47,7 @@ const callerDir = process.argv[2];
     sinks,
     interceptors: {
       workflowModules: [ join( __dirname, './interceptors/workflow.js' ) ],
-      activityInbound: [ () => new ActivityExecutionInterceptor() ]
+      activityInbound: [ () => new ActivityExecutionInterceptor( activities ) ]
     },
     maxConcurrentWorkflowTaskExecutions: maxWorkflows,
     maxConcurrentActivityTaskExecutions: maxActivities,

package/src/worker/interceptors/activity.js

@@ -2,7 +2,8 @@ import { Context } from '@temporalio/activity';
 import { Storage } from '../async_storage.js';
 import { trace } from '../tracer/index.js';
 import { headersToObject } from '../sandboxed_utils.js';
-import { THIS_LIB_NAME, TraceEvent } from '#consts';
+import { THIS_LIB_NAME } from '#consts';
+import { METADATA_ACCESS_SYMBOL } from '#consts';
 
 /*
   This interceptor is called for every activity execution
@@ -14,14 +15,26 @@ import { THIS_LIB_NAME, TraceEvent } from '#consts';
   Some information it needs for its context comes from Temporal's Activity Context others are injected in the headers
 */
 export class ActivityExecutionInterceptor {
+  constructor( activities ) {
+    this.activities = activities;
+  };
+
   async execute( input, next ) {
     const { workflowExecution: { workflowId }, activityId, activityType, workflowType } = Context.current().info;
+
+    const activityFn = this.activities?.[activityType];
+    const { type: componentType, skipTrace } = activityFn?.[METADATA_ACCESS_SYMBOL];
+
     const context = { workflowId, workflowType, activityId, activityType, ...headersToObject( input.headers ) };
 
     return Storage.runWithContext( async _ => {
-      trace( { lib: THIS_LIB_NAME, event: TraceEvent.STEP_START, input: input.args } );
+      if ( !skipTrace ) {
+        trace( { lib: THIS_LIB_NAME, event: `${componentType}_start`, input: input.args } );
+      }
       const output = await next( input );
-      trace( { lib: THIS_LIB_NAME, event: TraceEvent.STEP_END, output } );
+      if ( !skipTrace ) {
+        trace( { lib: THIS_LIB_NAME, event: `${componentType}_end`, output } );
+      }
       return output;
     }, context );
   }

package/src/worker/loader.js

@@ -12,10 +12,10 @@ const __dirname = dirname( fileURLToPath( import.meta.url ) );
 
 // returns a map of activities, where the key is they path + name and the value is the function with metadata
 export async function loadActivities( path ) {
-  const activityPaths = recursiveNavigateWhileCollecting( path, [ 'steps.js' ] );
+  const activityPaths = recursiveNavigateWhileCollecting( path, [ 'steps.js', 'evaluators.js' ] );
   const activities = [];
   for await ( const { component, metadata, pathname, path } of iteratorOverImportedComponents( activityPaths ) ) {
-    console.log( '[Core.Scanner]', 'Activity loaded:', metadata.name, 'at', pathname );
+    console.log( '[Core.Scanner]', 'Component loaded:', metadata.type, metadata.name, 'at', pathname );
     activities[`${path}#${metadata.name}`] = component;
   }
 

package/src/worker/tracer/index.js

@@ -48,7 +48,7 @@ export function trace( { lib, event, input = undefined, output = undefined } ) {
     rootWorkflowType
   } = Storage.load();
 
-  const entry = { lib, event, input, output, timestamp: now, stepId, stepName, workflowId, workflowType, workflowPath, parentWorkflowId };
+  const entry = { event, input, lib, output, parentWorkflowId, stepId, stepName, timestamp: now, workflowId, workflowPath, workflowType };
 
   // test for rootWorkflow to append to the same file as the parent/grandparent
   const outputDir = join( callerDir, 'logs', 'runs', rootWorkflowType ?? workflowType );

package/src/worker/tracer/index.test.js

@@ -4,7 +4,7 @@ import { tmpdir, EOL } from 'node:os';
 import { join } from 'path';
 import { THIS_LIB_NAME } from '#consts';
 
-const createTempDir = () => mkdtempSync( join( tmpdir(), 'flow-sdk-trace-' ) );
+const createTempDir = () => mkdtempSync( join( tmpdir(), 'output-sdk-trace-' ) );
 
 // Single mocks (configured per-test by mutating the backing objects)
 const mockConfig = { tracing: { enabled: false } };
@@ -32,7 +32,6 @@ describe( 'tracer/index', () => {
     vi.clearAllMocks();
     vi.useFakeTimers();
     vi.setSystemTime( new Date( '2020-01-01T00:00:00.000Z' ) );
-
   } );
 
   afterEach( () => {

package/src/worker/tracer/tracer_tree.js

@@ -46,11 +46,12 @@ export const buildLogTree = src => {
     const { event, workflowId, workflowType, workflowPath, parentWorkflowId, stepId, stepName, input, output, timestamp } = entry;
 
     const baseEntry = { children: [], startedAt: timestamp, workflowId };
-    if ( event === TraceEvent.STEP_START ) {
-      stepsMap.set( `${workflowId}:${stepId}`, { event: 'step', input, stepId, stepName, ...baseEntry } );
+    if ( [ TraceEvent.EVALUATOR_START, TraceEvent.STEP_START ].includes( event ) ) {
+      const eventName = event === TraceEvent.EVALUATOR_START ? 'evaluator' : 'step';
+      stepsMap.set( `${workflowId}:${stepId}`, { event: eventName, input, stepId, stepName, ...baseEntry } );
     }
 
-    if ( event === TraceEvent.STEP_END ) {
+    if ( [ TraceEvent.EVALUATOR_END, TraceEvent.STEP_END ].includes( event ) ) {
       Object.assign( stepsMap.get( `${workflowId}:${stepId}` ) ?? {}, { output, endedAt: timestamp } );
     }
 

package/src/worker/tracer/tracer_tree.test.js

@@ -7,7 +7,7 @@ import { EOL } from 'os';
 import { buildLogTree } from './tracer_tree.js';
 import { THIS_LIB_NAME, TraceEvent } from '#consts';
 
-const createTempDir = () => mkdtempSync( join( tmpdir(), 'flow-sdk-trace-tree-' ) );
+const createTempDir = () => mkdtempSync( join( tmpdir(), 'output-sdk-trace-tree-' ) );
 
 describe( 'tracer/tracer_tree', () => {
   it( 'builds a tree JSON from a raw log file', () => {

package/src/worker/webpack_loaders/workflow_rewriter/collect_target_imports.js

@@ -2,9 +2,11 @@ import traverseModule from '@babel/traverse';
 import {
   buildWorkflowNameMap,
   getLocalNameFromDestructuredProperty,
+  isEvaluatorsPath,
   isStepsPath,
   isWorkflowPath,
   buildStepsNameMap,
+  buildEvaluatorsNameMap,
   toAbsolutePath
 } from './tools.js';
 import {
@@ -34,15 +36,16 @@ const traverse = traverseModule.default ?? traverseModule;
  * @returns {{ stepImports: Array<{localName:string,stepName:string}>,
  *  flowImports: Array<{localName:string,workflowName:string}> }} Collected info mappings.
  */
-export default function collectTargetImports( ast, fileDir, { stepsNameCache, workflowNameCache } ) {
+export default function collectTargetImports( ast, fileDir, { stepsNameCache, workflowNameCache, evaluatorsNameCache } ) {
   const stepImports = [];
   const flowImports = [];
+  const evaluatorImports = [];
 
   traverse( ast, {
     ImportDeclaration: path => {
       const src = path.node.source.value;
       // Ignore other imports
-      if ( !isStepsPath( src ) && !isWorkflowPath( src ) ) {
+      if ( !isStepsPath( src ) && !isWorkflowPath( src ) && !isEvaluatorsPath( src ) ) {
         return;
       }
 
@@ -58,6 +61,17 @@ export default function collectTargetImports( ast, fileDir, { stepsNameCache, wo
           }
         }
       }
+      if ( isEvaluatorsPath( src ) ) {
+        const nameMap = buildEvaluatorsNameMap( absolutePath, evaluatorsNameCache );
+        for ( const s of path.node.specifiers.filter( s => isImportSpecifier( s ) ) ) {
+          const importedName = s.imported.name;
+          const localName = s.local.name;
+          const evaluatorName = nameMap.get( importedName );
+          if ( evaluatorName ) {
+            evaluatorImports.push( { localName, evaluatorName } );
+          }
+        }
+      }
       if ( isWorkflowPath( src ) ) {
         const { named, default: defName } = buildWorkflowNameMap( absolutePath, workflowNameCache );
         for ( const s of path.node.specifiers ) {
@@ -94,7 +108,7 @@ export default function collectTargetImports( ast, fileDir, { stepsNameCache, wo
 
       const req = firstArgument.value;
       // Must be steps/workflows module
-      if ( !isStepsPath( req ) && !isWorkflowPath( req ) ) {
+      if ( !isStepsPath( req ) && !isWorkflowPath( req ) && !isEvaluatorsPath( req ) ) {
         return;
       }
 
@@ -116,6 +130,23 @@ export default function collectTargetImports( ast, fileDir, { stepsNameCache, wo
         } else {
           path.remove();
         }
+      } else if ( isEvaluatorsPath( req ) && isObjectPattern( path.node.id ) ) {
+        const nameMap = buildEvaluatorsNameMap( absolutePath, evaluatorsNameCache );
+        for ( const prop of path.node.id.properties.filter( prop => isObjectProperty( prop ) && isIdentifier( prop.key ) ) ) {
+          const importedName = prop.key.name;
+          const localName = getLocalNameFromDestructuredProperty( prop );
+          if ( localName ) {
+            const evaluatorName = nameMap.get( importedName );
+            if ( evaluatorName ) {
+              evaluatorImports.push( { localName, evaluatorName } );
+            }
+          }
+        }
+        if ( isVariableDeclaration( path.parent ) && path.parent.declarations.length === 1 ) {
+          path.parentPath.remove();
+        } else {
+          path.remove();
+        }
       } else if ( isWorkflowPath( req ) && isIdentifier( path.node.id ) ) {
         const { default: defName } = buildWorkflowNameMap( absolutePath, workflowNameCache );
         const localName = path.node.id.name;
@@ -129,5 +160,5 @@ export default function collectTargetImports( ast, fileDir, { stepsNameCache, wo
     }
   } );
 
-  return { stepImports, flowImports };
+  return { stepImports, evaluatorImports, flowImports };
 };

package/src/worker/webpack_loaders/workflow_rewriter/collect_target_imports.spec.js

@@ -16,6 +16,9 @@ describe( 'collect_target_imports', () => {
       'export const StepA = step({ name: "step.a" })',
       'export const StepB = step({ name: "step.b" })'
     ].join( '\n' ) );
+    writeFileSync( join( dir, 'evaluators.js' ), [
+      'export const EvalA = evaluator({ name: "eval.a" })'
+    ].join( '\n' ) );
     writeFileSync( join( dir, 'workflow.js' ), [
       'export const FlowA = workflow({ name: "flow.a" })',
       'export default workflow({ name: "flow.def" })'
@@ -23,16 +26,18 @@ describe( 'collect_target_imports', () => {
 
     const source = [
       'import { StepA } from "./steps.js";',
+      'import { EvalA } from "./evaluators.js";',
       'import WF, { FlowA } from "./workflow.js";',
       'const x = 1;'
     ].join( '\n' );
 
     const ast = makeAst( source, join( dir, 'file.js' ) );
-    const { stepImports, flowImports } = collectTargetImports(
+    const { stepImports, evaluatorImports, flowImports } = collectTargetImports(
       ast,
       dir,
-      { stepsNameCache: new Map(), workflowNameCache: new Map() }
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
     );
+    expect( evaluatorImports ).toEqual( [ { localName: 'EvalA', evaluatorName: 'eval.a' } ] );
 
     expect( stepImports ).toEqual( [ { localName: 'StepA', stepName: 'step.a' } ] );
     expect( flowImports ).toEqual( [
@@ -48,20 +53,23 @@ describe( 'collect_target_imports', () => {
   it( 'collects CJS requires and removes declarators (steps + default workflow)', () => {
     const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-' ) );
     writeFileSync( join( dir, 'steps.js' ), 'export const StepB = step({ name: "step.b" })\n' );
+    writeFileSync( join( dir, 'evaluators.js' ), 'export const EvalB = evaluator({ name: "eval.b" })\n' );
     writeFileSync( join( dir, 'workflow.js' ), 'export default workflow({ name: "flow.c" })\n' );
 
     const source = [
       'const { StepB } = require("./steps.js");',
+      'const { EvalB } = require("./evaluators.js");',
       'const WF = require("./workflow.js");',
       'const obj = {};'
     ].join( '\n' );
 
     const ast = makeAst( source, join( dir, 'file.js' ) );
-    const { stepImports, flowImports } = collectTargetImports(
+    const { stepImports, evaluatorImports, flowImports } = collectTargetImports(
       ast,
       dir,
-      { stepsNameCache: new Map(), workflowNameCache: new Map() }
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
     );
+    expect( evaluatorImports ).toEqual( [ { localName: 'EvalB', evaluatorName: 'eval.b' } ] );
 
     expect( stepImports ).toEqual( [ { localName: 'StepB', stepName: 'step.b' } ] );
     expect( flowImports ).toEqual( [ { localName: 'WF', workflowName: 'flow.c' } ] );

package/src/worker/webpack_loaders/workflow_rewriter/index.mjs

@@ -10,6 +10,7 @@ const generate = generatorModule.default ?? generatorModule;
 
 // Caches to avoid re-reading files during a build
 const stepsNameCache = new Map(); // path -> Map<exported, stepName>
+const evaluatorsNameCache = new Map(); // path -> Map<exported, evaluatorName>
 const workflowNameCache = new Map(); // path -> { default?: name, named: Map<exported, flowName> }
 
 /**
@@ -25,20 +26,20 @@ const workflowNameCache = new Map(); // path -> { default?: name, named: Map<exp
 export default function stepImportRewriterAstLoader( source, inputMap ) {
   this.cacheable?.( true );
   const callback = this.async?.() ?? this.callback;
-  const cache = { stepsNameCache, workflowNameCache };
+  const cache = { stepsNameCache, evaluatorsNameCache, workflowNameCache };
 
   try {
     const filename = this.resourcePath;
     const ast = parse( String( source ), filename );
     const fileDir = dirname( filename );
-    const { stepImports, flowImports } = collectTargetImports( ast, fileDir, cache );
+    const { stepImports, evaluatorImports, flowImports } = collectTargetImports( ast, fileDir, cache );
 
     // No imports
-    if ( stepImports.length + flowImports.length === 0 ) {
+    if ( [].concat( stepImports, evaluatorImports, flowImports ).length === 0 ) {
       return callback( null, source, inputMap );
     }
 
-    const rewrote = rewriteFnBodies( ast, stepImports, flowImports );
+    const rewrote = rewriteFnBodies( { ast, stepImports, evaluatorImports, flowImports } );
     // No edits performed
     if ( !rewrote ) {
       return callback( null, source, inputMap );

package/src/worker/webpack_loaders/workflow_rewriter/rewrite_fn_bodies.js

@@ -15,12 +15,14 @@ const traverse = traverseModule.default ?? traverseModule;
  * `this.invokeStep('name', ...)` and `FlowY(...)` with
  * `this.startWorkflow('name', ...)`.
  *
- * @param {import('@babel/types').File} ast - Parsed file AST.
- * @param {Array<{localName:string,stepName:string}>} stepImports - Step imports.
- * @param {Array<{localName:string,workflowName:string}>} flowImports - Workflow imports.
+ * @param {object} params
+ * @param {import('@babel/types').File} params.ast - Parsed file AST.
+ * @param {Array<{localName:string,stepName:string}>} params.stepImports - Step imports.
+ * @param {Array<{localName:string,evaluatorName:string}>} params.evaluatorImports - Evaluator imports.
+ * @param {Array<{localName:string,workflowName:string}>} params.flowImports - Workflow imports.
  * @returns {boolean} True if the AST was modified; false otherwise.
  */
-export default function rewriteFnBodies( ast, stepImports, flowImports ) {
+export default function rewriteFnBodies( { ast, stepImports, evaluatorImports, flowImports } ) {
   const state = { rewrote: false };
   traverse( ast, {
     ObjectProperty: path => {
@@ -56,6 +58,13 @@ export default function rewriteFnBodies( ast, stepImports, flowImports ) {
             state.rewrote = true;
             return; // Stop after rewriting as step call
           }
+          const evaluator = evaluatorImports.find( x => x.localName === callee.name );
+          if ( evaluator ) {
+            const args = cPath.node.arguments;
+            cPath.replaceWith( createThisMethodCall( 'invokeEvaluator', evaluator.evaluatorName, args ) );
+            state.rewrote = true;
+            return; // Stop after rewriting as evaluator call
+          }
           const flow = flowImports.find( x => x.localName === callee.name );
           if ( flow ) {
             const args = cPath.node.arguments;

package/src/worker/webpack_loaders/workflow_rewriter/rewrite_fn_bodies.spec.js

@@ -16,17 +16,31 @@ describe( 'rewrite_fn_bodies', () => {
     const stepImports = [ { localName: 'StepA', stepName: 'step.a' } ];
     const flowImports = [ { localName: 'FlowB', workflowName: 'flow.b' } ];
 
-    const rewrote = rewriteFnBodies( ast, stepImports, flowImports );
+    const rewrote = rewriteFnBodies( { ast, stepImports, evaluatorImports: [], flowImports } );
     expect( rewrote ).toBe( true );
 
     const code = ast.program.body.map( n => n.type ).length; // smoke: ast mutated
     expect( code ).toBeGreaterThan( 0 );
   } );
 
+  it( 'rewrites evaluator calls to this.invokeEvaluator', () => {
+    const src = [
+      'const obj = {',
+      '  fn: async (x) => {',
+      '    EvalA(3);',
+      '  }',
+      '}'
+    ].join( '\n' );
+    const ast = parse( src, 'file.js' );
+    const evaluatorImports = [ { localName: 'EvalA', evaluatorName: 'eval.a' } ];
+    const rewrote = rewriteFnBodies( { ast, stepImports: [], evaluatorImports, flowImports: [] } );
+    expect( rewrote ).toBe( true );
+  } );
+
   it( 'does nothing when no matching calls are present', () => {
     const src = [ 'const obj = { fn: function() { other(); } }' ].join( '\n' );
     const ast = parse( src, 'file.js' );
-    const rewrote = rewriteFnBodies( ast, [], [] );
+    const rewrote = rewriteFnBodies( { ast, stepImports: [], evaluatorImports: [], flowImports: [] } );
     expect( rewrote ).toBe( false );
   } );
 } );