@outputai/evals 0.1.0

package/dist/judge.js

@@ -0,0 +1,31 @@
+import { EvaluationVerdictResult, EvaluationNumberResult, EvaluationBooleanResult, EvaluationStringResult, z } from '@outputai/core';
+import { resolveInvocationDir } from '@outputai/core/sdk_utils';
+import { generateText, Output } from '@outputai/llm';
+const verdictSchema = z.object({ verdict: z.enum(['pass', 'partial', 'fail']), reasoning: z.string() });
+const scoreSchema = z.object({ score: z.number(), reasoning: z.string() });
+const booleanSchema = z.object({ result: z.boolean(), reasoning: z.string() });
+const labelSchema = z.object({ label: z.string(), reasoning: z.string() });
+export async function judgeVerdict({ prompt, variables, schema = verdictSchema }) {
+    const promptDir = resolveInvocationDir();
+    const response = await generateText({ prompt, variables, promptDir, output: Output.object({ schema }) });
+    const result = response.output;
+    return new EvaluationVerdictResult({ value: result.verdict, confidence: 0.9, reasoning: result.reasoning });
+}
+export async function judgeScore({ prompt, variables, schema = scoreSchema }) {
+    const promptDir = resolveInvocationDir();
+    const response = await generateText({ prompt, variables, promptDir, output: Output.object({ schema }) });
+    const result = response.output;
+    return new EvaluationNumberResult({ value: result.score, confidence: 0.9, reasoning: result.reasoning });
+}
+export async function judgeBoolean({ prompt, variables, schema = booleanSchema }) {
+    const promptDir = resolveInvocationDir();
+    const response = await generateText({ prompt, variables, promptDir, output: Output.object({ schema }) });
+    const result = response.output;
+    return new EvaluationBooleanResult({ value: result.result, confidence: 0.9, reasoning: result.reasoning });
+}
+export async function judgeLabel({ prompt, variables, schema = labelSchema }) {
+    const promptDir = resolveInvocationDir();
+    const response = await generateText({ prompt, variables, promptDir, output: Output.object({ schema }) });
+    const result = response.output;
+    return new EvaluationStringResult({ value: result.label, confidence: 0.9, reasoning: result.reasoning });
+}

package/dist/naming.d.ts

@@ -0,0 +1,3 @@
+export declare const getEvalWorkflowName: (workflowName: string) => string;
+export declare const isEvalWorkflow: (name: string) => boolean;
+export declare const getParentWorkflowName: (evalName: string) => string;

package/dist/naming.js

@@ -0,0 +1,4 @@
+const EVAL_SUFFIX = '_eval';
+export const getEvalWorkflowName = (workflowName) => `${workflowName}${EVAL_SUFFIX}`;
+export const isEvalWorkflow = (name) => name.endsWith(EVAL_SUFFIX);
+export const getParentWorkflowName = (evalName) => evalName.slice(0, -EVAL_SUFFIX.length);

package/dist/naming.spec.d.ts

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

package/dist/naming.spec.js

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { getEvalWorkflowName, isEvalWorkflow, getParentWorkflowName } from './naming.js';
+describe('naming', () => {
+    describe('getEvalWorkflowName', () => {
+        it('appends _eval suffix', () => {
+            expect(getEvalWorkflowName('simple')).toBe('simple_eval');
+            expect(getEvalWorkflowName('my_workflow')).toBe('my_workflow_eval');
+        });
+    });
+    describe('isEvalWorkflow', () => {
+        it('returns true for names ending with _eval', () => {
+            expect(isEvalWorkflow('simple_eval')).toBe(true);
+            expect(isEvalWorkflow('my_workflow_eval')).toBe(true);
+        });
+        it('returns false for regular workflow names', () => {
+            expect(isEvalWorkflow('simple')).toBe(false);
+            expect(isEvalWorkflow('eval_runner')).toBe(false);
+            expect(isEvalWorkflow('evaluation')).toBe(false);
+        });
+    });
+    describe('getParentWorkflowName', () => {
+        it('strips the _eval suffix', () => {
+            expect(getParentWorkflowName('simple_eval')).toBe('simple');
+            expect(getParentWorkflowName('my_workflow_eval')).toBe('my_workflow');
+        });
+        it('returns empty string for bare _eval', () => {
+            expect(getParentWorkflowName('_eval')).toBe('');
+        });
+    });
+});

package/dist/render.d.ts

@@ -0,0 +1,3 @@
+import type { EvalOutput } from './schemas.js';
+export declare function renderEvalOutput(evalOutput: EvalOutput, evalName?: string): string;
+export declare function computeExitCode(evalOutput: EvalOutput): number;

package/dist/render.js

@@ -0,0 +1,75 @@
+import { VERDICT, CRITICALITY } from './schemas.js';
+const COLORS = {
+    reset: '\x1b[0m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    dim: '\x1b[2m',
+    bold: '\x1b[1m',
+    cyan: '\x1b[36m'
+};
+const VERDICT_STYLE = {
+    [VERDICT.PASS]: { label: 'PASS', color: COLORS.green },
+    [VERDICT.PARTIAL]: { label: 'PARTIAL', color: COLORS.yellow },
+    [VERDICT.FAIL]: { label: 'FAIL', color: COLORS.red }
+};
+function colorize(text, color) {
+    return `${color}${text}${COLORS.reset}`;
+}
+function padWithDots(label, width = 30) {
+    const dotCount = Math.max(2, width - label.length);
+    return ` ${'.'.repeat(dotCount)} `;
+}
+function renderEvaluator(evaluator) {
+    const lines = [];
+    const style = VERDICT_STYLE[evaluator.verdict];
+    const prefix = evaluator.criticality === CRITICALITY.INFORMATIONAL ?
+        `${COLORS.dim}(info)${COLORS.reset} ` :
+        '';
+    lines.push(`    ${prefix}${evaluator.name}${padWithDots(evaluator.name, 24)}${colorize(evaluator.verdict, style.color)}`);
+    if (evaluator.reasoning && evaluator.verdict !== VERDICT.PASS) {
+        lines.push(`      ${COLORS.dim}-> ${evaluator.reasoning}${COLORS.reset}`);
+    }
+    if (evaluator.feedback) {
+        for (const fb of evaluator.feedback) {
+            const item = fb;
+            if (item.issue) {
+                lines.push(`      ${COLORS.dim}-> ${item.issue}${COLORS.reset}`);
+            }
+        }
+    }
+    return lines;
+}
+function renderCase(evalCase) {
+    const caseStyle = VERDICT_STYLE[evalCase.verdict];
+    const lines = [
+        `  ${evalCase.datasetName}${padWithDots(evalCase.datasetName)}${colorize(caseStyle.label, caseStyle.color)}`
+    ];
+    evalCase.evaluators.forEach(evaluator => lines.push(...renderEvaluator(evaluator)));
+    lines.push('');
+    return lines;
+}
+export function renderEvalOutput(evalOutput, evalName) {
+    const lines = [];
+    if (evalName) {
+        lines.push(colorize(evalName, COLORS.bold));
+        lines.push('');
+    }
+    evalOutput.cases.forEach(evalCase => lines.push(...renderCase(evalCase)));
+    const { summary } = evalOutput;
+    const parts = [];
+    if (summary.passed > 0) {
+        parts.push(colorize(`${summary.passed} passed`, COLORS.green));
+    }
+    if (summary.partial > 0) {
+        parts.push(colorize(`${summary.partial} partial`, COLORS.yellow));
+    }
+    if (summary.failed > 0) {
+        parts.push(colorize(`${summary.failed} failed`, COLORS.red));
+    }
+    lines.push(`${parts.join(', ')} (${Math.round(summary.acceptableRate * 100)}% acceptable)`);
+    return lines.join('\n');
+}
+export function computeExitCode(evalOutput) {
+    return evalOutput.cases.some(c => c.verdict === VERDICT.FAIL) ? 1 : 0;
+}

package/dist/render.spec.d.ts

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

package/dist/render.spec.js

@@ -0,0 +1,171 @@
+import { describe, it, expect } from 'vitest';
+import { renderEvalOutput, computeExitCode } from './render.js';
+const makeOutput = (cases, overrides) => {
+    const passed = cases.filter(c => c.verdict === 'pass').length;
+    const partial = cases.filter(c => c.verdict === 'partial').length;
+    const failed = cases.filter(c => c.verdict === 'fail').length;
+    const total = cases.length;
+    return {
+        cases,
+        summary: {
+            total,
+            passed,
+            partial,
+            failed,
+            acceptableRate: total > 0 ? (passed + partial) / total : 0,
+            ...overrides
+        }
+    };
+};
+describe('computeExitCode', () => {
+    it('returns 0 when all cases pass', () => {
+        const output = makeOutput([
+            { datasetName: 'a', verdict: 'pass', evaluators: [] }
+        ]);
+        expect(computeExitCode(output)).toBe(0);
+    });
+    it('returns 0 when cases are partial but none fail', () => {
+        const output = makeOutput([
+            { datasetName: 'a', verdict: 'partial', evaluators: [] }
+        ]);
+        expect(computeExitCode(output)).toBe(0);
+    });
+    it('returns 1 when any case fails', () => {
+        const output = makeOutput([
+            { datasetName: 'a', verdict: 'pass', evaluators: [] },
+            { datasetName: 'b', verdict: 'fail', evaluators: [] }
+        ]);
+        expect(computeExitCode(output)).toBe(1);
+    });
+    it('returns 0 for empty cases', () => {
+        const output = makeOutput([]);
+        expect(computeExitCode(output)).toBe(0);
+    });
+});
+describe('renderEvalOutput', () => {
+    it('includes eval name when provided', () => {
+        const output = makeOutput([
+            { datasetName: 'test', verdict: 'pass', evaluators: [] }
+        ]);
+        const rendered = renderEvalOutput(output, 'my_eval');
+        expect(rendered).toContain('my_eval');
+    });
+    it('includes dataset names', () => {
+        const output = makeOutput([
+            { datasetName: 'basic_input', verdict: 'pass', evaluators: [] },
+            { datasetName: 'edge_case', verdict: 'fail', evaluators: [] }
+        ]);
+        const rendered = renderEvalOutput(output);
+        expect(rendered).toContain('basic_input');
+        expect(rendered).toContain('edge_case');
+    });
+    it('includes verdict labels', () => {
+        const output = makeOutput([
+            { datasetName: 'a', verdict: 'pass', evaluators: [] },
+            { datasetName: 'b', verdict: 'fail', evaluators: [] }
+        ]);
+        const rendered = renderEvalOutput(output);
+        expect(rendered).toContain('PASS');
+        expect(rendered).toContain('FAIL');
+    });
+    it('shows reasoning for failed evaluators', () => {
+        const output = makeOutput([
+            {
+                datasetName: 'test',
+                verdict: 'fail',
+                evaluators: [{
+                        name: 'check',
+                        verdict: 'fail',
+                        criticality: 'required',
+                        reasoning: 'Expected 15, got null'
+                    }]
+            }
+        ]);
+        const rendered = renderEvalOutput(output);
+        expect(rendered).toContain('Expected 15, got null');
+    });
+    it('hides reasoning for passing evaluators', () => {
+        const output = makeOutput([
+            {
+                datasetName: 'test',
+                verdict: 'pass',
+                evaluators: [{
+                        name: 'check',
+                        verdict: 'pass',
+                        criticality: 'required',
+                        reasoning: 'All good'
+                    }]
+            }
+        ]);
+        const rendered = renderEvalOutput(output);
+        expect(rendered).not.toContain('All good');
+    });
+    it('shows summary with acceptable rate', () => {
+        const output = makeOutput([
+            { datasetName: 'a', verdict: 'pass', evaluators: [] },
+            { datasetName: 'b', verdict: 'fail', evaluators: [] }
+        ]);
+        const rendered = renderEvalOutput(output);
+        expect(rendered).toContain('1 passed');
+        expect(rendered).toContain('1 failed');
+        expect(rendered).toContain('50% acceptable');
+    });
+    it('includes PARTIAL verdict label', () => {
+        const output = makeOutput([
+            { datasetName: 'a', verdict: 'partial', evaluators: [] }
+        ]);
+        const rendered = renderEvalOutput(output);
+        expect(rendered).toContain('PARTIAL');
+    });
+    it('shows reasoning for partial evaluators', () => {
+        const output = makeOutput([
+            {
+                datasetName: 'test',
+                verdict: 'partial',
+                evaluators: [{
+                        name: 'check',
+                        verdict: 'partial',
+                        criticality: 'required',
+                        reasoning: 'Close but not quite'
+                    }]
+            }
+        ]);
+        const rendered = renderEvalOutput(output);
+        expect(rendered).toContain('Close but not quite');
+    });
+    it('renders feedback issues', () => {
+        const output = makeOutput([
+            {
+                datasetName: 'test',
+                verdict: 'fail',
+                evaluators: [{
+                        name: 'check',
+                        verdict: 'fail',
+                        criticality: 'required',
+                        feedback: [
+                            { issue: 'Missing required field' },
+                            { issue: 'Invalid format' }
+                        ]
+                    }]
+            }
+        ]);
+        const rendered = renderEvalOutput(output);
+        expect(rendered).toContain('Missing required field');
+        expect(rendered).toContain('Invalid format');
+    });
+    it('marks informational evaluators with (info) prefix', () => {
+        const output = makeOutput([
+            {
+                datasetName: 'test',
+                verdict: 'pass',
+                evaluators: [{
+                        name: 'info_check',
+                        verdict: 'fail',
+                        criticality: 'informational'
+                    }]
+            }
+        ]);
+        const rendered = renderEvalOutput(output);
+        expect(rendered).toContain('(info)');
+    });
+});

package/dist/schemas.d.ts

@@ -0,0 +1,95 @@
+import { z } from '@outputai/core';
+export declare const VERDICT: {
+    readonly PASS: "pass";
+    readonly PARTIAL: "partial";
+    readonly FAIL: "fail";
+};
+export declare const CRITICALITY: {
+    readonly REQUIRED: "required";
+    readonly INFORMATIONAL: "informational";
+};
+export declare const VerdictSchema: z.ZodEnum<{
+    pass: "pass";
+    partial: "partial";
+    fail: "fail";
+}>;
+export type Verdict = z.infer<typeof VerdictSchema>;
+export declare const CriticalitySchema: z.ZodEnum<{
+    required: "required";
+    informational: "informational";
+}>;
+export type Criticality = z.infer<typeof CriticalitySchema>;
+export type InterpretConfig = {
+    type: 'verdict';
+} | {
+    type: 'boolean';
+} | {
+    type: 'number';
+    pass: number;
+    partial?: number;
+} | {
+    type: 'string';
+    pass: string[];
+    partial?: string[];
+};
+export declare const InterpretConfigSchema: z.ZodType<InterpretConfig>;
+export interface EvaluatorResult {
+    name: string;
+    verdict: Verdict;
+    criticality: Criticality;
+    confidence?: number;
+    reasoning?: string;
+    feedback?: unknown[];
+}
+export declare const EvaluatorResultSchema: z.ZodType<EvaluatorResult>;
+export interface EvalCase {
+    datasetName: string;
+    verdict: Verdict;
+    evaluators: EvaluatorResult[];
+}
+export declare const EvalCaseSchema: z.ZodType<EvalCase>;
+export interface EvalSummary {
+    total: number;
+    passed: number;
+    partial: number;
+    failed: number;
+    acceptableRate: number;
+}
+export interface EvalOutput {
+    cases: EvalCase[];
+    summary: EvalSummary;
+}
+export declare const EvalOutputSchema: z.ZodType<EvalOutput>;
+export interface GroundTruth {
+    evals?: Record<string, Record<string, unknown>>;
+    [key: string]: unknown;
+}
+export interface LastOutput {
+    output: unknown;
+    executionTimeMs?: number;
+    date: string;
+}
+export interface LastEval {
+    output: EvalCase;
+    executionTimeMs?: number;
+    date: string;
+}
+export declare const LastOutputSchema: z.ZodType<LastOutput>;
+export declare const LastEvalSchema: z.ZodType<LastEval>;
+export interface Dataset {
+    name: string;
+    input: Record<string, unknown>;
+    ground_truth?: GroundTruth;
+    last_output?: LastOutput;
+    last_eval?: LastEval;
+    [key: string]: unknown;
+}
+export declare const DatasetSchema: z.ZodObject<{
+    name: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodAny>;
+    ground_truth: z.ZodOptional<z.ZodObject<{
+        evals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    }, z.core.$loose>>;
+    last_output: z.ZodOptional<z.ZodType<LastOutput, unknown, z.core.$ZodTypeInternals<LastOutput, unknown>>>;
+    last_eval: z.ZodOptional<z.ZodType<LastEval, unknown, z.core.$ZodTypeInternals<LastEval, unknown>>>;
+}, z.core.$loose>;

package/dist/schemas.js

@@ -0,0 +1,60 @@
+import { z } from '@outputai/core';
+export const VERDICT = {
+    PASS: 'pass',
+    PARTIAL: 'partial',
+    FAIL: 'fail'
+};
+export const CRITICALITY = {
+    REQUIRED: 'required',
+    INFORMATIONAL: 'informational'
+};
+export const VerdictSchema = z.enum([VERDICT.PASS, VERDICT.PARTIAL, VERDICT.FAIL]);
+export const CriticalitySchema = z.enum([CRITICALITY.REQUIRED, CRITICALITY.INFORMATIONAL]);
+export const InterpretConfigSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('verdict') }),
+    z.object({ type: z.literal('boolean') }),
+    z.object({ type: z.literal('number'), pass: z.number(), partial: z.number().optional() }),
+    z.object({ type: z.literal('string'), pass: z.array(z.string()), partial: z.array(z.string()).optional() })
+]);
+export const EvaluatorResultSchema = z.object({
+    name: z.string(),
+    verdict: VerdictSchema,
+    criticality: CriticalitySchema,
+    confidence: z.number().optional(),
+    reasoning: z.string().optional(),
+    feedback: z.array(z.any()).optional()
+});
+export const EvalCaseSchema = z.object({
+    datasetName: z.string(),
+    verdict: VerdictSchema,
+    evaluators: z.array(EvaluatorResultSchema)
+});
+export const EvalOutputSchema = z.object({
+    cases: z.array(EvalCaseSchema),
+    summary: z.object({
+        total: z.number(),
+        passed: z.number(),
+        partial: z.number(),
+        failed: z.number(),
+        acceptableRate: z.number()
+    })
+});
+export const LastOutputSchema = z.object({
+    output: z.any(),
+    executionTimeMs: z.number().optional(),
+    date: z.string()
+});
+export const LastEvalSchema = z.object({
+    output: EvalCaseSchema,
+    executionTimeMs: z.number().optional(),
+    date: z.string()
+});
+export const DatasetSchema = z.object({
+    name: z.string(),
+    input: z.record(z.string(), z.any()),
+    ground_truth: z.object({
+        evals: z.record(z.string(), z.record(z.string(), z.any())).optional()
+    }).passthrough().optional(),
+    last_output: LastOutputSchema.optional(),
+    last_eval: LastEvalSchema.optional()
+}).passthrough();

package/dist/verdict.d.ts

@@ -0,0 +1,27 @@
+import { EvaluationVerdictResult, EvaluationBooleanResult, EvaluationNumberResult, EvaluationStringResult, EvaluationFeedback } from '@outputai/core';
+type FeedbackArg = ConstructorParameters<typeof EvaluationFeedback>[0];
+export declare const Verdict: {
+    pass(reasoning?: string): EvaluationVerdictResult;
+    partial(confidence: number, reasoning?: string, feedback?: FeedbackArg[]): EvaluationVerdictResult;
+    fail(reasoning: string, feedback?: FeedbackArg[]): EvaluationVerdictResult;
+    equals(actual: unknown, expected: unknown): EvaluationBooleanResult;
+    closeTo(actual: number, expected: number, tolerance: number): EvaluationBooleanResult;
+    gt(actual: number, threshold: number): EvaluationBooleanResult;
+    gte(actual: number, threshold: number): EvaluationBooleanResult;
+    lt(actual: number, threshold: number): EvaluationBooleanResult;
+    lte(actual: number, threshold: number): EvaluationBooleanResult;
+    inRange(actual: number, min: number, max: number): EvaluationBooleanResult;
+    contains(haystack: string, needle: string): EvaluationBooleanResult;
+    matches(value: string, pattern: RegExp): EvaluationBooleanResult;
+    includesAll(actual: unknown[], expected: unknown[]): EvaluationBooleanResult;
+    includesAny(actual: unknown[], expected: unknown[]): EvaluationBooleanResult;
+    isTrue(value: boolean): EvaluationBooleanResult;
+    isFalse(value: boolean): EvaluationBooleanResult;
+    fromJudge({ verdict, reasoning }: {
+        verdict: "pass" | "partial" | "fail";
+        reasoning: string;
+    }): EvaluationVerdictResult;
+    score(value: number, reasoning?: string): EvaluationNumberResult;
+    label(value: string, reasoning?: string): EvaluationStringResult;
+};
+export {};

package/dist/verdict.js

@@ -0,0 +1,109 @@
+import { EvaluationVerdictResult, EvaluationBooleanResult, EvaluationNumberResult, EvaluationStringResult, EvaluationFeedback } from '@outputai/core';
+const boolResult = (value, reasoning) => new EvaluationBooleanResult({ value, confidence: 1.0, reasoning });
+export const Verdict = {
+    // --- Original helpers ---
+    pass(reasoning) {
+        return new EvaluationVerdictResult({ value: 'pass', confidence: 1.0, reasoning });
+    },
+    partial(confidence, reasoning, feedback) {
+        return new EvaluationVerdictResult({
+            value: 'partial',
+            confidence,
+            reasoning,
+            feedback: feedback ? feedback.map(f => new EvaluationFeedback(f)) : undefined
+        });
+    },
+    fail(reasoning, feedback) {
+        return new EvaluationVerdictResult({
+            value: 'fail',
+            confidence: 0.0,
+            reasoning,
+            feedback: feedback ? feedback.map(f => new EvaluationFeedback(f)) : undefined
+        });
+    },
+    // --- Deterministic assertions (confidence 1.0 for both pass and fail) ---
+    equals(actual, expected) {
+        const passed = actual === expected;
+        return boolResult(passed, passed ?
+            `Value equals expected: ${JSON.stringify(expected)}` :
+            `Expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+    },
+    closeTo(actual, expected, tolerance) {
+        const passed = Math.abs(actual - expected) <= tolerance;
+        return boolResult(passed, passed ?
+            `${actual} is within ${tolerance} of ${expected}` :
+            `${actual} is not within ${tolerance} of ${expected} (diff: ${Math.abs(actual - expected)})`);
+    },
+    gt(actual, threshold) {
+        const passed = actual > threshold;
+        return boolResult(passed, passed ?
+            `${actual} > ${threshold}` :
+            `${actual} is not greater than ${threshold}`);
+    },
+    gte(actual, threshold) {
+        const passed = actual >= threshold;
+        return boolResult(passed, passed ?
+            `${actual} >= ${threshold}` :
+            `${actual} is not greater than or equal to ${threshold}`);
+    },
+    lt(actual, threshold) {
+        const passed = actual < threshold;
+        return boolResult(passed, passed ?
+            `${actual} < ${threshold}` :
+            `${actual} is not less than ${threshold}`);
+    },
+    lte(actual, threshold) {
+        const passed = actual <= threshold;
+        return boolResult(passed, passed ?
+            `${actual} <= ${threshold}` :
+            `${actual} is not less than or equal to ${threshold}`);
+    },
+    inRange(actual, min, max) {
+        const passed = actual >= min && actual <= max;
+        return boolResult(passed, passed ?
+            `${actual} is in range [${min}, ${max}]` :
+            `${actual} is not in range [${min}, ${max}]`);
+    },
+    contains(haystack, needle) {
+        const passed = haystack.includes(needle);
+        return boolResult(passed, passed ?
+            `String contains "${needle}"` :
+            `String does not contain "${needle}"`);
+    },
+    matches(value, pattern) {
+        const passed = pattern.test(value);
+        return boolResult(passed, passed ?
+            `Value matches ${pattern}` :
+            `Value does not match ${pattern}`);
+    },
+    includesAll(actual, expected) {
+        const missing = expected.filter(e => !actual.includes(e));
+        const passed = missing.length === 0;
+        return boolResult(passed, passed ?
+            'Array includes all expected values' :
+            `Array is missing: ${JSON.stringify(missing)}`);
+    },
+    includesAny(actual, expected) {
+        const found = expected.filter(e => actual.includes(e));
+        const passed = found.length > 0;
+        return boolResult(passed, passed ?
+            `Array includes: ${JSON.stringify(found)}` :
+            `Array includes none of: ${JSON.stringify(expected)}`);
+    },
+    isTrue(value) {
+        return boolResult(value === true, value === true ? 'Value is true' : `Expected true, got ${value}`);
+    },
+    isFalse(value) {
+        return boolResult(value === false, value === false ? 'Value is false' : `Expected false, got ${value}`);
+    },
+    // --- LLM judge helpers ---
+    fromJudge({ verdict, reasoning }) {
+        return new EvaluationVerdictResult({ value: verdict, confidence: 0.9, reasoning });
+    },
+    score(value, reasoning) {
+        return new EvaluationNumberResult({ value, confidence: 0.9, reasoning });
+    },
+    label(value, reasoning) {
+        return new EvaluationStringResult({ value, confidence: 0.9, reasoning });
+    }
+};

package/dist/verdict.spec.d.ts

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