@outputai/core 0.7.0 → 0.7.1-next.0e958f3.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.0",
+  "version": "0.7.1-next.0e958f3.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/hooks/index.d.ts

@@ -85,6 +85,8 @@ export interface WorkflowDetails {
 export interface ErrorHookPayload {
   /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
   eventId: string;
+  /** Timestamp of the event */
+  eventDate: number;
   /** Origin of the error: workflow execution, activity execution, or runtime. */
   source: 'workflow' | 'activity' | 'runtime';
   /** Information about the current workflow execution */
@@ -103,6 +105,8 @@ export interface ErrorHookPayload {
 export interface WorkflowStartHookPayload {
   /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
   eventId: string;
+  /** Timestamp of the event */
+  eventDate: number;
   /** Information about the current workflow execution */
   workflowDetails: WorkflowDetails;
 }
@@ -113,6 +117,8 @@ export interface WorkflowStartHookPayload {
 export interface WorkflowEndHookPayload {
   /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
   eventId: string;
+  /** Timestamp of the event */
+  eventDate: number;
   /** Information about the current workflow execution */
   workflowDetails: WorkflowDetails;
 }
@@ -123,6 +129,8 @@ export interface WorkflowEndHookPayload {
 export interface WorkflowErrorHookPayload {
   /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
   eventId: string;
+  /** Timestamp of the event */
+  eventDate: number;
   /** Information about the current workflow execution */
   workflowDetails: WorkflowDetails;
   /** The error thrown. */
@@ -177,6 +185,8 @@ export declare function onWorkflowError( handler: ( payload: WorkflowErrorHookPa
 export interface OnHookEnvelope {
   /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
   eventId: string;
+  /** Timestamp of the event */
+  eventDate: number;
   /** Information about the current workflow execution */
   workflowDetails: WorkflowDetails;
   /** Temporal's activityInfo(). */

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