@output.ai/core 0.0.15 → 0.1.0

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

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

@@ -106,6 +106,13 @@ export const toFunctionExpression = arrow => {
  */
 export const isStepsPath = value => /(^|\/)steps\.js$/.test( value );
 
+/**
+ * Check if a module specifier or request string points to evaluators.js.
+ * @param {string} value - Module path or request string.
+ * @returns {boolean} True if it matches evaluators.js.
+ */
+export const isEvaluatorsPath = value => /(^|\/)evaluators\.js$/.test( value );
+
 /**
  * Check if a module specifier or request string points to workflow.js.
  * @param {string} value - Module path or request string.
@@ -165,14 +172,18 @@ export const resolveNameFromOptions = ( optionsNode, consts, errorMessagePrefix
 };
 
 /**
- * Build a map from exported step variable name to declared step name.
- * Parses the steps module and extracts `step({ name: '...' })` names.
- * @param {string} path - Absolute path to the steps module file.
- * @param {Map<string, Map<string,string>>} cache - Cache of computed step name maps.
- * @returns {Map<string,string>} Exported identifier -> step name.
- * @throws {Error} When a step name is invalid (non-static or missing).
+ * Build a map of exported component identifiers to declared names by scanning a module.
+ * Coerces only static, analyzable forms: `export const X = callee({ name: '...' })`.
+ *
+ * @param {object} params
+ * @param {string} params.path - Absolute path to the module file.
+ * @param {Map<string, Map<string,string>>} params.cache - Cache for memoizing results by file path.
+ * @param {('step'|'evaluator')} params.calleeName - Factory function identifier to match.
+ * @param {string} params.invalidMessagePrefix - Prefix used in thrown errors when name is invalid.
+ * @returns {Map<string,string>} Map of `exportedIdentifier` -> `declaredName`.
+ * @throws {Error} When names are missing, dynamic, or otherwise non-static.
  */
-export const buildStepsNameMap = ( path, cache ) => {
+const buildComponentNameMap = ( { path, cache, calleeName, invalidMessagePrefix } ) => {
   if ( cache.has( path ) ) {
     return cache.get( path );
   }
@@ -180,24 +191,46 @@ export const buildStepsNameMap = ( path, cache ) => {
   const ast = parse( text, path );
   const consts = extractTopLevelStringConsts( ast );
 
-  const stepMap = ast.program.body
+  const result = ast.program.body
     .filter( node => isExportNamedDeclaration( node ) && isVariableDeclaration( node.declaration ) )
     .reduce( ( map, node ) => {
-
       node.declaration.declarations
-        .filter( dec => isIdentifier( dec.id ) && isCallExpression( dec.init ) && isIdentifier( dec.init.callee, { name: 'step' } ) )
+        .filter( dec => isIdentifier( dec.id ) && isCallExpression( dec.init ) && isIdentifier( dec.init.callee, { name: calleeName } ) )
         .map( dec => [
           dec,
-          resolveNameFromOptions( dec.init.arguments[0], consts, `Invalid step name in ${path} for "${dec.id.name}"` )
+          resolveNameFromOptions( dec.init.arguments[0], consts, `${invalidMessagePrefix} ${path} for "${dec.id.name}"` )
         ] )
         .forEach( ( [ dec, name ] ) => map.set( dec.id.name, name ) );
       return map;
     }, new Map() );
 
-  cache.set( path, stepMap );
-  return stepMap;
+  cache.set( path, result );
+  return result;
 };
 
+export const buildStepsNameMap = ( path, cache ) => buildComponentNameMap( {
+  path,
+  cache,
+  calleeName: 'step',
+  invalidMessagePrefix: 'Invalid step name in'
+} );
+
+/**
+ * Build a map from exported evaluator identifier to declared evaluator name.
+ * Parses `evaluators.js` for `export const X = evaluator({ name: '...' })`.
+ *
+ * @param {string} path - Absolute path to the evaluators module file.
+ * @param {Map<string, Map<string,string>>} cache - Cache of computed evaluator name maps.
+ * @returns {Map<string,string>} Exported identifier -> evaluator name.
+ * @throws {Error} When a evaluator name is invalid (non-static or missing).
+ */
+export const buildEvaluatorsNameMap = ( path, cache ) => buildComponentNameMap( {
+  path,
+  cache,
+  calleeName: 'evaluator',
+  invalidMessagePrefix: 'Invalid evaluator name in'
+} );
+
 /**
  * Build a structure with default and named workflow names from a workflow module.
  * Extracts names from `workflow({ name: '...' })` calls.

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

@@ -15,7 +15,8 @@ import {
   createThisMethodCall,
   resolveNameFromOptions,
   buildStepsNameMap,
-  buildWorkflowNameMap
+  buildWorkflowNameMap,
+  buildEvaluatorsNameMap
 } from './tools.js';
 
 describe( 'workflow_rewriter tools', () => {
@@ -72,6 +73,23 @@ describe( 'workflow_rewriter tools', () => {
     rmSync( dir, { recursive: true, force: true } );
   } );
 
+  it( 'buildEvaluatorsNameMap: reads names from evaluators module and caches result', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'tools-evals-' ) );
+    const evalsPath = join( dir, 'evaluators.js' );
+    writeFileSync( evalsPath, [
+      'export const EvalA = evaluator({ name: "eval.a" })',
+      'export const EvalB = evaluator({ name: "eval.b" })'
+    ].join( '\n' ) );
+    const cache = new Map();
+    const map1 = buildEvaluatorsNameMap( evalsPath, cache );
+    expect( map1.get( 'EvalA' ) ).toBe( 'eval.a' );
+    expect( map1.get( 'EvalB' ) ).toBe( 'eval.b' );
+    expect( cache.get( evalsPath ) ).toBe( map1 );
+    const map2 = buildEvaluatorsNameMap( evalsPath, cache );
+    expect( map2 ).toBe( map1 );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
   it( 'getLocalNameFromDestructuredProperty: handles { a }, { a: b }, { a: b = 1 }', () => {
     // { a }
     const p1 = t.objectProperty( t.identifier( 'a' ), t.identifier( 'a' ), false, true );
@@ -88,7 +106,7 @@ describe( 'workflow_rewriter tools', () => {
   } );
 
   it( 'buildWorkflowNameMap: reads named and default workflow names and caches', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'tools-flow-' ) );
+    const dir = mkdtempSync( join( tmpdir(), 'tools-output-' ) );
     const wfPath = join( dir, 'workflow.js' );
     writeFileSync( wfPath, [
       'export const FlowA = workflow({ name: "flow.a" })',

package/src/worker/tracer/index.js

@@ -1,75 +0,0 @@
-import { Storage } from '../async_storage.js';
-import { mkdirSync, existsSync, readdirSync, appendFileSync } from 'node:fs';
-import { join } from 'path';
-import { EOL } from 'os';
-import { buildLogTree } from './tracer_tree.js';
-import { tracing as tracingConfig } from '#configs';
-
-const callerDir = process.argv[2];
-
-/**
- * Appends new information to a file
- *
- * Information has to be a JSON
- *
- * File is encoded in utf-8
- *
- * @param {string} path - The full filename
- * @param {object} json - The content
- */
-const flushEntry = ( path, json ) => appendFileSync( path, JSON.stringify( json ) + EOL, 'utf-8' );
-
-/**
- * Add an event to the execution trace file.
- *
- * Events normally are the result of an operation, either a function call or an IO.
- *
- * @param {object} options
- * @param {string} options.lib - The macro part of the platform that triggered the event
- * @param {string} options.event - The name of the event
- * @param {any} [options.input] - The input of the operation
- * @param {any} [options.output] - The output of the operation
- */
-export function trace( { lib, event, input = undefined, output = undefined } ) {
-  const now = Date.now();
-
-  if ( !tracingConfig.enabled ) {
-    return;
-  }
-
-  const {
-    activityId: stepId,
-    activityType: stepName,
-    workflowId,
-    workflowType,
-    workflowPath,
-    parentWorkflowId,
-    rootWorkflowId,
-    rootWorkflowType
-  } = Storage.load();
-
-  const entry = { lib, event, input, output, timestamp: now, stepId, stepName, workflowId, workflowType, workflowPath, parentWorkflowId };
-
-  // test for rootWorkflow to append to the same file as the parent/grandparent
-  const outputDir = join( callerDir, 'logs', 'runs', rootWorkflowType ?? workflowType );
-  if ( !existsSync( outputDir ) ) {
-    mkdirSync( outputDir, { recursive: true } );
-  }
-
-  const suffix = `-${rootWorkflowId ?? workflowId}.raw`;
-  const logFile = readdirSync( outputDir ).find( f => f.endsWith( suffix ) ) ?? `${new Date( now ).toISOString()}-${suffix}`;
-  const logPath = join( outputDir, logFile );
-
-  flushEntry( logPath, entry );
-  buildLogTree( logPath );
-};
-
-/**
- * Setup the global tracer function, so it is available to be used by other libraries
- *
- * It will be situated in the global object, under Symbol.for('__trace')
- *
- * @returns {object} The assigned globalThis
- */
-export const setupGlobalTracer = () =>
-  Object.defineProperty( globalThis, Symbol.for( '__trace' ), { value: trace, writable: false, enumerable: false, configurable: false } );

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

@@ -1,103 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
-import { tmpdir, EOL } from 'node:os';
-import { join } from 'path';
-import { THIS_LIB_NAME } from '#consts';
-
-const createTempDir = () => mkdtempSync( join( tmpdir(), 'flow-sdk-trace-' ) );
-
-// Single mocks (configured per-test by mutating the backing objects)
-const mockConfig = { tracing: { enabled: false } };
-vi.mock( '#configs', () => mockConfig );
-
-const mockStorageData = {
-  activityId: 's1',
-  activityType: 'Step 1',
-  workflowId: 'wf1',
-  workflowType: 'prompt',
-  workflowPath: '/workflows/prompt.js',
-  parentWorkflowId: undefined,
-  rootWorkflowId: undefined,
-  rootWorkflowType: undefined
-};
-vi.mock( '../async_storage.js', () => ( {
-  Storage: { load: () => mockStorageData }
-} ) );
-
-vi.mock( './tracer_tree.js', () => ( { buildLogTree: vi.fn() } ) );
-
-describe( 'tracer/index', () => {
-  beforeEach( () => {
-    vi.resetModules();
-    vi.clearAllMocks();
-    vi.useFakeTimers();
-    vi.setSystemTime( new Date( '2020-01-01T00:00:00.000Z' ) );
-
-  } );
-
-  afterEach( () => {
-    vi.useRealTimers();
-  } );
-
-  it( 'writes a raw log entry and calls buildLogTree (mocked)', async () => {
-    const originalArgv2 = process.argv[2];
-    const tmp = createTempDir();
-    process.argv[2] = tmp;
-
-    mockConfig.tracing.enabled = true;
-
-    const { buildLogTree } = await import( './tracer_tree.js' );
-    const { trace } = await import( './index.js' );
-
-    const input = { foo: 1 };
-    trace( { lib: THIS_LIB_NAME, event: 'workflow_start', input, output: null } );
-
-    expect( buildLogTree ).toHaveBeenCalledTimes( 1 );
-    const logPath = buildLogTree.mock.calls[0][0];
-
-    const raw = readFileSync( logPath, 'utf-8' );
-    const [ firstLine ] = raw.split( EOL );
-    const entry = JSON.parse( firstLine );
-
-    expect( entry ).toMatchObject( {
-      lib: THIS_LIB_NAME,
-      event: 'workflow_start',
-      input,
-      output: null,
-      stepId: 's1',
-      stepName: 'Step 1',
-      workflowId: 'wf1',
-      workflowType: 'prompt',
-      workflowPath: '/workflows/prompt.js'
-    } );
-    expect( typeof entry.timestamp ).toBe( 'number' );
-
-    rmSync( tmp, { recursive: true, force: true } );
-    process.argv[2] = originalArgv2;
-  } );
-
-  it( 'does nothing when tracing is disabled', async () => {
-    const originalArgv2 = process.argv[2];
-    const tmp = createTempDir();
-    process.argv[2] = tmp;
-
-    mockConfig.tracing.enabled = false;
-    const { buildLogTree } = await import( './tracer_tree.js' );
-    const { trace } = await import( './index.js' );
-
-    trace( { lib: THIS_LIB_NAME, event: 'workflow_start', input: {}, output: null } );
-
-    expect( buildLogTree ).not.toHaveBeenCalled();
-
-    rmSync( tmp, { recursive: true, force: true } );
-    process.argv[2] = originalArgv2;
-  } );
-
-  it( 'setupGlobalTracer installs global symbol', async () => {
-    mockConfig.tracing.enabled = false;
-    const { setupGlobalTracer } = await import( './index.js' );
-    setupGlobalTracer();
-    const sym = Symbol.for( '__trace' );
-    expect( typeof globalThis[sym] ).toBe( 'function' );
-  } );
-} );

package/src/worker/tracer/tracer_tree.js

@@ -1,84 +0,0 @@
-import { readFileSync, writeFileSync } from 'node:fs';
-import { EOL } from 'os';
-import { THIS_LIB_NAME, TraceEvent } from '#consts';
-
-/**
- * Sorting function that compares two objects and ASC sort them by either .startedAt or, if not present, .timestamp
- *
- * @param {object} a
- * @param {object} b
- * @returns {number} The sorting result [1,-1]
- */
-const timestampAscSort = ( a, b ) => {
-  if ( a.startedAt ) {
-    return a.startedAt > b.startedAt ? 1 : 1;
-  }
-  return a.timestamp > b.timestamp ? 1 : -1;
-};
-
-/**
- * Add a member to an array an sort it. It is a mutating method.
- *
- * @param {array} arr - The arr to be changed
- * @param {any} entry - The entry to be added
- * @param {Function} sorter - The sort function to be used (within .filter)
- */
-const pushSort = ( arr, entry, sorter ) => {
-  arr.push( entry );
-  arr.sort( sorter );
-};
-
-/**
- * Transform the trace file into a tree of events, where nested events are represented as children of parent events.
- * And the events STEP_START/STEP_END and WORKFLOW_START/WORKFLOW_END are combined into single events with start and end timestamps.
- *
- * @param {string} src - The trace src filename
- */
-export const buildLogTree = src => {
-  const content = readFileSync( src, 'utf-8' );
-  const entries = content.split( EOL ).slice( 0, -1 ).map( c => JSON.parse( c ) );
-
-  const stepsMap = new Map();
-  const workflowsMap = new Map();
-
-  // close steps/workflows
-  for ( const entry of entries.filter( e => e.lib === THIS_LIB_NAME ) ) {
-    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 ( event === TraceEvent.STEP_END ) {
-      Object.assign( stepsMap.get( `${workflowId}:${stepId}` ) ?? {}, { output, endedAt: timestamp } );
-    }
-
-    if ( event === TraceEvent.WORKFLOW_START ) {
-      workflowsMap.set( workflowId, { event: 'workflow', input, parentWorkflowId, workflowPath, workflowType, ...baseEntry } );
-    }
-
-    if ( event === TraceEvent.WORKFLOW_END ) {
-      Object.assign( workflowsMap.get( workflowId ) ?? {}, { output, endedAt: timestamp } );
-    }
-  }
-
-  // insert operations inside steps
-  for ( const entry of entries.filter( e => e.lib !== THIS_LIB_NAME ) ) {
-    pushSort( stepsMap.get( `${entry.workflowId}:${entry.stepId}` ).children, entry, timestampAscSort );
-  }
-
-  // insert steps into workflows
-  for ( const step of stepsMap.values() ) {
-    pushSort( workflowsMap.get( step.workflowId ).children, step, timestampAscSort );
-  }
-
-  // insert children workflows
-  for ( const workflow of [ ...workflowsMap.values() ].filter( w => w.parentWorkflowId ) ) {
-    pushSort( workflowsMap.get( workflow.parentWorkflowId ).children, workflow, timestampAscSort );
-  }
-
-  const rootWorkflow = [ ...workflowsMap.values() ].find( w => !w.parentWorkflowId );
-
-  writeFileSync( src.replace( /\.raw$/, '.json' ), JSON.stringify( rootWorkflow, undefined, 2 ), 'utf-8' );
-};

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

@@ -1,115 +0,0 @@
-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';
-import { THIS_LIB_NAME, TraceEvent } from '#consts';
-
-const createTempDir = () => mkdtempSync( join( tmpdir(), 'flow-sdk-trace-tree-' ) );
-
-describe( 'tracer/tracer_tree', () => {
-  it( 'builds a tree JSON from a raw log file', () => {
-    const tmp = createTempDir();
-    const rawPath = join( tmp, 'run-123.raw' );
-
-    const entries = [
-      // root workflow start
-      {
-        lib: THIS_LIB_NAME,
-        event: TraceEvent.WORKFLOW_START,
-        input: { a: 1 },
-        output: null,
-        timestamp: 1000,
-        stepId: undefined,
-        stepName: undefined,
-        workflowId: 'wf1',
-        workflowType: 'prompt',
-        workflowPath: '/workflows/prompt.js',
-        parentWorkflowId: undefined
-      },
-      // step start
-      {
-        lib: THIS_LIB_NAME,
-        event: TraceEvent.STEP_START,
-        input: { x: 1 },
-        output: null,
-        timestamp: 2000,
-        stepId: 's1',
-        stepName: 'Step 1',
-        workflowId: 'wf1',
-        workflowType: 'prompt',
-        workflowPath: '/workflows/prompt.js',
-        parentWorkflowId: undefined
-      },
-      // non-core operation within step
-      {
-        lib: 'tool',
-        event: 'call',
-        input: { y: 2 },
-        output: { y: 3 },
-        timestamp: 3000,
-        stepId: 's1',
-        stepName: 'Step 1',
-        workflowId: 'wf1'
-      },
-      // step end
-      {
-        lib: THIS_LIB_NAME,
-        event: TraceEvent.STEP_END,
-        input: null,
-        output: { done: true },
-        timestamp: 4000,
-        stepId: 's1',
-        stepName: 'Step 1',
-        workflowId: 'wf1',
-        workflowType: 'prompt',
-        workflowPath: '/workflows/prompt.js',
-        parentWorkflowId: undefined
-      },
-      // workflow end
-      {
-        lib: THIS_LIB_NAME,
-        event: TraceEvent.WORKFLOW_END,
-        input: null,
-        output: { ok: true },
-        timestamp: 5000,
-        stepId: undefined,
-        stepName: undefined,
-        workflowId: 'wf1',
-        workflowType: 'prompt',
-        workflowPath: '/workflows/prompt.js',
-        parentWorkflowId: undefined
-      }
-    ];
-
-    writeFileSync( rawPath, entries.map( e => JSON.stringify( e ) ).join( EOL ) + EOL, 'utf-8' );
-
-    buildLogTree( rawPath );
-
-    const tree = JSON.parse( readFileSync( rawPath.replace( /.raw$/, '.json' ), 'utf-8' ) );
-
-    expect( tree.event ).toBe( 'workflow' );
-    expect( tree.workflowId ).toBe( 'wf1' );
-    expect( tree.workflowType ).toBe( 'prompt' );
-    expect( tree.startedAt ).toBe( 1000 );
-    expect( tree.endedAt ).toBe( 5000 );
-    expect( tree.output ).toEqual( { ok: true } );
-    expect( Array.isArray( tree.children ) ).toBe( true );
-    expect( tree.children.length ).toBe( 1 );
-
-    const step = tree.children[0];
-    expect( step.event ).toBe( 'step' );
-    expect( step.stepId ).toBe( 's1' );
-    expect( step.startedAt ).toBe( 2000 );
-    expect( step.endedAt ).toBe( 4000 );
-    expect( step.output ).toEqual( { done: true } );
-    expect( step.children.length ).toBe( 1 );
-    expect( step.children[0].lib ).toBe( 'tool' );
-    expect( step.children[0].timestamp ).toBe( 3000 );
-
-    rmSync( tmp, { recursive: true, force: true } );
-  } );
-} );
-