@outputai/core 0.7.1-next.db8ddd7.0 → 0.7.1-next.ed233ce.0

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

@@ -15,7 +15,7 @@ const traverse = traverseModule.default ?? traverseModule;
  * Check whether a CallExpression callee is a simple Identifier.
  * Only direct identifier calls are rewritten; member/dynamic calls are skipped.
  *
- * We only support rewriting `Foo()` calls that refer to imported steps/flows/evaluators
+ * We only support rewriting `Foo()` calls that refer to imported steps/evaluators
  * or local call-chain functions. Calls like `obj.Foo()` or `(getFn())()` are out of scope.
  *
  * Examples:
@@ -31,7 +31,7 @@ const isIdentifierCallee = cPath => isIdentifier( cPath.node.callee );
  * Convert an ArrowFunctionExpression at the given path into a FunctionExpression
  * to ensure dynamic `this` semantics inside the function body.
  *
- * Workflow code relies on `this` to invoke steps/flows (e.g., `this.invokeStep(...)`).
+ * Workflow code relies on `this` to invoke steps/evaluators (e.g., `this.invokeStep(...)`).
  * Arrow functions capture `this` lexically, which would break that contract.
  *
  * If the node is an arrow, it is replaced by an equivalent FunctionExpression and
@@ -49,7 +49,7 @@ const normalizeArrowToFunctionPath = ( nodePath, state ) => {
 };
 /**
  * Rewrite calls inside a function body and collect call-chain functions discovered within.
- * - Imported calls (steps/shared/evaluators/flows) are rewritten to `this.invokeX` or `this.startWorkflow`.
+ * - Imported calls (steps/shared/evaluators) are rewritten to `this.invokeX`.
  * - Local call-chain function calls are rewritten to `fn.call(this, ...)` to bind `this` correctly.
  * - Returns a map of call-chain function name -> binding path for further recursive processing.
  *
@@ -67,7 +67,7 @@ const rewriteCallsInBody = ( bodyPath, descriptors, state ) => {
       }
       const callee = cPath.node.callee;
 
-      // Rewrite imported calls (steps/shared/evaluators/flows)
+      // Rewrite imported calls (steps/shared/evaluators)
       for ( const { list, method, key } of descriptors ) {
         const found = list.find( x => x.localName === callee.name );
         if ( found ) {
@@ -143,28 +143,25 @@ const processFunction = ( { name, bindingPath, state, descriptors, processedFns
 };
 
 /**
- * Rewrite calls to imported steps/workflows within `fn` object properties.
+ * Rewrite calls to imported steps/evaluators within `fn` object properties.
  * Converts arrow fns to functions and replaces `StepX(...)` with
- * `this.invokeStep('name', ...)` and `FlowY(...)` with
- * `this.startWorkflow('name', ...)`.
+ * `this.invokeStep('name', ...)`.
  *
  * @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,stepName:string}>} params.sharedStepImports - Shared 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, sharedStepImports = [], evaluatorImports, sharedEvaluatorImports = [], flowImports } ) {
+export default function rewriteFnBodies( { ast, stepImports, sharedStepImports = [], evaluatorImports, sharedEvaluatorImports = [] } ) {
   const state = { rewrote: false };
   // Build rewrite descriptors once per traversal
   const descriptors = [
     { list: stepImports, method: 'invokeStep', key: 'stepName' },
     { list: sharedStepImports, method: 'invokeSharedStep', key: 'stepName' },
     { list: evaluatorImports, method: 'invokeEvaluator', key: 'evaluatorName' },
-    { list: sharedEvaluatorImports, method: 'invokeSharedEvaluator', key: 'evaluatorName' },
-    { list: flowImports, method: 'startWorkflow', key: 'workflowName' }
+    { list: sharedEvaluatorImports, method: 'invokeSharedEvaluator', key: 'evaluatorName' }
   ];
   traverse( ast, {
     ObjectProperty: path => {

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

@@ -6,7 +6,7 @@ import rewriteFnBodies from './rewrite_fn_bodies.js';
 const generate = generatorModule.default ?? generatorModule;
 
 describe( 'rewrite_fn_bodies', () => {
-  it( 'converts arrow to function and rewrites step/workflow calls', () => {
+  it( 'converts arrow to function and rewrites step calls without rewriting workflow calls', () => {
     const src = `
 const obj = {
   fn: async x => {
@@ -16,13 +16,13 @@ const obj = {
 }`;
     const ast = parse( src, 'file.js' );
     const stepImports = [ { localName: 'StepA', stepName: 'step.a' } ];
-    const flowImports = [ { localName: 'FlowB', workflowName: 'flow.b' } ];
 
-    const rewrote = rewriteFnBodies( { ast, stepImports, evaluatorImports: [], flowImports } );
+    const rewrote = rewriteFnBodies( { ast, stepImports, evaluatorImports: [] } );
     expect( rewrote ).toBe( true );
 
-    const code = ast.program.body.map( n => n.type ).length; // smoke: ast mutated
-    expect( code ).toBeGreaterThan( 0 );
+    const { code } = generate( ast, { quotes: 'single' } );
+    expect( code ).toMatch( /this\.invokeStep\(([\"'])step\.a\1,\s*1\)/ );
+    expect( code ).toMatch( /FlowB\(2\)/ );
   } );
 
   it( 'rewrites evaluator calls to this.invokeEvaluator', () => {
@@ -34,14 +34,14 @@ const obj = {
 };`;
     const ast = parse( src, 'file.js' );
     const evaluatorImports = [ { localName: 'EvalA', evaluatorName: 'eval.a' } ];
-    const rewrote = rewriteFnBodies( { ast, stepImports: [], evaluatorImports, flowImports: [] } );
+    const rewrote = rewriteFnBodies( { ast, stepImports: [], evaluatorImports } );
     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, stepImports: [], evaluatorImports: [], flowImports: [] } );
+    const rewrote = rewriteFnBodies( { ast, stepImports: [], evaluatorImports: [] } );
     expect( rewrote ).toBe( false );
   } );
 
@@ -66,7 +66,7 @@ const obj = {
     const stepImports = [ { localName: 'StepA', stepName: 'step.a' } ];
     const evaluatorImports = [ { localName: 'EvalA', evaluatorName: 'eval.a' } ];
 
-    const rewrote = rewriteFnBodies( { ast, stepImports, sharedStepImports: [], evaluatorImports, flowImports: [] } );
+    const rewrote = rewriteFnBodies( { ast, stepImports, sharedStepImports: [], evaluatorImports } );
     expect( rewrote ).toBe( true );
 
     const { code } = generate( ast, { quotes: 'single' } );
@@ -105,7 +105,7 @@ const obj = {
 
     const ast = parse( src, 'file.js' );
     const stepImports = [ { localName: 'StepA', stepName: 'step.a' } ];
-    const rewrote = rewriteFnBodies( { ast, stepImports, evaluatorImports: [], flowImports: [] } );
+    const rewrote = rewriteFnBodies( { ast, stepImports, evaluatorImports: [] } );
     expect( rewrote ).toBe( true );
 
     const { code } = generate( ast, { quotes: 'single' } );

package/src/interface/validations/runtime.js

@@ -1,20 +0,0 @@
-import { ValidationError } from '#errors';
-
-/**
- * Validates data against a Zod schema using safeParse
- * @param {unknown} schema - The Zod schema to validate against
- * @param {unknown} data - The data to validate
- * @param {string} context - Description of what's being validated (for error messages)
- * @throws {ValidationError} If validation fails
- * @returns {void}
- */
-export function validateWithSchema( schema, data, context ) {
-  if ( !schema ) {
-    return;
-  }
-
-  const result = schema.safeParse( data );
-  if ( !result.success ) {
-    throw new ValidationError( `${context} validation failed: ${result.error.message}` );
-  }
-}

package/src/interface/validations/runtime.spec.js

@@ -1,29 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod';
-import { validateWithSchema } from './runtime.js';
-import { ValidationError } from '#errors';
-
-describe( 'runtime validations', () => {
-  describe( 'validateWithSchema', () => {
-    it( 'no-ops when schema is falsy', () => {
-      expect( () => validateWithSchema( undefined, { a: 1 }, 'X' ) ).not.toThrow();
-      expect( () => validateWithSchema( null, { a: 1 }, 'X' ) ).not.toThrow();
-    } );
-
-    it( 'passes on valid data', () => {
-      const schema = z.object( { a: z.string(), b: z.number().optional() } );
-      expect( () => validateWithSchema( schema, { a: 'ok' }, 'Test' ) ).not.toThrow();
-    } );
-
-    it( 'throws ValidationError on invalid data and prefixes context', () => {
-      const schema = z.object( { a: z.string() } );
-      const call = () => validateWithSchema( schema, { a: 1 }, 'MyCtx' );
-      expect( call ).toThrow( ValidationError );
-      try {
-        call();
-      } catch ( e ) {
-        expect( String( e.message ) ).toContain( 'MyCtx validation failed:' );
-      }
-    } );
-  } );
-} );

package/src/interface/validations/schema_utils.js

@@ -1,8 +0,0 @@
-import { ZodType } from 'zod';
-
-/**
- * Detects if a schema is a ZodType instance
- * @param {unknown} schema - The schema to check
- * @returns {boolean} True if the schema is a Zod schema
- */
-export const isZodSchema = schema => schema instanceof ZodType;

package/src/interface/validations/schema_utils.spec.js

@@ -1,67 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod';
-
-// Import the actual implementations
-import { isZodSchema } from './schema_utils.js';
-
-describe( 'Schema Detection', () => {
-  describe( 'isZodSchema', () => {
-    it( 'should correctly identify Zod schemas', () => {
-      const zodSchema = z.object( {
-        name: z.string(),
-        age: z.number()
-      } );
-
-      expect( isZodSchema( zodSchema ) ).toBe( true );
-    } );
-
-    it( 'should correctly identify Zod string schema', () => {
-      const zodString = z.string();
-      expect( isZodSchema( zodString ) ).toBe( true );
-    } );
-
-    it( 'should correctly identify Zod array schema', () => {
-      const zodArray = z.array( z.number() );
-      expect( isZodSchema( zodArray ) ).toBe( true );
-    } );
-
-    it( 'should correctly identify Zod union schema', () => {
-      const zodUnion = z.union( [ z.string(), z.number() ] );
-      expect( isZodSchema( zodUnion ) ).toBe( true );
-    } );
-
-    it( 'should return false for JSON Schema objects', () => {
-      const jsonSchema = {
-        type: 'object',
-        properties: {
-          name: { type: 'string' },
-          age: { type: 'number' }
-        },
-        required: [ 'name' ]
-      };
-
-      expect( isZodSchema( jsonSchema ) ).toBe( false );
-    } );
-
-    it( 'should return false for plain objects', () => {
-      expect( isZodSchema( {} ) ).toBe( false );
-      expect( isZodSchema( { type: 'string' } ) ).toBe( false );
-    } );
-
-    it( 'should return false for null and undefined', () => {
-      expect( isZodSchema( null ) ).toBeFalsy();
-      expect( isZodSchema( undefined ) ).toBeFalsy();
-    } );
-
-    it( 'should return false for primitive values', () => {
-      expect( isZodSchema( 'string' ) ).toBe( false );
-      expect( isZodSchema( 123 ) ).toBe( false );
-      expect( isZodSchema( true ) ).toBe( false );
-    } );
-
-    it( 'should return false for arrays', () => {
-      expect( isZodSchema( [] ) ).toBe( false );
-      expect( isZodSchema( [ 1, 2, 3 ] ) ).toBe( false );
-    } );
-  } );
-} );

package/src/interface/validations/static.js

@@ -1,137 +0,0 @@
-import * as z from 'zod';
-import { isZodSchema } from './schema_utils.js';
-
-/**
- * Error is thrown when the definition of a step/workflow has problems
- */
-export class StaticValidationError extends Error {};
-
-const refineSchema = ( value, ctx ) => {
-  if ( !value || isZodSchema( value ) ) {
-    return;
-  }
-
-  ctx.addIssue( {
-    code: 'invalid_type',
-    message: 'Schema must be a Zod schema'
-  } );
-};
-
-export const executeInParallelSchema = z.object( {
-  jobs: z.array( z.function() ),
-  concurrency: z.number().min( 1 ).or( z.literal( Infinity ) ),
-  onJobCompleted: z.function().optional()
-} );
-
-export const durationSchema = z.union( [ z.string().regex(
-  /^(\d+)(ms|s|m|h|d)$/,
-  'Expected duration like "500ms", "10s", "5m", "2h", or "1d"'
-), z.number() ] );
-
-export const prioritySchema = z.object( {
-  fairnessKey: z.string().optional(),
-  fairnessWeight: z.number().min( 0.0001 ).max( 1000 ).optional(),
-  priorityKey: z.number().min( 1 ).optional()
-} );
-
-const baseSchema = z.strictObject( {
-  name: z.string().regex( /^[a-z_][a-z0-9_]*$/i ),
-  description: z.string().optional(),
-  inputSchema: z.any().optional().superRefine( refineSchema ),
-  outputSchema: z.any().optional().superRefine( refineSchema ),
-  fn: z.function(),
-  options: z.object( {
-    activityOptions: z.strictObject( {
-      activityId: z.string().optional(),
-      cancellationType: z.enum( [ 'TRY_CANCEL', 'WAIT_CANCELLATION_COMPLETED', 'ABANDON' ] ).optional(),
-      heartbeatTimeout: durationSchema.optional(),
-      priority: prioritySchema.optional(),
-      retry: z.strictObject( {
-        initialInterval: durationSchema.optional(),
-        backoffCoefficient: z.number().gte( 1 ).optional(),
-        maximumInterval: durationSchema.optional(),
-        maximumAttempts: z.number().gte( 1 ).int().optional(),
-        nonRetryableErrorTypes: z.array( z.string() ).optional()
-      } ).optional(),
-      scheduleToCloseTimeout: durationSchema.optional(),
-      scheduleToStartTimeout: durationSchema.optional(),
-      startToCloseTimeout: durationSchema.optional(),
-      summary: z.string().optional()
-    } ).optional()
-  } ).optional()
-} );
-
-const stepSchema = baseSchema;
-
-const workflowSchema = baseSchema.extend( {
-  aliases: z.array( z.string().regex( /^[a-z_][a-z0-9_]*$/i ) ).optional().default( [] ),
-  options: baseSchema.shape.options.unwrap().extend( {
-    disableTrace: z.boolean().optional().default( false )
-  } ).optional()
-} );
-
-const evaluatorSchema = baseSchema.omit( { outputSchema: true } );
-
-const httpRequestSchema = z.object( {
-  url: z.url( { protocol: /^https?$/ } ),
-  method: z.enum( [ 'GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE' ] ),
-  payload: z.any().optional(),
-  headers: z.record( z.string(), z.string() ).optional()
-} );
-
-const validateAgainstSchema = ( schema, args ) => {
-  const result = schema.safeParse( args );
-  if ( !result.success ) {
-    throw new StaticValidationError( z.prettifyError( result.error ) );
-  }
-};
-
-/**
- * Validate step payload
- *
- * @param {object} args - The step arguments
- * @throws {StaticValidationError} Throws if args are invalid
- */
-export function validateStep( args ) {
-  validateAgainstSchema( stepSchema, args );
-};
-
-/**
- * Validate evaluator payload
- *
- * @param {object} args - The evaluator arguments
- * @throws {StaticValidationError} Throws if args are invalid
- */
-export function validateEvaluator( args ) {
-  validateAgainstSchema( evaluatorSchema, args );
-};
-
-/**
- * Validate workflow payload
- *
- * @param {object} args - The workflow arguments
- * @throws {StaticValidationError} Throws if args are invalid
- */
-export function validateWorkflow( args ) {
-  validateAgainstSchema( workflowSchema, args );
-};
-
-/**
- * Validate request payload
- *
- * @param {object} args - The request arguments
- * @throws {StaticValidationError} Throws if args are invalid
- */
-export function validateRequestPayload( args ) {
-  validateAgainstSchema( httpRequestSchema, args );
-};
-
-/**
- * Validate executeInParallel
- *
- * @param {object} args - The request arguments
- * @throws {StaticValidationError} Throws if args are invalid
- */
-export function validateExecuteInParallel( args ) {
-  validateAgainstSchema( executeInParallelSchema, args );
-};