@outputai/core 0.7.1-dev.144d64f.0 → 0.7.1-next.0b398c7.0

package/bin/worker.sh

@@ -23,4 +23,10 @@ sdk_dir="$(dirname "$script_dir")"
 
 cd ${sdk_dir}
 
+# Route `output-worker --check` to the bundle-check entry, which validates the
+# workflow bundle without a Temporal connection or worker config.
+if [[ " $* " == *" --check "* ]]; then
+  exec node "${sdk_dir}/src/worker/check.js" "${invocation_dir}"
+fi
+
 exec node "${sdk_dir}/src/worker/index.js" "${invocation_dir}" "${@:2}"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.7.1-dev.144d64f.0",
+  "version": "0.7.1-next.0b398c7.0",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {

package/src/consts.js

@@ -35,10 +35,6 @@ export const BusEventType = {
   RUNTIME_ERROR: 'runtime_error'
 };
 
-export const Signal = {
-  SEND_AGGREGATIONS: 'send_aggregations'
-};
-
 export const WorkflowSpecialOutput = {
   CONTINUED_AS_NEW: '<<continued_as_new>>'
 };

package/src/errors.js

@@ -6,9 +6,13 @@
 /**
  * Any generic fatal errors
  */
-export class FatalError extends Error { }
+export class FatalError extends Error {
+  name = 'FatalError';
+}
 
 /**
  * Any validation error
  */
-export class ValidationError extends Error { }
+export class ValidationError extends Error {
+  name = 'ValidationError';
+}

package/src/interface/evaluator.js

@@ -1,31 +1,18 @@
-import { validateEvaluator } from './validations/static.js';
-import { validateWithSchema } from './validations/runtime.js';
+import { EvaluatorValidator } from './validations/index.js';
 import { setMetadata } from '#utils';
-import { ValidationError } from '#errors';
 import { ComponentType } from '#consts';
-import { EvaluationResult } from './evaluation_result.js';
+
 /**
- * Expose the function to create a new evaluator
- * @param {object} opts
- * @param {string} opts.name
- * @param {string} opts.description
- * @param {z.ZodType} opts.inputSchema
- * @param {Function} opts.fn
- * @param {object} opts.options
- * @returns {Function}
+ * Create a new evaluator (activity flavor) and return a wrapper function around its fn handler
  */
 export function evaluator( { name, description, inputSchema, fn, options } ) {
-  validateEvaluator( { name, description, inputSchema, fn, options } );
+  EvaluatorValidator.validateDefinition( { name, description, inputSchema, fn, options } );
+  const validator = new EvaluatorValidator( { name, inputSchema } );
 
   const wrapper = async input => {
-    validateWithSchema( inputSchema, input, `Evaluator ${name} input` );
-
+    validator.validateInput( input );
     const output = await fn( input );
-
-    if ( !( output instanceof EvaluationResult ) ) {
-      throw new ValidationError( 'Evaluators must return an EvaluationResult' );
-    }
-
+    validator.validateOutput( output );
     return output;
   };
 

package/src/interface/evaluator.spec.js

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import {
   EvaluationResult,
   EvaluationStringResult,
@@ -7,6 +7,122 @@ import {
   EvaluationFeedback
 } from './evaluation_result.js';
 import { ValidationError } from '#errors';
+import { ComponentType } from '#consts';
+
+const validateDefinitionMock = vi.hoisted( () => vi.fn() );
+const validateInputMock = vi.hoisted( () => vi.fn() );
+const validateOutputMock = vi.hoisted( () => vi.fn() );
+const validatorConstructorMock = vi.hoisted( () => vi.fn() );
+
+vi.mock( './validations/index.js', () => {
+  class EvaluatorValidator {
+    static validateDefinition( ...args ) {
+      return validateDefinitionMock( ...args );
+    }
+
+    constructor( ...args ) {
+      validatorConstructorMock( ...args );
+      this.validateInput = validateInputMock;
+      this.validateOutput = validateOutputMock;
+    }
+  }
+
+  return { EvaluatorValidator };
+} );
+
+describe( 'evaluator()', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+  } );
+
+  it( 'validates the definition, creates a runtime validator, and attaches metadata', async () => {
+    const { evaluator } = await import( './evaluator.js' );
+    const inputSchema = { safeParse: vi.fn() };
+    const fn = vi.fn().mockResolvedValue( new EvaluationResult( { value: 'ok', confidence: 1 } ) );
+    const options = { activityOptions: { startToCloseTimeout: '1m' } };
+
+    const wrapper = evaluator( {
+      name: 'test_evaluator',
+      description: 'Test evaluator',
+      inputSchema,
+      fn,
+      options
+    } );
+
+    expect( validateDefinitionMock ).toHaveBeenCalledWith( {
+      name: 'test_evaluator',
+      description: 'Test evaluator',
+      inputSchema,
+      fn,
+      options
+    } );
+    expect( validatorConstructorMock ).toHaveBeenCalledWith( {
+      name: 'test_evaluator',
+      inputSchema
+    } );
+
+    const [ metadataSymbol ] = Object.getOwnPropertySymbols( wrapper );
+    expect( wrapper[metadataSymbol] ).toEqual( {
+      name: 'test_evaluator',
+      description: 'Test evaluator',
+      inputSchema,
+      type: ComponentType.EVALUATOR,
+      options
+    } );
+  } );
+
+  it( 'validates input and output around the evaluator function', async () => {
+    const { evaluator } = await import( './evaluator.js' );
+    const output = new EvaluationResult( { value: 'ok', confidence: 1 } );
+    const fn = vi.fn().mockResolvedValue( output );
+    const wrapper = evaluator( {
+      name: 'runtime_evaluator',
+      inputSchema: undefined,
+      fn
+    } );
+
+    await expect( wrapper( { value: 'input' } ) ).resolves.toBe( output );
+
+    expect( validateInputMock ).toHaveBeenCalledWith( { value: 'input' } );
+    expect( fn ).toHaveBeenCalledWith( { value: 'input' } );
+    expect( validateOutputMock ).toHaveBeenCalledWith( output );
+  } );
+
+  it( 'does not call the evaluator function when input validation throws', async () => {
+    const { evaluator } = await import( './evaluator.js' );
+    const error = new ValidationError( 'invalid input' );
+    validateInputMock.mockImplementationOnce( () => {
+      throw error;
+    } );
+    const fn = vi.fn();
+    const wrapper = evaluator( {
+      name: 'invalid_input_evaluator',
+      fn
+    } );
+
+    await expect( wrapper( { value: 'bad' } ) ).rejects.toBe( error );
+    expect( fn ).not.toHaveBeenCalled();
+    expect( validateOutputMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'propagates output validation errors after the evaluator function runs', async () => {
+    const { evaluator } = await import( './evaluator.js' );
+    const error = new ValidationError( 'invalid output' );
+    validateOutputMock.mockImplementationOnce( () => {
+      throw error;
+    } );
+    const output = { value: 'not-an-evaluation-result' };
+    const fn = vi.fn().mockResolvedValue( output );
+    const wrapper = evaluator( {
+      name: 'invalid_output_evaluator',
+      fn
+    } );
+
+    await expect( wrapper( { value: 'input' } ) ).rejects.toBe( error );
+    expect( fn ).toHaveBeenCalledOnce();
+    expect( validateOutputMock ).toHaveBeenCalledWith( output );
+  } );
+} );
 
 describe( 'interface/evaluator - EvaluationResult classes', () => {
   describe( 'class inheritance', () => {

package/src/interface/step.js

@@ -1,19 +1,18 @@
-// THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
+import { StepValidator } from './validations/index.js';
 import { setMetadata } from '#utils';
-import { validateStep } from './validations/static.js';
-import { validateWithSchema } from './validations/runtime.js';
 import { ComponentType } from '#consts';
 
+/**
+ * Create a new step (activity flavor) and return a wrapper function around its fn handler
+ */
 export function step( { name, description, inputSchema, outputSchema, fn, options } ) {
-  validateStep( { name, description, inputSchema, outputSchema, fn, options } );
+  StepValidator.validateDefinition( { name, description, inputSchema, outputSchema, fn, options } );
+  const validator = new StepValidator( { name, inputSchema, outputSchema } );
 
   const wrapper = async input => {
-    validateWithSchema( inputSchema, input, `Step ${name} input` );
-
+    validator.validateInput( input );
     const output = await fn( input );
-
-    validateWithSchema( outputSchema, output, `Step ${name} output` );
-
+    validator.validateOutput( output );
     return output;
   };
 

package/src/interface/step.spec.js

@@ -0,0 +1,124 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ValidationError } from '#errors';
+import { ComponentType } from '#consts';
+
+const validateDefinitionMock = vi.hoisted( () => vi.fn() );
+const validateInputMock = vi.hoisted( () => vi.fn() );
+const validateOutputMock = vi.hoisted( () => vi.fn() );
+const validatorConstructorMock = vi.hoisted( () => vi.fn() );
+
+vi.mock( './validations/index.js', () => {
+  class StepValidator {
+    static validateDefinition( ...args ) {
+      return validateDefinitionMock( ...args );
+    }
+
+    constructor( ...args ) {
+      validatorConstructorMock( ...args );
+      this.validateInput = validateInputMock;
+      this.validateOutput = validateOutputMock;
+    }
+  }
+
+  return { StepValidator };
+} );
+
+describe( 'step()', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+  } );
+
+  it( 'validates the definition, creates a runtime validator, and attaches metadata', async () => {
+    const { step } = await import( './step.js' );
+    const inputSchema = { safeParse: vi.fn() };
+    const outputSchema = { safeParse: vi.fn() };
+    const fn = vi.fn().mockResolvedValue( { ok: true } );
+    const options = { activityOptions: { startToCloseTimeout: '1m' } };
+
+    const wrapper = step( {
+      name: 'test_step',
+      description: 'Test step',
+      inputSchema,
+      outputSchema,
+      fn,
+      options
+    } );
+
+    expect( validateDefinitionMock ).toHaveBeenCalledWith( {
+      name: 'test_step',
+      description: 'Test step',
+      inputSchema,
+      outputSchema,
+      fn,
+      options
+    } );
+    expect( validatorConstructorMock ).toHaveBeenCalledWith( {
+      name: 'test_step',
+      inputSchema,
+      outputSchema
+    } );
+
+    const [ metadataSymbol ] = Object.getOwnPropertySymbols( wrapper );
+    expect( wrapper[metadataSymbol] ).toEqual( {
+      name: 'test_step',
+      description: 'Test step',
+      inputSchema,
+      outputSchema,
+      type: ComponentType.STEP,
+      options
+    } );
+  } );
+
+  it( 'validates input and output around the step function', async () => {
+    const { step } = await import( './step.js' );
+    const output = { ok: true };
+    const fn = vi.fn().mockResolvedValue( output );
+    const wrapper = step( {
+      name: 'runtime_step',
+      inputSchema: undefined,
+      outputSchema: undefined,
+      fn
+    } );
+
+    await expect( wrapper( { value: 'input' } ) ).resolves.toBe( output );
+
+    expect( validateInputMock ).toHaveBeenCalledWith( { value: 'input' } );
+    expect( fn ).toHaveBeenCalledWith( { value: 'input' } );
+    expect( validateOutputMock ).toHaveBeenCalledWith( output );
+  } );
+
+  it( 'does not call the step function when input validation throws', async () => {
+    const { step } = await import( './step.js' );
+    const error = new ValidationError( 'invalid input' );
+    validateInputMock.mockImplementationOnce( () => {
+      throw error;
+    } );
+    const fn = vi.fn();
+    const wrapper = step( {
+      name: 'invalid_input_step',
+      fn
+    } );
+
+    await expect( wrapper( { value: 'bad' } ) ).rejects.toBe( error );
+    expect( fn ).not.toHaveBeenCalled();
+    expect( validateOutputMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'propagates output validation errors after the step function runs', async () => {
+    const { step } = await import( './step.js' );
+    const error = new ValidationError( 'invalid output' );
+    validateOutputMock.mockImplementationOnce( () => {
+      throw error;
+    } );
+    const output = { ok: false };
+    const fn = vi.fn().mockResolvedValue( output );
+    const wrapper = step( {
+      name: 'invalid_output_step',
+      fn
+    } );
+
+    await expect( wrapper( { value: 'input' } ) ).rejects.toBe( error );
+    expect( fn ).toHaveBeenCalledOnce();
+    expect( validateOutputMock ).toHaveBeenCalledWith( output );
+  } );
+} );

package/src/interface/validations/index.js

@@ -0,0 +1,108 @@
+import { ValidationError } from '#errors';
+import { prettifyError } from 'zod';
+import {
+  evaluatorOutputSchema,
+  evaluatorSchema,
+  httpRequestSchema,
+  executeInParallelSchema,
+  stepSchema,
+  workflowInvocationOptionsSchema,
+  workflowSchema
+} from './schemas.js';
+
+/**
+ * Validates data using a Zod schema
+ * @param {unknown} data
+ * @param {ZodType} schema
+ * @param {string} prefix - Validation error prefix
+ * @throws {ValidationError} If validation fails
+ * @returns {void}
+ */
+const validate = ( data, schema, prefix = '' ) => {
+  if ( !schema ) {
+    return;
+  }
+
+  const result = schema.safeParse( data );
+  if ( !result.success ) {
+    throw new ValidationError( `${prefix} validation failed: ${prettifyError( result.error ) }` );
+  }
+};
+
+export class WorkflowValidator {
+  static validateDefinition( definition ) {
+    validate( definition, workflowSchema, 'Workflow' );
+  }
+
+  constructor( { name, inputSchema, outputSchema } ) {
+    this.name = name;
+    this.inputSchema = inputSchema;
+    this.outputSchema = outputSchema;
+  }
+
+  validateInput( input ) {
+    validate( input, this.inputSchema, `Workflow "${this.name}" input` );
+  }
+
+  validateOutput( output ) {
+    validate( output, this.outputSchema, `Workflow "${this.name}" output` );
+  }
+
+  validateInvocationOptions( options ) {
+    validate( options, workflowInvocationOptionsSchema, `Workflow "${this.name}" invocation options` );
+  }
+}
+
+export class StepValidator {
+  static validateDefinition( definition ) {
+    validate( definition, stepSchema, 'Step' );
+  }
+
+  constructor( { name, inputSchema, outputSchema } ) {
+    this.name = name;
+    this.inputSchema = inputSchema;
+    this.outputSchema = outputSchema;
+  }
+
+  validateInput( input ) {
+    validate( input, this.inputSchema, `Step "${this.name}" input` );
+  }
+
+  validateOutput( output ) {
+    validate( output, this.outputSchema, `Step "${this.name}" output` );
+  }
+}
+
+export class EvaluatorValidator {
+  static validateDefinition( definition ) {
+    validate( definition, evaluatorSchema, 'Evaluator' );
+  }
+  constructor( { name, inputSchema } ) {
+    this.name = name;
+    this.inputSchema = inputSchema;
+  }
+
+  validateInput( input ) {
+    validate( input, this.inputSchema, `Evaluator "${this.name}" input` );
+  }
+
+  validateOutput( output ) {
+    validate( output, evaluatorOutputSchema, `Evaluator "${this.name}" output` );
+  }
+}
+
+/**
+ * Validate request payload
+ * @param {object} args - The request arguments
+ */
+export function validateRequestPayload( args ) {
+  validate( args, httpRequestSchema, 'Request payload' );
+};
+
+/**
+ * Validate executeInParallel
+ * @param {object} args - The request arguments
+ */
+export function validateExecuteInParallel( args ) {
+  validate( args, executeInParallelSchema, 'ExecuteInParallel' );
+};

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

@@ -0,0 +1,182 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod';
+import { ValidationError } from '#errors';
+import { EvaluationResult } from '../evaluation_result.js';
+import {
+  EvaluatorValidator,
+  StepValidator,
+  WorkflowValidator,
+  validateExecuteInParallel,
+  validateRequestPayload
+} from './index.js';
+
+const fn = async () => {};
+
+const workflowArgs = {
+  name: 'valid_workflow',
+  description: 'Valid workflow',
+  inputSchema: z.object( { value: z.string() } ),
+  outputSchema: z.object( { result: z.string() } ),
+  fn,
+  options: {
+    activityOptions: {
+      startToCloseTimeout: '5m',
+      retry: { maximumAttempts: 2 }
+    },
+    disableTrace: true
+  },
+  aliases: [ 'old_workflow' ]
+};
+
+const stepArgs = {
+  name: 'valid_step',
+  description: 'Valid step',
+  inputSchema: z.object( { value: z.string() } ),
+  outputSchema: z.object( { result: z.string() } ),
+  fn,
+  options: {
+    activityOptions: {
+      heartbeatTimeout: '30s'
+    }
+  }
+};
+
+const evaluatorArgs = {
+  name: 'valid_evaluator',
+  description: 'Valid evaluator',
+  inputSchema: z.object( { value: z.string() } ),
+  fn
+};
+
+describe( 'interface validators', () => {
+  describe( 'WorkflowValidator', () => {
+    it( 'validates workflow definitions, input, output, and invocation options', () => {
+      expect( () => WorkflowValidator.validateDefinition( workflowArgs ) ).not.toThrow();
+      const validator = new WorkflowValidator( workflowArgs );
+
+      expect( () => validator.validateInput( { value: 'ok' } ) ).not.toThrow();
+      expect( () => validator.validateOutput( { result: 'ok' } ) ).not.toThrow();
+      expect( () => validator.validateInvocationOptions( {
+        detached: true,
+        activityOptions: { retry: { maximumAttempts: 1 } },
+        context: { info: { workflowId: 'test-workflow' } }
+      } ) ).not.toThrow();
+    } );
+
+    it( 'throws ValidationError with useful prefixes for invalid workflow data', () => {
+      expect( () => WorkflowValidator.validateDefinition( { ...workflowArgs, name: 'bad-name' } ) ).toThrow( ValidationError );
+      expect( () => WorkflowValidator.validateDefinition( { ...workflowArgs, name: 'bad-name' } ) ).toThrow(
+        /Workflow validation failed/
+      );
+
+      const validator = new WorkflowValidator( workflowArgs );
+
+      expect( () => validator.validateInput( { value: 1 } ) ).toThrow( ValidationError );
+      expect( () => validator.validateInput( { value: 1 } ) ).toThrow( /Workflow "valid_workflow" input validation failed/ );
+      expect( () => validator.validateOutput( { result: 1 } ) ).toThrow( /Workflow "valid_workflow" output validation failed/ );
+      expect( () => validator.validateInvocationOptions( {
+        options: { activityOptions: { retry: { maximumAttempts: 1 } } }
+      } ) ).toThrow( /Workflow "valid_workflow" invocation options validation failed/ );
+    } );
+
+    it( 'skips input and output validation when schemas are omitted', () => {
+      const validator = new WorkflowValidator( {
+        name: 'schema_less_workflow',
+        fn
+      } );
+
+      expect( () => validator.validateInput( { anything: true } ) ).not.toThrow();
+      expect( () => validator.validateOutput( { anything: true } ) ).not.toThrow();
+    } );
+  } );
+
+  describe( 'StepValidator', () => {
+    it( 'validates step definitions, input, and output', () => {
+      expect( () => StepValidator.validateDefinition( stepArgs ) ).not.toThrow();
+      const validator = new StepValidator( stepArgs );
+
+      expect( () => validator.validateInput( { value: 'ok' } ) ).not.toThrow();
+      expect( () => validator.validateOutput( { result: 'ok' } ) ).not.toThrow();
+    } );
+
+    it( 'throws ValidationError with useful prefixes for invalid step data', () => {
+      expect( () => StepValidator.validateDefinition( { ...stepArgs, fn: 'not-a-function' } ) ).toThrow(
+        /Step validation failed/
+      );
+
+      const validator = new StepValidator( stepArgs );
+
+      expect( () => validator.validateInput( { value: 1 } ) ).toThrow( /Step "valid_step" input validation failed/ );
+      expect( () => validator.validateOutput( { result: 1 } ) ).toThrow( /Step "valid_step" output validation failed/ );
+    } );
+  } );
+
+  describe( 'EvaluatorValidator', () => {
+    it( 'validates evaluator definitions, input, and EvaluationResult output', () => {
+      expect( () => EvaluatorValidator.validateDefinition( evaluatorArgs ) ).not.toThrow();
+      const validator = new EvaluatorValidator( evaluatorArgs );
+
+      expect( () => validator.validateInput( { value: 'ok' } ) ).not.toThrow();
+      expect( () => validator.validateOutput( new EvaluationResult( { value: 'pass', confidence: 1 } ) ) ).not.toThrow();
+    } );
+
+    it( 'throws ValidationError for output schemas and invalid evaluator output', () => {
+      expect( () => EvaluatorValidator.validateDefinition( {
+        ...evaluatorArgs,
+        outputSchema: z.string()
+      } ) ).toThrow( /Evaluator validation failed/ );
+
+      const validator = new EvaluatorValidator( evaluatorArgs );
+
+      expect( () => validator.validateInput( { value: 1 } ) ).toThrow( /Evaluator "valid_evaluator" input validation failed/ );
+      expect( () => validator.validateOutput( { value: 'pass', confidence: 1 } ) ).toThrow(
+        /Evaluator "valid_evaluator" output validation failed/
+      );
+    } );
+  } );
+
+  describe( 'validateRequestPayload()', () => {
+    it( 'accepts valid request payloads', () => {
+      expect( () => validateRequestPayload( {
+        url: 'https://example.com',
+        method: 'POST',
+        payload: { ok: true },
+        headers: { authorization: 'Bearer token' }
+      } ) ).not.toThrow();
+    } );
+
+    it( 'throws ValidationError for invalid request payloads', () => {
+      expect( () => validateRequestPayload( {
+        url: 'ftp://example.com',
+        method: 'POST'
+      } ) ).toThrow( /Request payload validation failed/ );
+
+      expect( () => validateRequestPayload( {
+        url: 'https://example.com',
+        method: 'OPTIONS'
+      } ) ).toThrow( ValidationError );
+    } );
+  } );
+
+  describe( 'validateExecuteInParallel()', () => {
+    it( 'accepts valid parallel execution configs', () => {
+      expect( () => validateExecuteInParallel( {
+        jobs: [ () => 'ok' ],
+        concurrency: Infinity,
+        onJobCompleted: () => {}
+      } ) ).not.toThrow();
+    } );
+
+    it( 'throws ValidationError for invalid parallel execution configs', () => {
+      expect( () => validateExecuteInParallel( {
+        jobs: [ () => 'ok' ],
+        concurrency: 0
+      } ) ).toThrow( /ExecuteInParallel validation failed/ );
+
+      expect( () => validateExecuteInParallel( {
+        jobs: [ 'not-a-function' ],
+        concurrency: 1
+      } ) ).toThrow( ValidationError );
+    } );
+  } );
+} );