@output.ai/core 0.0.13 → 0.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "description": "The core module of the output framework",
   "type": "module",
   "main": "src/index.js",
@@ -27,7 +27,6 @@
     "@babel/types": "7.28.4",
     "@temporalio/worker": "1.13.0",
     "@temporalio/workflow": "1.13.0",
-    "ajv": "8.17.1",
     "zod": "4.1.9"
   },
   "imports": {

package/src/index.d.ts

@@ -1,175 +1,100 @@
-// JSON Schema → TypeScript type mapping (subset sufficient for IntelliSense)
-type Simplify<T> = { [K in keyof T]: T[K] };
-type EnumValues = readonly ( string | number | boolean | null )[];
+// Import Zod types for dual schema support
+import type { z } from 'zod';
 
-type JSONSchema = {
-  type?: 'string' | 'number' | 'integer' | 'boolean' | 'null' | 'object' | 'array';
-  enum?: EnumValues;
-  const?: string | number | boolean | null;
-  anyOf?: readonly JSONSchema[];
-  oneOf?: readonly JSONSchema[];
-  allOf?: readonly JSONSchema[];
-  // object
-  properties?: { [key: string]: JSONSchema };
-  required?: readonly string[];
-  additionalProperties?: boolean | JSONSchema;
-  // array
-  items?: JSONSchema | readonly JSONSchema[];
-  // ignore $ref & others for typing purposes
-  $ref?: string;
-} & Record<string, unknown>;
+// Re-export Zod for consumers to use
+export { z } from 'zod';
 
-type UnionToIntersection<U> = ( U extends unknown ? ( k: U ) => void : never ) extends ( k: infer I ) => void ? I : never;
-
-type FromEnum<S> = S extends { enum: infer E extends EnumValues } ? E[number] : never;
-type FromConst<S> = S extends { const: infer C } ? C : never;
-
-type FromPrimitive<S> =
-  S extends { type: 'string' } ? string :
-  S extends { type: 'number' | 'integer' } ? number :
-  S extends { type: 'boolean' } ? boolean :
-  S extends { type: 'null' } ? null :
-  never;
-
-type ObjectProps<S extends JSONSchema> = S extends { properties: infer P extends Record<string, JSONSchema> }
-  ? { [K in keyof P]: FromSchema<P[K]> }
-  : Record<never, never>;
-
-type ObjectRequiredKeys<S extends JSONSchema> = S extends { required: readonly ( infer R )[] }
-  ? Extract<R & string, keyof ObjectProps<S>>
-  : never;
-
-type ObjectFrom<S extends JSONSchema> = Simplify<
-  Pick<ObjectProps<S>, ObjectRequiredKeys<S>> &
-  Partial<Omit<ObjectProps<S>, ObjectRequiredKeys<S>>>
->;
-
-type ArrayFrom<S extends JSONSchema> = S extends { items: infer I }
-  ? I extends readonly unknown[]
-    ? FromSchema<I[number]>[]
-    : FromSchema<I>[]
-  : unknown[];
-
-export type FromSchema<S extends JSONSchema> =
-  // combinators first
-  S extends { anyOf: infer A extends readonly JSONSchema[] } ? FromSchema<A[number]> :
-  S extends { oneOf: infer A extends readonly JSONSchema[] } ? FromSchema<A[number]> :
-  S extends { allOf: infer A extends readonly JSONSchema[] } ? UnionToIntersection<FromSchema<A[number]>> :
-  // enum/const
-  FromEnum<S> extends never ? ( FromConst<S> extends never ? (
-    // object (explicit or by presence of properties)
-    S extends { type: 'object' } | { properties: Record<string, JSONSchema> } ? ObjectFrom<S> :
-    // array
-    S extends { type: 'array' } ? ArrayFrom<S> :
-    // primitives
-    FromPrimitive<S> extends never ? unknown : FromPrimitive<S>
-  ) : FromConst<S> ) : FromEnum<S>;
-
-export type OutputFrom<O extends JSONSchema> = FromSchema<O>;
-
-// Utility to strip readonly from inferred types
-/** Recursively removes readonly modifiers from object and array types. */
-type DeepMutable<T> =
-  T extends readonly ( infer U )[] ? DeepMutable<U>[] :
-  T extends object ? { -readonly [K in keyof T]: DeepMutable<T[K]> } :
-  T;
+/**
+ * Type alias for any Zod schema type.
+ *
+ * Note: The use of `any` here is intentional and necessary. Zod's ZodType has three
+ * generic parameters (Output, Def, Input) that vary based on the specific schema type.
+ * When we want to accept ANY Zod schema (string, number, object, etc.), we must use
+ * `any` for these parameters. Using `unknown` would be too restrictive and would
+ * break Zod's type inference system.
+ *
+ * This is a common pattern in TypeScript when dealing with highly generic types,
+ * and Zod itself uses this pattern internally.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyZodSchema = z.ZodType<any, any, any>;
 
 /*
- * There is 4 overrides of the "step" function"
+ * There are 4 overloads of the "step" function:
  * - with fn receiving input and returning output;
  * - with fn receiving input and returning void;
- * - with fn receiving void and returning outout;
+ * - with fn receiving void and returning output;
  * - with fn receiving void and returning void;
  */
 
 /**
- * @callback StepFn
- * @param {any} input - The input, defined by the inputSchema
- * @returns {any} The output defined by the outputSchema
- */
-
-/**
- * Creates logical unit of work, called "step", which will be invoked from workflows.
+ * Creates logical unit of work with Zod schemas for both input and output.
  *
  * @param {object} options - Step options
  * @param {string} options.name - Human-readable step name (only letters, numbers and "_")
  * @param {string} [options.description] - Description of the step
- * @param {JSONSchema} options.inputSchema - JSON Schema for the fn input, will infer a TS type
- * @param {JSONSchema} options.outputSchema - JSON Schema for the fn output, will infer a TS type
- * @param {StepFn} options.fn - The function logic
- * @returns {StepFn} The options.fn function
+ * @param {z.ZodType} options.inputSchema - Zod schema for the fn input
+ * @param {z.ZodType} options.outputSchema - Zod schema for the fn output
+ * @param {function} options.fn - The function logic: `(input: z.infer<InputSchema>) => Promise<z.infer<OutputSchema>>`
+ * @returns {function} Function with signature: `(input: z.infer<InputSchema>) => Promise<z.infer<OutputSchema>>`
  */
 export async function step<
-  const InputSchema extends JSONSchema,
-  const OutputSchema extends JSONSchema
+  InputSchema extends AnyZodSchema,
+  OutputSchema extends AnyZodSchema
 >( options: {
   name: string;
   description?: string;
   inputSchema: InputSchema;
   outputSchema: OutputSchema;
-  fn: ( input: DeepMutable<FromSchema<InputSchema>> ) => Promise<DeepMutable<FromSchema<OutputSchema>>>;
-} ): ( input: DeepMutable<FromSchema<InputSchema>> ) => Promise<DeepMutable<FromSchema<OutputSchema>>>;
-
-/**
- * @callback InputOnlyStepFn
- * @param {any} input - The input, defined by the inputSchema
- */
+  fn: ( input: z.infer<InputSchema> ) => Promise<z.infer<OutputSchema>>;
+} ): ( input: z.infer<InputSchema> ) => Promise<z.infer<OutputSchema>>;
 
 /**
- * Creates logical unit of work, called "step", which will be invoked from workflows.
+ * Creates logical unit of work with Zod schema for input only.
  *
  * @param {object} options - Step options
  * @param {string} options.name - Human-readable step name (only letters, numbers and "_")
  * @param {string} [options.description] - Description of the step
- * @param {JSONSchema} options.inputSchema - JSON Schema for the fn input, will infer a TS type
- * @param {InputOnlyStepFn} options.fn - The function logic
- * @returns {InputOnlyStepFn} The options.fn function
+ * @param {z.ZodType} options.inputSchema - Zod schema for the fn input
+ * @param {function} options.fn - The function logic: `(input: z.infer<InputSchema>) => Promise<void>`
+ * @returns {function} Function with signature: `(input: z.infer<InputSchema>) => Promise<void>`
  */
 export async function step<
-  const InputSchema extends JSONSchema
+  InputSchema extends AnyZodSchema
 >( options: {
   name: string;
   description?: string;
   inputSchema: InputSchema;
-  fn: ( input: DeepMutable<FromSchema<InputSchema>> ) => Promise<void>;
-} ): ( input: DeepMutable<FromSchema<InputSchema>> ) => Promise<void>;
+  fn: ( input: z.infer<InputSchema> ) => Promise<void>;
+} ): ( input: z.infer<InputSchema> ) => Promise<void>;
 
 /**
- * @callback OutputOnlyStepFn
- * @returns {any} The output defined by the outputSchema
- */
-
-/**
- * Creates logical unit of work, called "step", which will be invoked from workflows.
+ * Creates logical unit of work with Zod schema for output only.
  *
  * @param {object} options - Step options
  * @param {string} options.name - Human-readable step name (only letters, numbers and "_")
  * @param {string} [options.description] - Description of the step
- * @param {JSONSchema} options.outputSchema - JSON Schema for the fn output, will infer a TS type
- * @param {OutputOnlyStepFn} options.fn - The function logic
- * @returns {OutputOnlyStepFn} The options.fn function
+ * @param {z.ZodType} options.outputSchema - Zod schema for the fn output
+ * @param {function} options.fn - The function logic: `() => Promise<z.infer<OutputSchema>>`
+ * @returns {function} Function with signature: `() => Promise<z.infer<OutputSchema>>`
  */
 export async function step<
-  const OutputSchema extends JSONSchema
+  OutputSchema extends AnyZodSchema
 >( options: {
   name: string;
   description?: string;
   outputSchema: OutputSchema;
-  fn: () => Promise<DeepMutable<FromSchema<OutputSchema>>>;
-} ): () => Promise<DeepMutable<FromSchema<OutputSchema>>>;
+  fn: () => Promise<z.infer<OutputSchema>>;
+} ): () => Promise<z.infer<OutputSchema>>;
 
 /**
- * @callback VoidStepFn
- */
-
-/**
- * Creates logical unit of work, called "step", which will be invoked from workflows.
+ * Creates logical unit of work without schemas.
  *
  * @param {object} options - Step options
  * @param {string} options.name - Human-readable step name (only letters, numbers and "_")
  * @param {string} [options.description] - Description of the step
- * @param {VoidStepFn} options.fn - The function logic
- * @returns {VoidStepFn} The options.fn function
+ * @param {function} options.fn - The function logic: `() => Promise<void>`
+ * @returns {function} Function with signature: `() => Promise<void>`
  */
 export async function step( options: {
   name: string;
@@ -178,103 +103,81 @@ export async function step( options: {
 } ): () => Promise<void>;
 
 /*
- * There is 4 overrides of the "workflow" function"
+ * There are 4 overloads of the "workflow" function:
  * - with fn receiving input and returning output;
  * - with fn receiving input and returning void;
- * - with fn receiving void and returning outout;
+ * - with fn receiving void and returning output;
  * - with fn receiving void and returning void;
  */
 
 /**
- * @callback WorkflowFn
- * @param {any} input - The input, defined by the inputSchema
- * @returns {any} The output defined by the outputSchema
- */
-
-/**
- * Creates a workflow orchestrator which can invoke steps.
+ * Creates a workflow orchestrator with Zod schemas for both input and output.
  *
  * @param {object} options - Workflow options
  * @param {string} options.name - Unique workflow name
  * @param {string} [options.description] - Description of the workflow
- * @param {JSONSchema} [options.inputSchema] - JSON Schema for workflow input
- * @param {JSONSchema} [options.outputSchema] - JSON Schema for workflow output
- * @param {WorkflowFn} options.fn - Workflow logic
- * @returns {WorkflowFn} Callable workflow function
+ * @param {z.ZodType} options.inputSchema - Zod schema for workflow input
+ * @param {z.ZodType} options.outputSchema - Zod schema for workflow output
+ * @param {function} options.fn - Workflow logic: `(input: z.infer<InputSchema>) => Promise<z.infer<OutputSchema>>`
+ * @returns {function} Callable workflow function: `(input: z.infer<InputSchema>) => Promise<z.infer<OutputSchema>>`
  */
 export function workflow<
-  const InputSchema extends JSONSchema,
-  const OutputSchema extends JSONSchema
+  InputSchema extends AnyZodSchema,
+  OutputSchema extends AnyZodSchema
 >( options : {
   name: string,
   description?: string,
   inputSchema: InputSchema,
   outputSchema: OutputSchema,
-  fn: ( input: DeepMutable<FromSchema<InputSchema>> ) => Promise<DeepMutable<FromSchema<OutputSchema>>>
-} ): ( input: DeepMutable<FromSchema<InputSchema>> ) => Promise<DeepMutable<FromSchema<OutputSchema>>>;
+  fn: ( input: z.infer<InputSchema> ) => Promise<z.infer<OutputSchema>>
+} ): ( input: z.infer<InputSchema> ) => Promise<z.infer<OutputSchema>>;
 
 /**
- * @callback InputOnlyWorkflowFn
- * @param {any} input - The input, defined by the inputSchema
- */
-
-/**
- * Creates a workflow orchestrator which can invoke steps.
+ * Creates a workflow orchestrator with Zod schema for input only.
  *
  * @param {object} options - Workflow options
  * @param {string} options.name - Unique workflow name
  * @param {string} [options.description] - Description of the workflow
- * @param {JSONSchema} [options.inputSchema] - JSON Schema for workflow input
- * @param {InputOnlyWorkflowFn} options.fn - Workflow logic
- * @returns {InputOnlyWorkflowFn} Callable workflow function
+ * @param {z.ZodType} options.inputSchema - Zod schema for workflow input
+ * @param {function} options.fn - Workflow logic: `(input: z.infer<InputSchema>) => Promise<void>`
+ * @returns {function} Callable workflow function: `(input: z.infer<InputSchema>) => Promise<void>`
  */
 export function workflow<
-  const InputSchema extends JSONSchema
+  InputSchema extends AnyZodSchema
 >( options : {
   name: string,
   description?: string,
   inputSchema: InputSchema,
-  fn: ( input: DeepMutable<FromSchema<InputSchema>> ) => Promise<void>
-} ): ( input: DeepMutable<FromSchema<InputSchema>> ) => Promise<void>;
+  fn: ( input: z.infer<InputSchema> ) => Promise<void>
+} ): ( input: z.infer<InputSchema> ) => Promise<void>;
 
 /**
- * @callback OutputOnlyWorkflowFn
- * @returns {any} The output defined by the outputSchema
- */
-
-/**
- * Creates a workflow orchestrator which can invoke steps.
+ * Creates a workflow orchestrator with Zod schema for output only.
  *
  * @param {object} options - Workflow options
  * @param {string} options.name - Unique workflow name
  * @param {string} [options.description] - Description of the workflow
- * @param {JSONSchema} [options.outputSchema] - JSON Schema for workflow output
- * @param {OutputOnlyWorkflowFn} options.fn - Workflow logic
- * @returns {OutputOnlyWorkflowFn} Callable workflow function
+ * @param {z.ZodType} options.outputSchema - Zod schema for workflow output
+ * @param {function} options.fn - Workflow logic: `() => Promise<z.infer<OutputSchema>>`
+ * @returns {function} Callable workflow function: `() => Promise<z.infer<OutputSchema>>`
  */
 export function workflow<
-  const OutputSchema extends JSONSchema
+  OutputSchema extends AnyZodSchema
 >( options : {
   name: string,
   description?: string,
   outputSchema: OutputSchema,
-  fn: () => Promise<DeepMutable<FromSchema<OutputSchema>>>
-} ): () => Promise<DeepMutable<FromSchema<OutputSchema>>>;
-
-/**
- * @callback VoidWorkflowFn
- * @param {any} input - The input, defined by the inputSchema
- * @returns {any} The output defined by the outputSchema
- */
+  fn: () => Promise<z.infer<OutputSchema>>
+} ): () => Promise<z.infer<OutputSchema>>;
 
 /**
- * Creates a workflow orchestrator which can invoke steps.
+ * Creates a workflow orchestrator without schemas.
  *
  * @param {object} options - Workflow options
  * @param {string} options.name - Unique workflow name
  * @param {string} [options.description] - Description of the workflow
- * @param {VoidWorkflowFn} options.fn - Workflow logic
- * @returns {VoidWorkflowFn} Callable workflow function
+ * @param {function} options.fn - Workflow logic: `() => Promise<void>`
+ * @returns {function} Callable workflow function: `() => Promise<void>`
  */
 export function workflow( options : {
   name: string,

package/src/index.js

@@ -2,5 +2,6 @@ import { step } from './interface/step.js';
 import { workflow } from './interface/workflow.js';
 import { createWebhook } from './interface/webhook.js';
 import { FatalError, ValidationError } from './errors.js';
+import { z } from 'zod';
 
-export { step, workflow, createWebhook, FatalError, ValidationError };
+export { step, workflow, createWebhook, FatalError, ValidationError, z };

package/src/interface/schema_utils.js

@@ -0,0 +1,34 @@
+import { ValidationError } from '#errors';
+
+/**
+ * Detects if a schema is a Zod schema object
+ * @param {unknown} schema - The schema to check
+ * @returns {boolean} True if the schema is a Zod schema
+ */
+export function isZodSchema( schema ) {
+  return schema &&
+         typeof schema === 'object' &&
+         '_def' in schema &&
+         typeof schema.parse === 'function' &&
+         typeof schema.parseAsync === 'function';
+}
+
+/**
+ * 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/schema_utils.spec.js

@@ -0,0 +1,67 @@
+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/step.js

@@ -1,17 +1,23 @@
 import { setMetadata } from './metadata.js';
 import { validateStep } from './validations/static.js';
-import { validateStepInput, validateStepOutput } from './validations/runtime.js';
+import { validateWithSchema } from './schema_utils.js';
 
 export function step( { name, description, inputSchema, outputSchema, fn } ) {
-  validateStep( { name, description, inputSchema, outputSchema, fn } );
+  validateStep( {
+    name,
+    description,
+    inputSchema,
+    outputSchema,
+    fn
+  } );
+
   const wrapper = async input => {
-    if ( inputSchema ) {
-      validateStepInput( name, inputSchema, input );
-    }
+    validateWithSchema( inputSchema, input, `Step ${name} input` );
+
     const output = await fn( input );
-    if ( outputSchema ) {
-      validateStepOutput( name, outputSchema, output );
-    }
+
+    validateWithSchema( outputSchema, output, `Step ${name} output` );
+
     return output;
   };
 

package/src/interface/validations/static.js

@@ -1,26 +1,27 @@
-import { ajv } from './ajv_provider.js';
 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 {};
 
-// Custom validation for zod, to be used when validating JSONSchema def with ajv
-const refineJsonSchema = ( value, ctx ) => {
-  if ( value && !ajv.validateSchema( value ) ) {
-    ctx.addIssue( {
-      code: 'invalid_format',
-      message: ajv.errorsText( ajv.errors )
-    } );
+const refineSchema = ( value, ctx ) => {
+  if ( !value || isZodSchema( value ) ) {
+    return;
   }
+
+  ctx.addIssue( {
+    code: 'invalid_type',
+    message: 'Schema must be a Zod schema'
+  } );
 };
 
 const stepAndWorkflowSchema = z.object( {
   name: z.string().regex( /^[a-z_][a-z0-9_]*$/i ),
   description: z.string().optional(),
-  inputSchema: z.looseObject( {} ).optional().superRefine( refineJsonSchema ),
-  outputSchema: z.looseObject( {} ).optional().superRefine( refineJsonSchema ),
+  inputSchema: z.any().optional().superRefine( refineSchema ),
+  outputSchema: z.any().optional().superRefine( refineSchema ),
   fn: z.function()
 } );
 

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

@@ -1,11 +1,12 @@
 import { describe, it, expect } from 'vitest';
+import { z } from 'zod';
 import { validateStep, validateWorkflow, validateCreateWebhook, StaticValidationError } from './static.js';
 
 const validArgs = Object.freeze( {
   name: 'valid_name',
   description: 'desc',
-  inputSchema: { type: 'object' },
-  outputSchema: { type: 'object' },
+  inputSchema: z.object( {} ),
+  outputSchema: z.object( {} ),
   fn: () => {}
 } );
 
@@ -35,26 +36,24 @@ describe( 'interface/validator', () => {
       expect( () => validateStep( { ...validArgs, description: 10 } ) ).toThrow( error );
     } );
 
-    it( 'rejects non-object inputSchema', () => {
-      const error = new StaticValidationError( '✖ Invalid input: expected object, received string\n  → at inputSchema' );
-      expect( () => validateStep( { ...validArgs, inputSchema: 'not-an-object' } ) ).toThrow( error );
+    it( 'rejects non-Zod inputSchema', () => {
+      const error = new StaticValidationError( '✖ Schema must be a Zod schema\n  → at inputSchema' );
+      expect( () => validateStep( { ...validArgs, inputSchema: 'not-a-zod-schema' } ) ).toThrow( error );
     } );
 
-    it( 'rejects invalid inputSchema structure', () => {
-      const error = new StaticValidationError( '✖ data/type must be equal to one of the allowed values, \
-data/type must be array, data/type must match a schema in anyOf\n  → at inputSchema' );
-      expect( () => validateStep( { ...validArgs, inputSchema: { type: 1 } } ) ).toThrow( error );
+    it( 'rejects JSON Schema inputSchema', () => {
+      const error = new StaticValidationError( '✖ Schema must be a Zod schema\n  → at inputSchema' );
+      expect( () => validateStep( { ...validArgs, inputSchema: { type: 'object' } } ) ).toThrow( error );
     } );
 
-    it( 'rejects non-object outputSchema', () => {
-      const error = new StaticValidationError( '✖ Invalid input: expected object, received number\n  → at outputSchema' );
+    it( 'rejects non-Zod outputSchema', () => {
+      const error = new StaticValidationError( '✖ Schema must be a Zod schema\n  → at outputSchema' );
       expect( () => validateStep( { ...validArgs, outputSchema: 10 } ) ).toThrow( error );
     } );
 
-    it( 'rejects invalid outputSchema structure', () => {
-      const error = new StaticValidationError( '✖ data/type must be equal to one of the allowed values, \
-data/type must be array, data/type must match a schema in anyOf\n  → at outputSchema' );
-      expect( () => validateStep( { ...validArgs, outputSchema: { type: 1 } } ) ).toThrow( error );
+    it( 'rejects JSON Schema outputSchema', () => {
+      const error = new StaticValidationError( '✖ Schema must be a Zod schema\n  → at outputSchema' );
+      expect( () => validateStep( { ...validArgs, outputSchema: { type: 'string' } } ) ).toThrow( error );
     } );
 
     it( 'rejects missing fn', () => {