@outputai/core 0.10.1-next.c717e35.0 → 0.10.1-next.cbef793.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.10.1-next.c717e35.0",
+  "version": "0.10.1-next.cbef793.0",
   "description": "The core module of the output framework",
   "type": "module",
   "engines": {

package/src/interface/evaluator.d.ts

@@ -16,7 +16,7 @@ export type EvaluatorOptions = {
 /**
  * The handler function of an evaluator.
  *
- * @param input - The evaluator input; it matches the schema defined by `inputSchema`.
+ * @param input - Parsed evaluator input (`z.infer<inputSchema>`).
  *
  * @returns The result of the evaluation.
  */
@@ -30,14 +30,15 @@ export type EvaluatorFunction<
 /**
  * A wrapper around the user defined `fn` handler function.
  *
- * It has the same signature and returns the same value, calling the user function inside.
- *
- * It adds input validation based on the `inputSchema`.
+ * Callers pass values accepted by `inputSchema` (`z.input`). The wrapper parses input
+ * and invokes `fn`.
  */
-export type EvaluatorFunctionWrapper<EvaluatorFunction extends ( ...args: any ) => any> = // eslint-disable-line @typescript-eslint/no-explicit-any
-  Parameters<EvaluatorFunction> extends [infer Input] ?
-    ( input: Input ) => ReturnType<EvaluatorFunction> :
-    () => ReturnType<EvaluatorFunction>;
+export type EvaluatorFunctionWrapper<
+  InputSchema extends AnyZodSchema | undefined = undefined,
+  Result extends EvaluationResult = EvaluationResult
+> = InputSchema extends AnyZodSchema ?
+  ( input: z.input<InputSchema> ) => Promise<Result> :
+  () => Promise<Result>;
 
 /**
  * Creates an evaluation function. It is similar to a step, but must return an EvaluationResult.
@@ -67,4 +68,4 @@ export declare function evaluator<
   inputSchema: InputSchema;
   fn: EvaluatorFunction<InputSchema, Result>;
   options?: EvaluatorOptions;
-} ): EvaluatorFunctionWrapper<EvaluatorFunction<InputSchema, Result>>;
+} ): EvaluatorFunctionWrapper<InputSchema, Result>;

package/src/interface/evaluator.js

@@ -13,11 +13,6 @@ export function evaluator( { name, description, inputSchema, fn, options } ) {
     description,
     inputSchema,
     options,
-    handler: async input => {
-      validator.validateInput( input );
-      const output = await fn( input );
-      validator.validateOutput( output );
-      return output;
-    }
+    handler: async input => validator.parseOutput( await fn( validator.parseInput( input ) ) )
   } );
 }

package/src/interface/evaluator.spec.js

@@ -9,8 +9,8 @@ import {
 import { ValidationError } from '#errors';
 
 const validateDefinitionMock = vi.hoisted( () => vi.fn() );
-const validateInputMock = vi.hoisted( () => vi.fn() );
-const validateOutputMock = vi.hoisted( () => vi.fn() );
+const parseInputMock = vi.hoisted( () => vi.fn( input => input ) );
+const parseOutputMock = vi.hoisted( () => vi.fn( output => output ) );
 const validatorConstructorMock = vi.hoisted( () => vi.fn() );
 const createEvaluatorMock = vi.hoisted( () => vi.fn( ( { handler } ) => handler ) );
 
@@ -22,8 +22,8 @@ vi.mock( './validations/index.js', () => {
 
     constructor( ...args ) {
       validatorConstructorMock( ...args );
-      this.validateInput = validateInputMock;
-      this.validateOutput = validateOutputMock;
+      this.parseInput = parseInputMock;
+      this.parseOutput = parseOutputMock;
     }
   }
 
@@ -87,15 +87,15 @@ describe( 'evaluator()', () => {
 
     await expect( wrapper( { value: 'input' } ) ).resolves.toBe( output );
 
-    expect( validateInputMock ).toHaveBeenCalledWith( { value: 'input' } );
+    expect( parseInputMock ).toHaveBeenCalledWith( { value: 'input' } );
     expect( fn ).toHaveBeenCalledWith( { value: 'input' } );
-    expect( validateOutputMock ).toHaveBeenCalledWith( output );
+    expect( parseOutputMock ).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( () => {
+    parseInputMock.mockImplementationOnce( () => {
       throw error;
     } );
     const fn = vi.fn();
@@ -106,13 +106,13 @@ describe( 'evaluator()', () => {
 
     await expect( wrapper( { value: 'bad' } ) ).rejects.toBe( error );
     expect( fn ).not.toHaveBeenCalled();
-    expect( validateOutputMock ).not.toHaveBeenCalled();
+    expect( parseOutputMock ).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( () => {
+    parseOutputMock.mockImplementationOnce( () => {
       throw error;
     } );
     const output = { value: 'not-an-evaluation-result' };
@@ -124,7 +124,7 @@ describe( 'evaluator()', () => {
 
     await expect( wrapper( { value: 'input' } ) ).rejects.toBe( error );
     expect( fn ).toHaveBeenCalledOnce();
-    expect( validateOutputMock ).toHaveBeenCalledWith( output );
+    expect( parseOutputMock ).toHaveBeenCalledWith( output );
   } );
 } );
 

package/src/interface/step.d.ts

@@ -15,31 +15,32 @@ export type StepOptions = {
 /**
  * The handler function of a step.
  *
- * @param input - The step input; it matches the schema defined by `inputSchema`.
+ * @param input - Parsed step input (`z.infer<inputSchema>`).
  *
- * @returns A value matching the schema defined by `outputSchema`.
+ * @returns A value accepted by `outputSchema` before parse (`z.input<outputSchema>`).
  */
 export type StepFunction<
   InputSchema extends AnyZodSchema | undefined = undefined,
   OutputSchema extends AnyZodSchema | undefined = undefined
 > = InputSchema extends AnyZodSchema ?
-  ( input: z.infer<InputSchema> ) => Promise<OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void> :
-  () => Promise<OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void>;
+  ( input: z.infer<InputSchema> ) => Promise<OutputSchema extends AnyZodSchema ? z.input<OutputSchema> : void> :
+  () => Promise<OutputSchema extends AnyZodSchema ? z.input<OutputSchema> : void>;
 
 /**
  * A wrapper around the user defined `fn` handler function.
  *
- * It accepts the same input and returns the same value, calling the user function inside.
- *
- * It adds input and output validation based on the `inputSchema`, `outputSchema`.
+ * Callers pass values accepted by `inputSchema` (`z.input`). The wrapper parses input,
+ * invokes `fn`, parses output, and returns `z.infer<outputSchema>`.
  *
- * @param input - The Step input; it matches the schema defined by `inputSchema`.
- * @returns A value matching the schema defined by `outputSchema`.
+ * @param input - The step input before `inputSchema` parse.
+ * @returns The step output after `outputSchema` parse.
  */
-export type StepFunctionWrapper<StepFunction extends ( ...args: any ) => any> = // eslint-disable-line @typescript-eslint/no-explicit-any
-  Parameters<StepFunction> extends [infer Input] ?
-    ( input: Input ) => ReturnType<StepFunction> :
-    () => ReturnType<StepFunction>;
+export type StepFunctionWrapper<
+  InputSchema extends AnyZodSchema | undefined = undefined,
+  OutputSchema extends AnyZodSchema | undefined = undefined
+> = InputSchema extends AnyZodSchema ?
+  ( input: z.input<InputSchema> ) => Promise<OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void> :
+  () => Promise<OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void>;
 
 /**
  * Creates a step.
@@ -123,7 +124,7 @@ export type StepFunctionWrapper<StepFunction extends ( ...args: any ) => any> =
  * @param params.outputSchema - Zod schema for the `fn` output
  * @param params.fn - A handler function containing the step code
  * @param params.options - Optional step options.
- * @returns The same handler function set at `fn`
+ * @returns A wrapper that parses input/output around `fn`
  */
 export declare function step<
   InputSchema extends AnyZodSchema | undefined = undefined,
@@ -135,4 +136,4 @@ export declare function step<
   outputSchema?: OutputSchema;
   fn: StepFunction<InputSchema, OutputSchema>;
   options?: StepOptions;
-} ): StepFunctionWrapper<StepFunction<InputSchema, OutputSchema>>;
+} ): StepFunctionWrapper<InputSchema, OutputSchema>;

package/src/interface/step.js

@@ -14,11 +14,6 @@ export function step( { name, description, inputSchema, outputSchema, fn, option
     inputSchema,
     outputSchema,
     options,
-    handler: async input => {
-      validator.validateInput( input );
-      const output = await fn( input );
-      validator.validateOutput( output );
-      return output;
-    }
+    handler: async input => validator.parseOutput( await fn( validator.parseInput( input ) ) )
   } );
 }

package/src/interface/step.spec.js

@@ -2,8 +2,8 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { ValidationError } from '#errors';
 
 const validateDefinitionMock = vi.hoisted( () => vi.fn() );
-const validateInputMock = vi.hoisted( () => vi.fn() );
-const validateOutputMock = vi.hoisted( () => vi.fn() );
+const parseInputMock = vi.hoisted( () => vi.fn( input => input ) );
+const parseOutputMock = vi.hoisted( () => vi.fn( output => output ) );
 const validatorConstructorMock = vi.hoisted( () => vi.fn() );
 const createStepMock = vi.hoisted( () => vi.fn( ( { handler } ) => handler ) );
 
@@ -15,8 +15,8 @@ vi.mock( './validations/index.js', () => {
 
     constructor( ...args ) {
       validatorConstructorMock( ...args );
-      this.validateInput = validateInputMock;
-      this.validateOutput = validateOutputMock;
+      this.parseInput = parseInputMock;
+      this.parseOutput = parseOutputMock;
     }
   }
 
@@ -86,15 +86,15 @@ describe( 'step()', () => {
 
     await expect( wrapper( { value: 'input' } ) ).resolves.toBe( output );
 
-    expect( validateInputMock ).toHaveBeenCalledWith( { value: 'input' } );
+    expect( parseInputMock ).toHaveBeenCalledWith( { value: 'input' } );
     expect( fn ).toHaveBeenCalledWith( { value: 'input' } );
-    expect( validateOutputMock ).toHaveBeenCalledWith( output );
+    expect( parseOutputMock ).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( () => {
+    parseInputMock.mockImplementationOnce( () => {
       throw error;
     } );
     const fn = vi.fn();
@@ -105,13 +105,13 @@ describe( 'step()', () => {
 
     await expect( wrapper( { value: 'bad' } ) ).rejects.toBe( error );
     expect( fn ).not.toHaveBeenCalled();
-    expect( validateOutputMock ).not.toHaveBeenCalled();
+    expect( parseOutputMock ).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( () => {
+    parseOutputMock.mockImplementationOnce( () => {
       throw error;
     } );
     const output = { ok: false };
@@ -123,6 +123,6 @@ describe( 'step()', () => {
 
     await expect( wrapper( { value: 'input' } ) ).rejects.toBe( error );
     expect( fn ).toHaveBeenCalledOnce();
-    expect( validateOutputMock ).toHaveBeenCalledWith( output );
+    expect( parseOutputMock ).toHaveBeenCalledWith( output );
   } );
 } );

package/src/interface/validations/index.js

@@ -1,4 +1,5 @@
 import { ValidationError } from '#errors';
+import { ComponentType } from '#consts';
 import { prettifyError } from 'zod';
 import {
   evaluatorOutputSchema,
@@ -10,84 +11,63 @@ import {
   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 = '' ) => {
+const capitalize = word => word.at( 0 ).toUpperCase() + word.slice( 1 );
+
+const validate = ( schema, data, prefix ) => {
   if ( !schema ) {
-    return;
+    return data;
   }
-
   const result = schema.safeParse( data );
-  if ( !result.success ) {
+  if ( result.success === false ) {
     throw new ValidationError( `${prefix} validation failed: ${prettifyError( result.error ) }` );
   }
+  return result.data;
 };
 
-export class WorkflowValidator {
+export class Validator {
+  static label;
+  static definitionSchema;
+
   static validateDefinition( definition ) {
-    validate( definition, workflowSchema, 'Workflow' );
+    validate( this.definitionSchema, definition, this.label );
   }
 
   constructor( { name, inputSchema, outputSchema } ) {
     this.name = name;
     this.inputSchema = inputSchema;
     this.outputSchema = outputSchema;
+    this.prefix = `${this.constructor.label} "${this.name}"`;
   }
 
-  validateInput( input ) {
-    validate( input, this.inputSchema, `Workflow "${this.name}" input` );
-  }
-
-  validateOutput( output ) {
-    validate( output, this.outputSchema, `Workflow "${this.name}" output` );
+  parseInput( input ) {
+    return validate( this.inputSchema, input, `${this.prefix} input` );
   }
 
-  validateInvocationOptions( options ) {
-    validate( options, workflowInvocationOptionsSchema, `Workflow "${this.name}" invocation options` );
+  parseOutput( output ) {
+    return validate( this.outputSchema, output, `${this.prefix} output` );
   }
 }
 
-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` );
-  }
+export class WorkflowValidator extends Validator {
+  static label = capitalize( ComponentType.WORKFLOW );
+  static definitionSchema = workflowSchema;
 
-  validateOutput( output ) {
-    validate( output, this.outputSchema, `Step "${this.name}" output` );
+  parseInvocationOptions( options ) {
+    return validate( workflowInvocationOptionsSchema, options, `${this.prefix} invocation options` );
   }
 }
 
-export class EvaluatorValidator {
-  static validateDefinition( definition ) {
-    validate( definition, evaluatorSchema, 'Evaluator' );
-  }
-  constructor( { name, inputSchema } ) {
-    this.name = name;
-    this.inputSchema = inputSchema;
-  }
+export class StepValidator extends Validator {
+  static label = capitalize( ComponentType.STEP );
+  static definitionSchema = stepSchema;
+}
 
-  validateInput( input ) {
-    validate( input, this.inputSchema, `Evaluator "${this.name}" input` );
-  }
+export class EvaluatorValidator extends Validator {
+  static label = capitalize( ComponentType.EVALUATOR );
+  static definitionSchema = evaluatorSchema;
 
-  validateOutput( output ) {
-    validate( output, evaluatorOutputSchema, `Evaluator "${this.name}" output` );
+  constructor( { name, inputSchema } ) {
+    super( { name, inputSchema, outputSchema: evaluatorOutputSchema } );
   }
 }
 
@@ -96,7 +76,7 @@ export class EvaluatorValidator {
  * @param {object} args - The request arguments
  */
 export function validateRequestPayload( args ) {
-  validate( args, httpRequestSchema, 'Request payload' );
+  validate( httpRequestSchema, args, 'Request payload' );
 };
 
 /**
@@ -104,5 +84,5 @@ export function validateRequestPayload( args ) {
  * @param {object} args - The request arguments
  */
 export function validateExecuteInParallel( args ) {
-  validate( args, executeInParallelSchema, 'ExecuteInParallel' );
+  validate( executeInParallelSchema, args, 'ExecuteInParallel' );
 };

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

@@ -53,10 +53,12 @@ describe( 'interface validators', () => {
     it( 'validates workflow definitions, input, output, and invocation options', () => {
       expect( () => WorkflowValidator.validateDefinition( workflowArgs ) ).not.toThrow();
       const validator = new WorkflowValidator( workflowArgs );
+      const input = { value: 'ok' };
+      const output = { result: 'ok' };
 
-      expect( () => validator.validateInput( { value: 'ok' } ) ).not.toThrow();
-      expect( () => validator.validateOutput( { result: 'ok' } ) ).not.toThrow();
-      expect( () => validator.validateInvocationOptions( {
+      expect( validator.parseInput( input ) ).toEqual( input );
+      expect( validator.parseOutput( output ) ).toEqual( output );
+      expect( () => validator.parseInvocationOptions( {
         detached: true,
         activityOptions: { retry: { maximumAttempts: 1 } },
         context: { info: { workflowId: 'test-workflow' } }
@@ -71,10 +73,10 @@ describe( 'interface validators', () => {
 
       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( {
+      expect( () => validator.parseInput( { value: 1 } ) ).toThrow( ValidationError );
+      expect( () => validator.parseInput( { value: 1 } ) ).toThrow( /Workflow "valid_workflow" input validation failed/ );
+      expect( () => validator.parseOutput( { result: 1 } ) ).toThrow( /Workflow "valid_workflow" output validation failed/ );
+      expect( () => validator.parseInvocationOptions( {
         options: { activityOptions: { retry: { maximumAttempts: 1 } } }
       } ) ).toThrow( /Workflow "valid_workflow" invocation options validation failed/ );
     } );
@@ -84,9 +86,11 @@ describe( 'interface validators', () => {
         name: 'schema_less_workflow',
         fn
       } );
+      const input = { anything: true };
+      const output = { anything: true };
 
-      expect( () => validator.validateInput( { anything: true } ) ).not.toThrow();
-      expect( () => validator.validateOutput( { anything: true } ) ).not.toThrow();
+      expect( validator.parseInput( input ) ).toBe( input );
+      expect( validator.parseOutput( output ) ).toBe( output );
     } );
   } );
 
@@ -94,9 +98,11 @@ describe( 'interface validators', () => {
     it( 'validates step definitions, input, and output', () => {
       expect( () => StepValidator.validateDefinition( stepArgs ) ).not.toThrow();
       const validator = new StepValidator( stepArgs );
+      const input = { value: 'ok' };
+      const output = { result: 'ok' };
 
-      expect( () => validator.validateInput( { value: 'ok' } ) ).not.toThrow();
-      expect( () => validator.validateOutput( { result: 'ok' } ) ).not.toThrow();
+      expect( validator.parseInput( input ) ).toEqual( input );
+      expect( validator.parseOutput( output ) ).toEqual( output );
     } );
 
     it( 'throws ValidationError with useful prefixes for invalid step data', () => {
@@ -106,8 +112,8 @@ describe( 'interface validators', () => {
 
       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/ );
+      expect( () => validator.parseInput( { value: 1 } ) ).toThrow( /Step "valid_step" input validation failed/ );
+      expect( () => validator.parseOutput( { result: 1 } ) ).toThrow( /Step "valid_step" output validation failed/ );
     } );
   } );
 
@@ -115,9 +121,11 @@ describe( 'interface validators', () => {
     it( 'validates evaluator definitions, input, and EvaluationResult output', () => {
       expect( () => EvaluatorValidator.validateDefinition( evaluatorArgs ) ).not.toThrow();
       const validator = new EvaluatorValidator( evaluatorArgs );
+      const input = { value: 'ok' };
+      const output = new EvaluationResult( { value: 'pass', confidence: 1 } );
 
-      expect( () => validator.validateInput( { value: 'ok' } ) ).not.toThrow();
-      expect( () => validator.validateOutput( new EvaluationResult( { value: 'pass', confidence: 1 } ) ) ).not.toThrow();
+      expect( validator.parseInput( input ) ).toEqual( input );
+      expect( validator.parseOutput( output ) ).toEqual( output );
     } );
 
     it( 'throws ValidationError for output schemas and invalid evaluator output', () => {
@@ -128,8 +136,8 @@ describe( 'interface validators', () => {
 
       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(
+      expect( () => validator.parseInput( { value: 1 } ) ).toThrow( /Evaluator "valid_evaluator" input validation failed/ );
+      expect( () => validator.parseOutput( { value: 'pass', confidence: 1 } ) ).toThrow(
         /Evaluator "valid_evaluator" output validation failed/
       );
     } );

package/src/interface/workflow.d.ts

@@ -21,6 +21,8 @@ export type WorkflowContext<
      * It acts as a checkpoint when the workflow gets too long or approaches certain scaling limits.
      *
      * It accepts input with the same schema as the parent workflow function (`inputSchema`).
+     * The next run parses that input like any other workflow start; pass wire-format values if
+     * `inputSchema` transforms are not safe to apply twice.
      *
      * Calling this function must be the last statement in the workflow, accompanied by a `return`:
      *
@@ -38,7 +40,7 @@ export type WorkflowContext<
      * @returns The workflow output type for type-checking; never returns at runtime.
      */
     continueAsNew: InputSchema extends AnyZodSchema ?
-      ( input: z.infer<InputSchema> ) => ( OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void ) :
+      ( input: z.input<InputSchema> ) => ( OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void ) :
       () => ( OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void ),
 
     /**
@@ -122,39 +124,44 @@ export type WorkflowOptions = {
 /**
  * The handler function of a workflow.
  *
- * @param input - The workflow input; it matches the schema defined by `inputSchema`.
+ * @param input - Parsed workflow input (`z.infer<inputSchema>`).
  * @param context - A context object with tools and information.
  *
- * @returns A value matching the schema defined by `outputSchema`.
+ * @returns A value accepted by `outputSchema` before parse (`z.input<outputSchema>`).
  */
 export type WorkflowFunction<
   InputSchema extends AnyZodSchema | undefined = undefined,
   OutputSchema extends AnyZodSchema | undefined = undefined
 > = InputSchema extends AnyZodSchema ?
   ( input: z.infer<InputSchema>, context: WorkflowContext<InputSchema, OutputSchema> ) =>
-  Promise<OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void> :
+  Promise<OutputSchema extends AnyZodSchema ? z.input<OutputSchema> : void> :
   ( input: undefined | null, context: WorkflowContext<InputSchema, OutputSchema> ) =>
-  Promise<OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void>;
+  Promise<OutputSchema extends AnyZodSchema ? z.input<OutputSchema> : void>;
 
 /**
  * A wrapper around the user defined `fn` handler function.
  *
- * It accepts the same input and returns the same value, calling the user function inside.
+ * Callers pass values accepted by `inputSchema` (`z.input`). The wrapper parses input,
+ * invokes `fn`, parses output, and returns `z.infer<outputSchema>`.
  *
  * The second argument is a WorkflowInvocationOptions object, allowing workflows configuration overwrite.
  *
- * It adds input and output validation based on the `inputSchema`, `outputSchema`.
- *
- * @param input - The workflow input; it matches the schema defined by `inputSchema`.
+ * @param input - The workflow input before `inputSchema` parse.
  * @param options - Additional options for the invocation.
- * @returns A value matching the schema defined by `outputSchema`.
+ * @returns The workflow output after `outputSchema` parse.
  */
-export type WorkflowFunctionWrapper<WorkflowFunction extends ( ...args: any ) => any> = // eslint-disable-line @typescript-eslint/no-explicit-any
-  [Parameters<WorkflowFunction>[0]] extends [undefined | null] ?
-    ( input?: undefined | null, options?: WorkflowInvocationOptions ) =>
-    ReturnType<WorkflowFunction> :
-    ( input: Parameters<WorkflowFunction>[0], options?: WorkflowInvocationOptions ) =>
-    ReturnType<WorkflowFunction>;
+export type WorkflowFunctionWrapper<
+  InputSchema extends AnyZodSchema | undefined = undefined,
+  OutputSchema extends AnyZodSchema | undefined = undefined
+> = InputSchema extends AnyZodSchema ?
+  (
+    input: z.input<InputSchema>,
+    options?: WorkflowInvocationOptions
+  ) => Promise<OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void> :
+  (
+    input?: undefined | null,
+    options?: WorkflowInvocationOptions
+  ) => Promise<OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void>;
 
 /**
  * Creates a workflow.
@@ -270,7 +277,7 @@ export type WorkflowFunctionWrapper<WorkflowFunction extends ( ...args: any ) =>
  * @param params.outputSchema - Zod schema for workflow output
  * @param params.fn - A function containing the workflow code
  * @param params.options - Optional workflow options.
- * @returns The same handler function set at `fn` with a different signature
+ * @returns A wrapper that parses input/output around `fn`
  */
 export declare function workflow<
   InputSchema extends AnyZodSchema | undefined = undefined,
@@ -288,4 +295,4 @@ export declare function workflow<
    * while maintaining backward compatibility with existing callers.
    */
   aliases?: string[];
-} ): WorkflowFunctionWrapper<WorkflowFunction<InputSchema, OutputSchema>>;
+} ): WorkflowFunctionWrapper<InputSchema, OutputSchema>;

package/src/interface/workflow.js

@@ -10,17 +10,6 @@ import { createWorkflow } from '#helpers/component';
 import { FatalError } from '#errors';
 import * as C from '#consts';
 
-/**
- * Execute the workflow without temporal, using the fn handler function.
- * This is important to allow for workflows to have unit tests
- */
-const executeWithoutTemporal = async ( { input, validator, handler, contextOverrides = {} } ) => {
-  validator.validateInput( input );
-  const output = await handler( input, deepMerge( WorkflowContext.build(), contextOverrides ) );
-  validator.validateOutput( output );
-  return output;
-};
-
 /**
  * Add a global dispatcher function to be used to invoke activities.
  * This will replace direct activity invocation in the user code by the webpack loader.
@@ -51,12 +40,14 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
   const disableTrace = options.disableTrace ?? defaultOptions.disableTrace;
   const validator = new WorkflowValidator( { name, inputSchema, outputSchema } );
 
-  const handler = async ( input, invocationOptions = {} ) => {
-    validator.validateInvocationOptions( invocationOptions );
+  const handler = async ( input, rawInvocationOptions = {} ) => {
+    const invocationOptions = validator.parseInvocationOptions( rawInvocationOptions );
 
     // If called outside Temporal workflow context, just execute the handler function
     if ( !inWorkflowContext() ) {
-      return executeWithoutTemporal( { input, validator, handler: fn, contextOverrides: invocationOptions?.context } );
+      return validator.parseOutput(
+        await fn( validator.parseInput( input ), deepMerge( WorkflowContext.build(), invocationOptions?.context ) )
+      );
     }
 
     const { workflowId, runId, memo, root } = workflowInfo();
@@ -99,9 +90,7 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
     };
 
     try {
-      validator.validateInput( input );
-      const output = await fn( input, WorkflowContext.build() );
-      validator.validateOutput( output );
+      const output = validator.parseOutput( await fn( validator.parseInput( input ), WorkflowContext.build() ) );
 
       return { [C.WORKFLOW_WRAPPER_VERSION_FIELD]: 1, output, ...traceDestinations };
     } catch ( error ) {

package/src/interface/workflow.spec.js

@@ -15,9 +15,9 @@ const executeChildMock = vi.hoisted( () => vi.fn() );
 const workflowInfoMock = vi.hoisted( () => vi.fn() );
 const continueAsNewMock = vi.hoisted( () => vi.fn() );
 const validateDefinitionMock = vi.hoisted( () => vi.fn() );
-const validateInputMock = vi.hoisted( () => vi.fn() );
-const validateOutputMock = vi.hoisted( () => vi.fn() );
-const validateInvocationOptionsMock = vi.hoisted( () => vi.fn() );
+const parseInputMock = vi.hoisted( () => vi.fn( input => input ) );
+const parseOutputMock = vi.hoisted( () => vi.fn( output => output ) );
+const parseInvocationOptionsMock = vi.hoisted( () => vi.fn( options => options ) );
 const validatorConstructorMock = vi.hoisted( () => vi.fn() );
 const createWorkflowMock = vi.hoisted( () => vi.fn( ( { handler } ) => handler ) );
 
@@ -29,9 +29,9 @@ vi.mock( './validations/index.js', () => {
 
     constructor( ...args ) {
       validatorConstructorMock( ...args );
-      this.validateInput = validateInputMock;
-      this.validateOutput = validateOutputMock;
-      this.validateInvocationOptions = validateInvocationOptionsMock;
+      this.parseInput = parseInputMock;
+      this.parseOutput = parseOutputMock;
+      this.parseInvocationOptions = parseInvocationOptionsMock;
     }
   }
 
@@ -210,9 +210,9 @@ describe( 'workflow()', () => {
         value: 'test-workflow-ok',
         extra: 'custom'
       } );
-      expect( validateInvocationOptionsMock ).toHaveBeenCalledWith( { context: { extra: 'custom' } } );
-      expect( validateInputMock ).toHaveBeenCalledWith( { suffix: '-ok' } );
-      expect( validateOutputMock ).toHaveBeenCalledWith( { value: 'test-workflow-ok', extra: 'custom' } );
+      expect( parseInvocationOptionsMock ).toHaveBeenCalledWith( { context: { extra: 'custom' } } );
+      expect( parseInputMock ).toHaveBeenCalledWith( { suffix: '-ok' } );
+      expect( parseOutputMock ).toHaveBeenCalledWith( { value: 'test-workflow-ok', extra: 'custom' } );
       expect( workflowInfoMock ).not.toHaveBeenCalled();
       expect( proxyActivitiesMock ).not.toHaveBeenCalled();
     } );
@@ -220,7 +220,7 @@ describe( 'workflow()', () => {
     it( 'does not run fn when plain function input validation fails', async () => {
       const { workflow } = await import( './workflow.js' );
       const error = new ValidationError( 'invalid input' );
-      validateInputMock.mockImplementationOnce( () => {
+      parseInputMock.mockImplementationOnce( () => {
         throw error;
       } );
       const fn = vi.fn();
@@ -234,13 +234,13 @@ describe( 'workflow()', () => {
 
       await expect( wf( { value: 1 } ) ).rejects.toBe( error );
       expect( fn ).not.toHaveBeenCalled();
-      expect( validateOutputMock ).not.toHaveBeenCalled();
+      expect( parseOutputMock ).not.toHaveBeenCalled();
     } );
 
     it( 'propagates plain function output validation errors after fn runs', async () => {
       const { workflow } = await import( './workflow.js' );
       const error = new ValidationError( 'invalid output' );
-      validateOutputMock.mockImplementationOnce( () => {
+      parseOutputMock.mockImplementationOnce( () => {
         throw error;
       } );
       const output = { result: 1 };
@@ -257,7 +257,7 @@ describe( 'workflow()', () => {
       expect( fn ).toHaveBeenCalledWith( { value: 'ok' }, expect.objectContaining( {
         info: { workflowId: 'test-workflow', runId: 'test-run' }
       } ) );
-      expect( validateOutputMock ).toHaveBeenCalledWith( output );
+      expect( parseOutputMock ).toHaveBeenCalledWith( output );
     } );
   } );
 
@@ -294,7 +294,7 @@ describe( 'workflow()', () => {
           retry: { maximumAttempts: 7 }
         }
       } ) ).resolves.toEqual( { child: 'ok' } );
-      expect( validateInvocationOptionsMock ).toHaveBeenCalledWith( {
+      expect( parseInvocationOptionsMock ).toHaveBeenCalledWith( {
         detached: true,
         context: { testOnly: true },
         activityOptions: {
@@ -543,7 +543,7 @@ describe( 'workflow()', () => {
         fn: async () => ( { result: 1 } )
       } ) );
 
-      validateInputMock.mockImplementationOnce( () => {
+      parseInputMock.mockImplementationOnce( () => {
         throw inputError;
       } );
       await expect( wf( { value: 1 } ) ).rejects.toBe( inputError );
@@ -551,7 +551,7 @@ describe( 'workflow()', () => {
 
       delete globalThis[INVOKE_ACTIVITY_SYMBOL];
       setWorkflowInfo( { workflowType: 'runtime_validation_wf', memo: {} } );
-      validateOutputMock.mockImplementationOnce( () => {
+      parseOutputMock.mockImplementationOnce( () => {
         throw outputError;
       } );
       await expect( wf( { value: 'ok' } ) ).rejects.toBe( outputError );