@output.ai/core 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {

package/src/index.d.ts

@@ -477,6 +477,11 @@ export class EvaluationResult {
    * @returns The evaluation result reasoning
    */
   get reasoning(): string;
+
+  /**
+   * @returns A zod schema representing this class
+   */
+  get schema(): string;
 }
 
 /**

package/src/interface/evaluator.js

@@ -34,11 +34,17 @@ export class EvaluationResult {
    */
   reasoning = undefined;
 
-  static #schema = z.object( {
-    value: z.any(),
-    confidence: z.number(),
-    reasoning: z.string().optional()
-  } );
+  static get valueSchema() {
+    return z.any();
+  };
+
+  static get schema() {
+    return z.object( {
+      value: this.valueSchema,
+      confidence: z.number(),
+      reasoning: z.string().optional()
+    } );
+  };
 
   /**
    * @constructor
@@ -48,7 +54,7 @@ export class EvaluationResult {
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
   constructor( args ) {
-    const result = EvaluationResult.#schema.safeParse( args );
+    const result = this.constructor.schema.safeParse( args );
     if ( result.error ) {
       throw new EvaluationResultValidationError( z.prettifyError( result.error ) );
     }
@@ -64,7 +70,9 @@ export class EvaluationResult {
  * @property {string} value - The evaluation result value
  */
 export class EvaluationStringResult extends EvaluationResult {
-  static #valueSchema = z.string();
+  static get valueSchema() {
+    return z.string();
+  };
 
   /**
    * @constructor
@@ -74,10 +82,6 @@ export class EvaluationStringResult extends EvaluationResult {
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
   constructor( args ) {
-    const result = EvaluationStringResult.#valueSchema.safeParse( args.value );
-    if ( result.error ) {
-      throw new EvaluationResultValidationError( z.prettifyError( result.error ) );
-    }
     super( args );
   }
 };
@@ -88,7 +92,9 @@ export class EvaluationStringResult extends EvaluationResult {
  * @property {boolean} value - The evaluation result value
  */
 export class EvaluationBooleanResult extends EvaluationResult {
-  static #valueSchema = z.boolean();
+  static get valueSchema() {
+    return z.boolean();
+  };
 
   /**
    * @constructor
@@ -98,10 +104,6 @@ export class EvaluationBooleanResult extends EvaluationResult {
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
   constructor( args ) {
-    const result = EvaluationBooleanResult.#valueSchema.safeParse( args.value );
-    if ( result.error ) {
-      throw new EvaluationResultValidationError( z.prettifyError( result.error ) );
-    }
     super( args );
   }
 };
@@ -112,7 +114,9 @@ export class EvaluationBooleanResult extends EvaluationResult {
  * @property {number} value - The evaluation result value
  */
 export class EvaluationNumberResult extends EvaluationResult {
-  static #valueSchema = z.number();
+  static get valueSchema() {
+    return z.number();
+  };
 
   /**
    * @constructor
@@ -122,10 +126,6 @@ export class EvaluationNumberResult extends EvaluationResult {
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
   constructor( args ) {
-    const result = EvaluationNumberResult.#valueSchema.safeParse( args.value );
-    if ( result.error ) {
-      throw new EvaluationResultValidationError( z.prettifyError( result.error ) );
-    }
     super( args );
   }
 };
@@ -138,7 +138,7 @@ export function evaluator( { name, description, inputSchema, fn, options } ) {
 
     const output = await fn( input );
 
-    if ( !output instanceof EvaluationResult ) {
+    if ( !( output instanceof EvaluationResult ) ) {
       throw new ValidationError( 'Evaluators must return an EvaluationResult' );
     }
 

package/src/interface/evaluator.spec.js

@@ -0,0 +1,103 @@
+import { describe, it, expect } from 'vitest';
+import {
+  EvaluationResult,
+  EvaluationStringResult,
+  EvaluationNumberResult,
+  EvaluationBooleanResult
+} from './evaluator.js';
+import { ValidationError } from '#errors';
+
+describe( 'interface/evaluator - EvaluationResult classes', () => {
+  describe( 'class inheritance', () => {
+    it( 'subclasses extend EvaluationResult', () => {
+      const s = new EvaluationStringResult( { value: 'ok', confidence: 0.8 } );
+      const n = new EvaluationNumberResult( { value: 42, confidence: 1 } );
+      const b = new EvaluationBooleanResult( { value: true, confidence: 0.5 } );
+
+      expect( s ).toBeInstanceOf( EvaluationResult );
+      expect( n ).toBeInstanceOf( EvaluationResult );
+      expect( b ).toBeInstanceOf( EvaluationResult );
+    } );
+  } );
+
+  describe( 'constructor payload validation', () => {
+    it( 'base class validates presence and types of common fields', () => {
+      // valid
+      const base = new EvaluationResult( { value: { any: 'thing' }, confidence: 0.1 } );
+      expect( base.value ).toEqual( { any: 'thing' } );
+      expect( base.confidence ).toBe( 0.1 );
+      expect( base.reasoning ).toBeUndefined();
+
+      // invalid: missing confidence
+      expect( () => new EvaluationResult( { value: 1 } ) ).toThrow( ValidationError );
+
+      // invalid: confidence wrong type
+      expect( () => new EvaluationResult( { value: 'x', confidence: 'nope' } ) ).toThrow( ValidationError );
+
+      // invalid: reasoning wrong type
+      expect( () => new EvaluationResult( { value: 'x', confidence: 1, reasoning: 123 } ) ).toThrow( ValidationError );
+    } );
+
+    it( 'string subclass enforces string value', () => {
+      // valid
+      const r = new EvaluationStringResult( { value: 'hello', confidence: 0.9 } );
+      expect( r.value ).toBe( 'hello' );
+
+      // invalid
+      expect( () => new EvaluationStringResult( { value: 123, confidence: 0.2 } ) ).toThrow( ValidationError );
+    } );
+
+    it( 'number subclass enforces number value', () => {
+      // valid
+      const r = new EvaluationNumberResult( { value: 123, confidence: 0.2 } );
+      expect( r.value ).toBe( 123 );
+
+      // invalid
+      expect( () => new EvaluationNumberResult( { value: 'nope', confidence: 0.2 } ) ).toThrow( ValidationError );
+    } );
+
+    it( 'boolean subclass enforces boolean value', () => {
+      // valid
+      const r = new EvaluationBooleanResult( { value: true, confidence: 1 } );
+      expect( r.value ).toBe( true );
+
+      // invalid
+      expect( () => new EvaluationBooleanResult( { value: 'nope', confidence: 0.2 } ) ).toThrow( ValidationError );
+    } );
+  } );
+
+  describe( 'static schema getter', () => {
+    it( 'base schema accepts any value and optional reasoning', () => {
+      const ok = EvaluationResult.schema.safeParse( { value: 'x', confidence: 0.5, reasoning: 'why' } );
+      expect( ok.success ).toBe( true );
+
+      const ok2 = EvaluationResult.schema.safeParse( { value: 123, confidence: 0.5 } );
+      expect( ok2.success ).toBe( true );
+    } );
+
+    it( 'string schema requires value to be string', () => {
+      const ok = EvaluationStringResult.schema.safeParse( { value: 'x', confidence: 1 } );
+      expect( ok.success ).toBe( true );
+
+      const bad = EvaluationStringResult.schema.safeParse( { value: 123, confidence: 1 } );
+      expect( bad.success ).toBe( false );
+    } );
+
+    it( 'number schema requires value to be number', () => {
+      const ok = EvaluationNumberResult.schema.safeParse( { value: 10, confidence: 1 } );
+      expect( ok.success ).toBe( true );
+
+      const bad = EvaluationNumberResult.schema.safeParse( { value: '10', confidence: 1 } );
+      expect( bad.success ).toBe( false );
+    } );
+
+    it( 'boolean schema requires value to be boolean', () => {
+      const ok = EvaluationBooleanResult.schema.safeParse( { value: false, confidence: 1 } );
+      expect( ok.success ).toBe( true );
+
+      const bad = EvaluationBooleanResult.schema.safeParse( { value: 'false', confidence: 1 } );
+      expect( bad.success ).toBe( false );
+    } );
+  } );
+} );
+