@outputai/evals 0.1.2-dev.0 → 0.1.2

package/dist/verify.js

@@ -1,18 +0,0 @@
-import { evaluator, z } from '@outputai/core';
-export const verify = (options, fn) => {
-    const inputSchema = z.object({
-        input: options.input ?? z.any(),
-        output: options.output ?? z.any(),
-        ground_truth: z.record(z.string(), z.unknown()).optional()
-    });
-    const wrappedFn = async (data) => {
-        const groundTruth = data.ground_truth ?? {};
-        return fn({ input: data.input, output: data.output, context: { ground_truth: groundTruth } });
-    };
-    return evaluator({
-        name: options.name,
-        description: options.name,
-        inputSchema,
-        fn: wrappedFn
-    });
-};

package/dist/verify.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/verify.spec.js

@@ -1,70 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { verify } from './verify.js';
-import { getMetadata } from '@outputai/core/sdk_utils';
-import { EvaluationBooleanResult, z } from '@outputai/core';
-import { Verdict } from './verdict.js';
-describe('verify', () => {
-    it('returns a function with metadata matching the given name', () => {
-        const ev = verify({ name: 'my_eval' }, () => Verdict.isTrue(true));
-        const meta = getMetadata(ev);
-        expect(meta).not.toBeNull();
-        expect(meta.name).toBe('my_eval');
-        expect(meta.description).toBe('my_eval');
-    });
-    it('passes input and output to the user function', async () => {
-        const captured = [];
-        const ev = verify({ name: 'capture_test' }, ctx => {
-            captured.push(ctx);
-            return Verdict.isTrue(true);
-        });
-        await ev({
-            input: { values: [1, 2] },
-            output: { result: 3 },
-            ground_truth: { key: 'val' }
-        });
-        expect(captured).toHaveLength(1);
-        expect(captured[0].input).toEqual({ values: [1, 2] });
-        expect(captured[0].output).toEqual({ result: 3 });
-        expect(captured[0].context.ground_truth).toEqual({ key: 'val' });
-    });
-    it('defaults ground_truth to empty object when undefined', async () => {
-        const captured = [];
-        const ev = verify({ name: 'default_ground_truth_test' }, ({ context }) => {
-            captured.push(context.ground_truth);
-            return Verdict.isTrue(true);
-        });
-        await ev({ input: {}, output: {} });
-        expect(captured[0]).toEqual({});
-    });
-    it('returns EvaluationResult from user fn as-is', async () => {
-        const ev = verify({
-            name: 'return_test',
-            input: z.object({ x: z.number() }),
-            output: z.object({ result: z.number() })
-        }, ({ input, output }) => Verdict.equals(output.result, input.x));
-        const result = await ev({ input: { x: 5 }, output: { result: 5 } });
-        expect(result).toBeInstanceOf(EvaluationBooleanResult);
-        expect(result.value).toBe(true);
-        expect(result.confidence).toBe(1.0);
-    });
-    it('returns failing result when assertion fails', async () => {
-        const ev = verify({
-            name: 'fail_test',
-            input: z.object({ x: z.number() }),
-            output: z.object({ result: z.number() })
-        }, ({ input, output }) => Verdict.equals(output.result, input.x));
-        const result = await ev({ input: { x: 5 }, output: { result: 10 } });
-        expect(result).toBeInstanceOf(EvaluationBooleanResult);
-        expect(result.value).toBe(false);
-        expect(result.confidence).toBe(1.0);
-    });
-    it('provides type inference via Zod schemas without as-casts', async () => {
-        const ev = verify({
-            name: 'typed_test',
-            input: z.object({ values: z.array(z.number()) }),
-            output: z.object({ sum: z.number() })
-        }, ({ input, output }) => Verdict.equals(output.sum, input.values.reduce((a, b) => a + b, 0)));
-        const result = await ev({ input: { values: [1, 2, 3] }, output: { sum: 6 } });
-        expect(result.value).toBe(true);
-    });
-});