@output.ai/core 0.0.15 → 0.1.0

package/src/tracing/tracer_tree.js

@@ -0,0 +1,83 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { EOL } from 'os';
+
+/**
+ * @typedef {object} NodeEntry
+ * @property {string} id
+ * @property {string} kind
+ * @property {string} name
+ * @property {number} startedAt
+ * @property {number} endedAt
+ * @property {object} [input]
+ * @property {object} [output]
+ * @property {object} [error]
+ * @property {NodeTree[]} children
+ */
+/**
+ * Create a node entry for the tree.
+ *
+ * Properties are sorted the way they should be in the final file, as this makes it easier to read.
+ *
+ * @param {string} id - Node id
+ * @returns {NodeEntry} The entry without any values
+ */
+const createEntry = id => ( {
+  id,
+  kind: '',
+  name: '',
+  startedAt: 0,
+  endedAt: 0,
+  input: undefined,
+  output: undefined,
+  error: undefined,
+  children: []
+} );
+
+/**
+ * Build a tree of nodes from the raw trace file.
+ *
+ * Each node will have: id, name, kind, children, input, output or error, startedAt, endedAt.
+ *
+ * Entries with same id will be combined according to their phase (start, end OR error).
+ * - The details of the start phase becomes input, timestamp becomes startedAt;
+ * - The details of the end phase become output, timestamp becomes endedAt;
+ * - The details of the error phase become error, timestamp becomes endedAt;
+ * - Only start phase's kind and name are used;
+ *
+ *
+ * Children are added according to the parentId of each entry.
+ * The result tree has a single root: the only node without parentId, normally the workflow itself.
+ *
+ * @param {string} src - Full path to the raw log file (NDJSON)
+ * @returns {void}
+ */
+export const buildLogTree = src => {
+  const content = readFileSync( src, 'utf-8' );
+  const lines = content.split( EOL ).filter( l => l.trim().length > 0 );
+  const entries = lines.map( l => JSON.parse( l ) );
+
+  const nodes = new Map();
+  const ensureNode = id => nodes.get( id ) ?? nodes.set( id, createEntry( id ) ).get( id );
+
+  for ( const entry of entries ) {
+    const { kind, id, name, parentId, details, phase, timestamp } = entry;
+    const node = ensureNode( id );
+
+    if ( phase === 'start' ) {
+      Object.assign( node, { input: details, startedAt: timestamp, kind, name } );
+    } else if ( phase === 'end' ) {
+      Object.assign( node, { output: details, endedAt: timestamp } );
+    } else if ( phase === 'error' ) {
+      Object.assign( node, { error: details, endedAt: timestamp } );
+    }
+
+    if ( parentId && phase === 'start' ) {
+      const parent = ensureNode( parentId );
+      parent.children.push( node );
+      parent.children.sort( ( a, b ) => a.startedAt - b.startedAt );
+    }
+  }
+
+  const root = nodes.get( entries.find( e => !e.parentId ).id );
+  writeFileSync( src.replace( /\.raw$/, '.json' ), JSON.stringify( root, undefined, 2 ), 'utf-8' );
+};

package/src/tracing/tracer_tree.spec.js

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest';
+import { writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'path';
+import { EOL } from 'os';
+import { buildLogTree } from './tracer_tree.js';
+
+const createTempDir = () => mkdtempSync( join( tmpdir(), 'output-sdk-trace-tree-' ) );
+
+describe( 'tracer/tracer_tree', () => {
+  it( 'builds a tree from workflow/step/IO entries with grouping and sorting', () => {
+    const tmp = createTempDir();
+    const rawPath = join( tmp, 'run-123.raw' );
+
+    const entries = [
+      // workflow start
+      { kind: 'workflow', phase: 'start', name: 'wf', id: 'wf', parentId: undefined, details: { a: 1 }, timestamp: 1000 },
+      // evaluator start/stop
+      { kind: 'evaluator', phase: 'start', name: 'eval', id: 'eval', parentId: 'wf', details: { z: 0 }, timestamp: 1500 },
+      { kind: 'evaluator', phase: 'end', name: 'eval', id: 'eval', parentId: 'wf', details: { z: 1 }, timestamp: 1600 },
+      // step1 start
+      { kind: 'step', phase: 'start', name: 'step-1', id: 's1', parentId: 'wf', details: { x: 1 }, timestamp: 2000 },
+      // IO under step1
+      { kind: 'IO', phase: 'start', name: 'test-1', id: 'io1', parentId: 's1', details: { y: 2 }, timestamp: 2300 },
+      // step2 start
+      { kind: 'step', phase: 'start', name: 'step-2', id: 's2', parentId: 'wf', details: { x: 2 }, timestamp: 2400 },
+      // IO under step2
+      { kind: 'IO', phase: 'start', name: 'test-2', id: 'io2', parentId: 's2', details: { y: 3 }, timestamp: 2500 },
+      { kind: 'IO', phase: 'end', name: 'test-2', id: 'io2', parentId: 's2', details: { y: 4 }, timestamp: 2600 },
+      // IO under step1 ends
+      { kind: 'IO', phase: 'end', name: 'test-1', id: 'io1', parentId: 's1', details: { y: 5 }, timestamp: 2700 },
+      // step1 end
+      { kind: 'step', phase: 'end', name: 'step-1', id: 's1', parentId: 'wf', details: { done: true }, timestamp: 2800 },
+      // step2 end
+      { kind: 'step', phase: 'end', name: 'step-2', id: 's2', parentId: 'wf', details: { done: true }, timestamp: 2900 },
+      // workflow end
+      { kind: 'workflow', phase: 'end', name: 'wf', id: 'wf', parentId: undefined, details: { ok: true }, timestamp: 3000 }
+    ];
+
+    writeFileSync( rawPath, entries.map( e => JSON.stringify( e ) ).join( EOL ) + EOL, 'utf-8' );
+
+    buildLogTree( rawPath );
+
+    const jsonText = readFileSync( rawPath.replace( /.raw$/, '.json' ), 'utf-8' );
+
+    const expected = {
+      id: 'wf',
+      kind: 'workflow',
+      name: 'wf',
+      startedAt: 1000,
+      endedAt: 3000,
+      input: { a: 1 },
+      output: { ok: true },
+      children: [
+        {
+          id: 'eval',
+          kind: 'evaluator',
+          name: 'eval',
+          startedAt: 1500,
+          endedAt: 1600,
+          input: { z: 0 },
+          output: { z: 1 },
+          children: []
+        },
+        {
+          id: 's1',
+          kind: 'step',
+          name: 'step-1',
+          startedAt: 2000,
+          endedAt: 2800,
+          input: { x: 1 },
+          output: { done: true },
+          children: [
+            {
+              id: 'io1',
+              kind: 'IO',
+              name: 'test-1',
+              startedAt: 2300,
+              endedAt: 2700,
+              input: { y: 2 },
+              output: { y: 5 },
+              children: []
+            }
+          ]
+        },
+        {
+          id: 's2',
+          kind: 'step',
+          name: 'step-2',
+          startedAt: 2400,
+          endedAt: 2900,
+          input: { x: 2 },
+          output: { done: true },
+          children: [
+            {
+              id: 'io2',
+              kind: 'IO',
+              name: 'test-2',
+              startedAt: 2500,
+              endedAt: 2600,
+              input: { y: 3 },
+              output: { y: 4 },
+              children: []
+            }
+          ]
+        }
+      ]
+    };
+
+    expect( jsonText ).toBe( JSON.stringify( expected, undefined, 2 ) );
+
+    rmSync( tmp, { recursive: true, force: true } );
+  } );
+} );

package/src/tracing/utils.js

@@ -0,0 +1,21 @@
+/**
+ * @typedef {object} SerializedError
+ * @property {string} name - The error constructor name
+ * @property {string} message - The error message
+ * @property {string} stack - The error stack trace
+ */
+
+/**
+ * Serialize an error object.
+ *
+ * If it has ".cause", recursive serialize its cause until finally found an error without it.
+ *
+ * @param {Error} error
+ * @returns {SerializedError}
+ */
+export const serializeError = error =>
+  error.cause ? serializeError( error.cause ) : {
+    name: error.constructor.name,
+    message: error.message,
+    stack: error.stack
+  };

package/src/tracing/utils.spec.js

@@ -0,0 +1,14 @@
+import { describe, it, expect } 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 } );
+
+    const out = serializeError( outer );
+    expect( out.name ).toBe( 'Error' );
+    expect( out.message ).toBe( 'inner' );
+    expect( typeof out.stack ).toBe( 'string' );
+  } );
+} );

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/index.js

@@ -6,15 +6,11 @@ import { fileURLToPath } from 'node:url';
 import { worker as workerConfig } from '#configs';
 import { loadActivities, loadWorkflows, createWorkflowsEntryPoint } from './loader.js';
 import { ActivityExecutionInterceptor } from './interceptors/activity.js';
-import { setupGlobalTracer } from './tracer/index.js';
 import { sinks } from './sinks.js';
 import { createCatalog } from './catalog_workflow/index.js';
 
 const __dirname = dirname( fileURLToPath( import.meta.url ) );
 
-// expose the coreTracker so other parts of the SDK can use it
-setupGlobalTracer();
-
 const { address, apiKey, maxActivities, maxWorkflows, namespace, taskQueue, catalogId } = workerConfig;
 
 // Get caller directory from command line arguments
@@ -47,7 +43,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

@@ -1,8 +1,8 @@
 import { Context } from '@temporalio/activity';
-import { Storage } from '../async_storage.js';
-import { trace } from '../tracer/index.js';
+import { Storage } from '#async_storage';
+import { addEventStart, addEventEnd, addEventError } from '#tracing';
 import { headersToObject } from '../sandboxed_utils.js';
-import { THIS_LIB_NAME, TraceEvent } from '#consts';
+import { METADATA_ACCESS_SYMBOL } from '#consts';
 
 /*
   This interceptor is called for every activity execution
@@ -14,15 +14,33 @@ 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 context = { workflowId, workflowType, activityId, activityType, ...headersToObject( input.headers ) };
+    const { workflowExecution: { workflowId }, activityId, activityType } = Context.current().info;
+    const { traceId, traceHelm } = headersToObject( input.headers );
+    const { type: kind, skipTrace } = this.activities?.[activityType]?.[METADATA_ACCESS_SYMBOL];
+
+    const traceContext = { kind, id: activityId, parentId: workflowId, name: activityType, traceId, traceHelm };
+
+    if ( !skipTrace ) {
+      addEventStart( { details: input.args[0], ...traceContext } );
+    }
 
-    return Storage.runWithContext( async _ => {
-      trace( { lib: THIS_LIB_NAME, event: TraceEvent.STEP_START, input: input.args } );
-      const output = await next( input );
-      trace( { lib: THIS_LIB_NAME, event: TraceEvent.STEP_END, output } );
+    // creates a context for the nested tracing
+    try {
+      const output = await Storage.runWithContext( async _ => next( input ), { parentId: activityId, traceId, traceHelm } );
+      if ( !skipTrace ) {
+        addEventEnd( { details: output, ...traceContext } );
+      }
       return output;
-    }, context );
+    } catch ( error ) {
+      if ( !skipTrace ) {
+        addEventError( { details: error, ...traceContext } );
+      }
+      throw error;
+    }
   }
 };

package/src/worker/interceptors/workflow.js

@@ -1,5 +1,5 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
-import { workflowInfo } from '@temporalio/workflow';
+import { workflowInfo, proxySinks, ApplicationFailure } from '@temporalio/workflow';
 import { memoToHeaders } from '../sandboxed_utils.js';
 
 /*
@@ -18,6 +18,24 @@ class HeadersInjectionInterceptor {
   }
 };
 
+const sinks = proxySinks();
+
+class WorkflowExecutionInterceptor {
+  async execute( input, next ) {
+    sinks.trace.addWorkflowEventStart( input.args[0] );
+    try {
+      const output = await next( input );
+      // if the workflow is root, the result wraps "output" and "trace" onto an object, this will hide the trace
+      sinks.trace.addWorkflowEventEnd( !workflowInfo().memo.parentId ? output.output : output );
+      return output;
+    } catch ( error ) {
+      sinks.trace.addWorkflowEventError( error );
+      throw new ApplicationFailure( error.message, error.constructor.name );
+    }
+  }
+};
+
 export const interceptors = () => ( {
+  inbound: [ new WorkflowExecutionInterceptor() ],
   outbound: [ new HeadersInjectionInterceptor( workflowInfo().workflowType ) ]
 } );

package/src/worker/loader.js

@@ -1,7 +1,7 @@
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
-import { sendWebhookPost, readTraceFile } from '#internal_activities';
-import { SEND_WEBHOOK_ACTIVITY_NAME, WORKFLOWS_INDEX_FILENAME, READ_TRACE_FILE } from '#consts';
+import { sendWebhook, readTraceFile } from '#internal_activities';
+import { ACTIVITY_SEND_WEBHOOK, ACTIVITY_READ_TRACE_FILE, WORKFLOWS_INDEX_FILENAME } from '#consts';
 import {
   iteratorOverImportedComponents,
   recursiveNavigateWhileCollecting,
@@ -12,16 +12,16 @@ 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;
   }
 
   // system activities
-  activities[SEND_WEBHOOK_ACTIVITY_NAME] = sendWebhookPost;
-  activities[READ_TRACE_FILE] = readTraceFile;
+  activities[ACTIVITY_SEND_WEBHOOK] = sendWebhook;
+  activities[ACTIVITY_READ_TRACE_FILE] = readTraceFile;
   return activities;
 };
 

package/src/worker/loader.spec.js

@@ -1,18 +1,15 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
-const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
-
 vi.mock( '#consts', () => ( {
-  SEND_WEBHOOK_ACTIVITY_NAME: '__internal#sendWebhookPost',
-  READ_TRACE_FILE: '__internal#readTraceFile',
-  WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
-  METADATA_ACCESS_SYMBOL
+  ACTIVITY_SEND_WEBHOOK: '__internal#sendWebhook',
+  ACTIVITY_READ_TRACE_FILE: '__internal#readTraceFile',
+  WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js'
 } ) );
 
-const sendWebhookPostMock = vi.fn();
+const sendWebhookMock = vi.fn();
 const readTraceFileMock = vi.fn();
 vi.mock( '#internal_activities', () => ( {
-  sendWebhookPost: sendWebhookPostMock,
+  sendWebhook: sendWebhookMock,
   readTraceFile: readTraceFileMock
 } ) );
 
@@ -41,7 +38,7 @@ describe( 'worker/loader', () => {
 
     const activities = await loadActivities( '/root' );
     expect( activities['/a#Act1'] ).toBeTypeOf( 'function' );
-    expect( activities['__internal#sendWebhookPost'] ).toBe( sendWebhookPostMock );
+    expect( activities['__internal#sendWebhook'] ).toBe( sendWebhookMock );
     expect( activities['__internal#readTraceFile'] ).toBe( readTraceFileMock );
   } );
 

package/src/worker/sinks.js

@@ -1,16 +1,62 @@
-import { Storage } from './async_storage.js';
-import { trace } from './tracer/index.js';
-import { THIS_LIB_NAME } from '#consts';
+import { addEventStart, addEventEnd, addEventError } from '#tracing';
 
+/**
+ * Start a workflow trace event
+ *
+ * @param {function} method - Trace function to call
+ * @param {object} workflowInfo - Temporal workflowInfo object
+ * @param {object} details - Teh details to attach to the event
+ */
+const addWorkflowEvent = ( method, workflowInfo, details ) => {
+  const { workflowId: id, workflowType: name, memo: { parentId, traceId, traceHelm } } = workflowInfo;
+  method( { id, kind: 'workflow', name, details, parentId, traceId, traceHelm } );
+};
+
+/**
+ * Start a trace event with given configuration
+ *
+ * @param {function} method - Trace function to call
+ * @param {object} workflowInfo - Temporal workflowInfo object
+ * @param {object} options - Trace options, like id, kind, name and details
+ */
+const addEvent = ( method, workflowInfo, options ) => {
+  const { id, name, kind, details } = options;
+  const { workflowId, memo: { traceId, traceHelm } } = workflowInfo;
+  method( { id, kind, name, details, parentId: workflowId, traceId, traceHelm } );
+};
+
+// This sink allow for sandbox Temporal environment to send trace logs back to the main thread.
 export const sinks = {
-  // This sink allow for sandbox Temporal environment to send trace logs back to the main thread.
-  log: {
-    trace: {
-      fn( workflowInfo, args ) {
-        const { workflowId, workflowType, memo } = workflowInfo;
-        Storage.runWithContext( _ => trace( { lib: THIS_LIB_NAME, ...args } ), { workflowId, workflowType, ...memo } );
-      },
+  trace: {
+    addWorkflowEventStart: {
+      fn: ( ...args ) => addWorkflowEvent( addEventStart, ...args ),
+      callDuringReplay: false
+    },
+
+    addWorkflowEventEnd: {
+      fn: ( ...args ) => addWorkflowEvent( addEventEnd, ...args ),
+      callDuringReplay: false
+    },
+
+    addWorkflowEventError: {
+      fn: ( ...args ) => addWorkflowEvent( addEventError, ...args ),
       callDuringReplay: false
+    },
+
+    addEventStart: {
+      fn: ( ...args ) => addEvent( addEventStart, ...args ),
+      callDuringReplay: false
+    },
+
+    addEventEnd: {
+      fn: ( ...args ) => addEvent( addEventEnd, ...args ),
+      callDuringReplay: false
+    },
+
+    addEventError: {
+      fn: ( ...args ) => addEvent( addEventError, ...args ),
+      callDuringReplay: false
+
     }
   }
 };

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 };
 };