llm-testrunner-components 1.1.0 → 1.2.1

package/dist/llm-testrunner/llm-testrunner.esm.js

@@ -1,2 +1,2 @@
-import{p as e,b as t}from"./p-DxzhGhec.js";export{s as setNonce}from"./p-DxzhGhec.js";import{g as a}from"./p-GQwFOmwJ.js";var i=()=>{const s=import.meta.url;const t={};if(s!==""){t.resourcesUrl=new URL(".",s).href}return e(t)};i().then((async e=>{await a();return t([["p-2cc09217",[[513,"llm-test-runner",{delayMs:[2,"delay-ms"],useSave:[4,"use-save"],initialTestCases:[16],defaultExpectedOutcomeSchema:[16],testCases:[32],isRunningAll:[32],error:[32],isExportingTestSuite:[32],isExportingTestResults:[32],isSaving:[32],resetSavingState:[64]}],[513,"app-chips",{value:[16],config:[16]}],[513,"app-select",{value:[1],config:[16]}],[513,"app-textarea",{value:[1],config:[16]}]]]],e)}));
+import{p as e,b as t}from"./p-DxzhGhec.js";export{s as setNonce}from"./p-DxzhGhec.js";import{g as a}from"./p-GQwFOmwJ.js";var r=()=>{const s=import.meta.url;const t={};if(s!==""){t.resourcesUrl=new URL(".",s).href}return e(t)};r().then((async e=>{await a();return t([["p-2cc09217",[[513,"llm-test-runner",{delayMs:[2,"delay-ms"],useSave:[4,"use-save"],usePromptEditor:[4,"use-prompt-editor"],initialTestCases:[16],defaultExpectedOutcomeSchema:[16],testCases:[32],isRunningAll:[32],error:[32],isExportingTestSuite:[32],isExportingTestResults:[32],isSaving:[32],resetSavingState:[64]}],[513,"app-chips",{value:[16],config:[16]}],[513,"app-select",{value:[1],config:[16]}],[513,"app-textarea",{value:[1],config:[16]}]]]],e)}));
 //# sourceMappingURL=llm-testrunner.esm.js.map

package/dist/types/components/llm-test-runner/header/llm-test-runner-header.d.ts

@@ -5,6 +5,7 @@ export interface LLMTestRunnerHeaderProps {
     isRunningAll: boolean;
     useSave?: boolean;
     isSaving?: boolean;
+    usePromptEditor?: boolean;
     onImport: (file: File) => void;
     onExportSuite: () => void;
     onExportResults: () => void;

package/dist/types/components/llm-test-runner/llm-test-runner.d.ts

@@ -5,6 +5,7 @@ export declare class LLMTestRunner {
     save: EventEmitter<SavePayload>;
     delayMs?: number;
     useSave?: boolean;
+    usePromptEditor?: boolean;
     initialTestCases?: TestCase[];
     defaultExpectedOutcomeSchema?: ExpectedOutcomeSchema;
     testCases: TestCase[];
@@ -24,7 +25,6 @@ export declare class LLMTestRunner {
     private updateTestCase;
     private runSingleTest;
     private deleteTestCase;
-    private updateApproach;
     private handleExpectedOutcomeChange;
     private evaluateResponse;
     private runAllTests;

package/dist/types/components/llm-test-runner/test-cases/expected-outcome-renderer.d.ts

@@ -1,12 +1,9 @@
 import { FunctionalComponent } from '../../../stencil-public-runtime';
 import { ExpectedOutcomeField } from '../../../types/llm-test-runner';
-export type ExpectedOutcomeOperation = 'set-value' | 'add-chip' | 'remove-chip';
-export interface ExpectedOutcomeChangeDetail {
+import { ExpectedOutcomeChange } from '../../../lib/test-cases/test-case-mutations';
+export type ExpectedOutcomeChangeDetail = {
     testCaseId: string;
-    index: number;
-    operation: ExpectedOutcomeOperation;
-    value?: string;
-}
+} & ExpectedOutcomeChange;
 interface ExpectedOutcomeRendererProps {
     testCaseId: string;
     fields: ExpectedOutcomeField[];

package/dist/types/components/llm-test-runner/test-cases/llm-test-case-row.d.ts

@@ -1,12 +1,10 @@
 import { FunctionalComponent } from '../../../stencil-public-runtime';
 import { TestCase } from '../../../types/llm-test-runner';
-import { EvaluationApproach } from '../../../lib/evaluation/constants';
 import { ExpectedOutcomeChangeDetail } from './expected-outcome-renderer';
 export interface LLMTestCaseRowProps {
     testCase: TestCase;
     onRun: (testCase: TestCase) => void;
     onDelete: (id: string) => void;
-    onUpdateApproach: (testCase: TestCase, approach: EvaluationApproach) => void;
     handleTestCaseChange: (e: CustomEvent<{
         testCaseId: string;
         key: string;

package/dist/types/components/llm-test-runner/test-cases/llm-test-cases.d.ts

@@ -1,12 +1,10 @@
 import { FunctionalComponent } from '../../../stencil-public-runtime';
 import { TestCase } from '../../../types/llm-test-runner';
-import { EvaluationApproach } from '../../../lib/evaluation/constants';
 import { ExpectedOutcomeChangeDetail } from './expected-outcome-renderer';
 export interface LLMTestCasesProps {
     testCases: TestCase[];
     onRun: (testCase: TestCase) => void;
     onDelete: (id: string) => void;
-    onUpdateApproach: (testCase: TestCase, approach: EvaluationApproach) => void;
     onAddTestCase: () => void;
     handleTestCaseChange: (e: CustomEvent<{
         testCaseId: string;

package/dist/types/components.d.ts

@@ -33,6 +33,10 @@ export namespace Components {
         "delayMs"?: number;
         "initialTestCases"?: TestCase[];
         "resetSavingState": () => Promise<void>;
+        /**
+          * @default false
+         */
+        "usePromptEditor"?: boolean;
         /**
           * @default false
          */
@@ -162,6 +166,10 @@ declare namespace LocalJSX {
         "initialTestCases"?: TestCase[];
         "onLlmRequest"?: (event: LlmTestRunnerCustomEvent<LLMRequestPayload>) => void;
         "onSave"?: (event: LlmTestRunnerCustomEvent<SavePayload>) => void;
+        /**
+          * @default false
+         */
+        "usePromptEditor"?: boolean;
         /**
           * @default false
          */
@@ -177,6 +185,7 @@ declare namespace LocalJSX {
     interface LlmTestRunnerAttributes {
         "delayMs": number;
         "useSave": boolean;
+        "usePromptEditor": boolean;
     }
 
     interface IntrinsicElements {

package/dist/types/lib/evaluation/evaluation-engine.d.ts

@@ -1,4 +1,6 @@
-import { EvaluationRequest, EvaluationCallback } from './types';
+import { EvaluationCallback, EvaluationRequestV2 } from './types';
 export declare class LLMEvaluationEngine {
-    evaluateResponse(request: EvaluationRequest, callback: EvaluationCallback): Promise<void>;
+    evaluateResponse(request: EvaluationRequestV2, callback: EvaluationCallback): Promise<void>;
+    private evaluateField;
+    private getSafeErrorMessage;
 }

package/dist/types/lib/evaluation/field-evaluation-approach.d.ts

@@ -0,0 +1,6 @@
+import { EvaluationApproach } from './constants';
+import type { EvaluationParameters } from '../../types/evaluation';
+export type EvaluationFieldType = 'text' | 'textarea' | 'chips-input' | 'select';
+export declare function getAllowedApproachesForFieldType(fieldType: EvaluationFieldType): EvaluationApproach[];
+export declare function isApproachAllowedForFieldType(fieldType: EvaluationFieldType, approach: EvaluationApproach): boolean;
+export declare function normalizeEvaluationParametersForField(fieldType: EvaluationFieldType, evaluationParameters?: EvaluationParameters): EvaluationParameters;

package/dist/types/lib/evaluation/index.d.ts

@@ -2,4 +2,3 @@ import { LLMEvaluationEngine } from './evaluation-engine';
 import type { EvaluationRequest, EvaluationResult, KeywordMatch, EvaluationCallback } from './types';
 export { LLMEvaluationEngine };
 export type { EvaluationRequest, EvaluationResult, KeywordMatch, EvaluationCallback, };
-export declare function evaluateLLMResponse(request: EvaluationRequest, callback: EvaluationCallback): Promise<void>;

package/dist/types/lib/evaluation/types.d.ts

@@ -1,4 +1,5 @@
 import { EvaluationParameters, EvaluationApproachResult } from '../../types/evaluation';
+import type { ExpectedOutcomeFieldType } from '../../types/llm-test-runner';
 export interface EvaluationRequest {
     testCaseId: string;
     question: string;
@@ -6,13 +7,38 @@ export interface EvaluationRequest {
     actualResponse: string;
     evaluationParameters: EvaluationParameters;
 }
+export interface FieldEvaluationInput {
+    index: number;
+    label: string;
+    type: ExpectedOutcomeFieldType;
+    expectedValue: string;
+    evaluationParameters: EvaluationParameters;
+}
+export interface EvaluationRequestV2 {
+    testCaseId: string;
+    question: string;
+    actualResponse: string;
+    fields: FieldEvaluationInput[];
+}
 export interface EvaluationResult {
     testCaseId: string;
     passed: boolean;
     keywordMatches: KeywordMatch[];
+    fieldResults?: FieldEvaluationResult[];
     timestamp?: string;
+    evaluationParameters?: EvaluationParameters;
+    evaluationApproachResult?: EvaluationApproachResult;
+}
+export interface FieldEvaluationResult {
+    index: number;
+    label: string;
+    type: ExpectedOutcomeFieldType;
+    expectedValue: string;
+    passed: boolean;
+    keywordMatches: KeywordMatch[];
     evaluationParameters: EvaluationParameters;
     evaluationApproachResult: EvaluationApproachResult;
+    error?: string;
 }
 export interface KeywordMatch {
     keyword: string;

package/dist/types/lib/import-export/test-suite-exporter.d.ts

@@ -3,10 +3,6 @@ export interface TestSuiteExportData {
     id: string;
     question: string;
     expectedOutcome: ExpectedOutcomeField[];
-    evaluationParameters?: {
-        approach: string;
-        threshold?: number;
-    };
 }
 /**
  * Formats test cases as a JSON string suitable for saving as a test suite

package/dist/types/lib/test-cases/test-case-factory.d.ts

@@ -6,11 +6,10 @@ export declare const DEFAULT_EXPECTED_OUTCOME_SCHEMA: ExpectedOutcomeSchema;
  */
 export declare function createTestCase(expectedOutcomeSchema?: ExpectedOutcomeSchema): TestCase;
 export declare function createExpectedOutcomeFromSchema(expectedOutcomeSchema: ExpectedOutcomeSchema): ExpectedOutcomeField[];
-export declare function migrateLegacyExpectedOutcomeString(value: string): ExpectedOutcomeField[];
 /**
  * Creates a runtime test case from validated input data.
- * The input is expected to already satisfy `TestCaseInput` (legacy string or v2 shape),
- * and this function only performs normalization/defaulting (including legacy migration).
+ * The input is expected to already satisfy `TestCaseInput`,
+ * and this function only performs normalization/defaulting.
  *
  * @param data - Validated test case input
  * @returns A normalized TestCase object with runtime defaults applied

package/dist/types/lib/test-cases/test-case-mutations.d.ts

@@ -1,9 +1,25 @@
 import { TestCase } from '../../types/llm-test-runner';
 import { EvaluationApproach } from '../evaluation/constants';
+export type ExpectedOutcomeChange = {
+    index: number;
+    operation: 'set-value';
+    value: string;
+} | {
+    index: number;
+    operation: 'add-chip';
+    value: string;
+} | {
+    index: number;
+    operation: 'remove-chip';
+    value: string;
+} | {
+    index: number;
+    operation: 'set-evaluation-approach';
+    value: EvaluationApproach;
+};
+export declare function applyExpectedOutcomeChange(testCase: TestCase, change: ExpectedOutcomeChange): TestCase;
 /**
- * Updates the evaluation approach for a test case
- * @param testCase - The test case to update
- * @param approach - The new evaluation approach
- * @returns Updated test case with the new evaluation approach
+ * Updates the evaluation approach for a specific expected outcome field.
+ * Select fields always use exact matching.
  */
-export declare function updateApproach(testCase: TestCase, approach: EvaluationApproach): TestCase;
+export declare function updateExpectedOutcomeFieldApproach(testCase: TestCase, fieldIndex: number, approach: EvaluationApproach): TestCase;

package/dist/types/schemas/expected-outcome.d.ts

@@ -1,107 +1,155 @@
 import { z } from 'zod';
+import { EvaluationApproach } from '../lib/evaluation/constants';
 declare const defaultExpectedOutcomeBaseSchema: z.ZodObject<{
     label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const expectedOutcomeSchemaFieldSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"text">;
+    evaluationParameters: z.ZodOptional<z.ZodObject<{
+        approach: z.ZodEnum<typeof EvaluationApproach>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"textarea">;
     rows: z.ZodOptional<z.ZodNumber>;
+    evaluationParameters: z.ZodOptional<z.ZodObject<{
+        approach: z.ZodEnum<typeof EvaluationApproach>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"chips-input">;
+    evaluationParameters: z.ZodOptional<z.ZodObject<{
+        approach: z.ZodEnum<typeof EvaluationApproach>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"select">;
     options: z.ZodArray<z.ZodString>;
+    evaluationParameters: z.ZodOptional<z.ZodObject<{
+        approach: z.ZodEnum<typeof EvaluationApproach>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>], "type">;
 export declare const expectedOutcomeSchemaSchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
     label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"text">;
+    evaluationParameters: z.ZodOptional<z.ZodObject<{
+        approach: z.ZodEnum<typeof EvaluationApproach>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"textarea">;
     rows: z.ZodOptional<z.ZodNumber>;
+    evaluationParameters: z.ZodOptional<z.ZodObject<{
+        approach: z.ZodEnum<typeof EvaluationApproach>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"chips-input">;
+    evaluationParameters: z.ZodOptional<z.ZodObject<{
+        approach: z.ZodEnum<typeof EvaluationApproach>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"select">;
     options: z.ZodArray<z.ZodString>;
+    evaluationParameters: z.ZodOptional<z.ZodObject<{
+        approach: z.ZodEnum<typeof EvaluationApproach>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>], "type">>;
 export declare const expectedOutcomeFieldSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"text">;
+    evaluationParameters: z.ZodOptional<z.ZodObject<{
+        approach: z.ZodEnum<typeof EvaluationApproach>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
     value: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"textarea">;
     rows: z.ZodOptional<z.ZodNumber>;
+    evaluationParameters: z.ZodOptional<z.ZodObject<{
+        approach: z.ZodEnum<typeof EvaluationApproach>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
     value: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"chips-input">;
+    evaluationParameters: z.ZodOptional<z.ZodObject<{
+        approach: z.ZodEnum<typeof EvaluationApproach>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
     value: z.ZodArray<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"select">;
     options: z.ZodArray<z.ZodString>;
+    evaluationParameters: z.ZodOptional<z.ZodObject<{
+        approach: z.ZodEnum<typeof EvaluationApproach>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
     value: z.ZodString;
 }, z.core.$strip>], "type">;
 export declare const expectedOutcomeArraySchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
     label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"text">;
+    evaluationParameters: z.ZodOptional<z.ZodObject<{
+        approach: z.ZodEnum<typeof EvaluationApproach>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
     value: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"textarea">;
     rows: z.ZodOptional<z.ZodNumber>;
+    evaluationParameters: z.ZodOptional<z.ZodObject<{
+        approach: z.ZodEnum<typeof EvaluationApproach>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
     value: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"chips-input">;
+    evaluationParameters: z.ZodOptional<z.ZodObject<{
+        approach: z.ZodEnum<typeof EvaluationApproach>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
     value: z.ZodArray<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     label: z.ZodString;
-    required: z.ZodOptional<z.ZodBoolean>;
     placeholder: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"select">;
     options: z.ZodArray<z.ZodString>;
+    evaluationParameters: z.ZodOptional<z.ZodObject<{
+        approach: z.ZodEnum<typeof EvaluationApproach>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
     value: z.ZodString;
 }, z.core.$strip>], "type">>;
 export type ExpectedOutcomeSchemaField = z.infer<typeof expectedOutcomeSchemaFieldSchema>;

package/dist/types/schemas/test-case.d.ts

@@ -1,184 +1,140 @@
 import { z } from 'zod';
-import { EvaluationApproach } from '../lib/evaluation/constants';
 import type { EvaluationResult } from '../lib/evaluation/types';
-export declare const evaluationParametersSchema: z.ZodObject<{
-    approach: z.ZodEnum<typeof EvaluationApproach>;
-    threshold: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const legacyTestCaseInputSchema: z.ZodObject<{
+export declare const testCaseInputSchema: z.ZodObject<{
     id: z.ZodString;
     question: z.ZodString;
-    evaluationParameters: z.ZodOptional<z.ZodObject<{
-        approach: z.ZodEnum<typeof EvaluationApproach>;
-        threshold: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    expectedOutcome: z.ZodString;
-}, z.core.$strip>;
-export declare const v2TestCaseInputSchema: z.ZodObject<{
-    id: z.ZodString;
-    question: z.ZodString;
-    evaluationParameters: z.ZodOptional<z.ZodObject<{
-        approach: z.ZodEnum<typeof EvaluationApproach>;
-        threshold: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
     expectedOutcome: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         label: z.ZodString;
-        required: z.ZodOptional<z.ZodBoolean>;
         placeholder: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"text">;
+        evaluationParameters: z.ZodOptional<z.ZodObject<{
+            approach: z.ZodEnum<typeof import("../lib/evaluation/constants").EvaluationApproach>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
         value: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         label: z.ZodString;
-        required: z.ZodOptional<z.ZodBoolean>;
         placeholder: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"textarea">;
         rows: z.ZodOptional<z.ZodNumber>;
+        evaluationParameters: z.ZodOptional<z.ZodObject<{
+            approach: z.ZodEnum<typeof import("../lib/evaluation/constants").EvaluationApproach>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
         value: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         label: z.ZodString;
-        required: z.ZodOptional<z.ZodBoolean>;
         placeholder: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"chips-input">;
+        evaluationParameters: z.ZodOptional<z.ZodObject<{
+            approach: z.ZodEnum<typeof import("../lib/evaluation/constants").EvaluationApproach>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
         value: z.ZodArray<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         label: z.ZodString;
-        required: z.ZodOptional<z.ZodBoolean>;
         placeholder: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"select">;
         options: z.ZodArray<z.ZodString>;
+        evaluationParameters: z.ZodOptional<z.ZodObject<{
+            approach: z.ZodEnum<typeof import("../lib/evaluation/constants").EvaluationApproach>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
         value: z.ZodString;
     }, z.core.$strip>], "type">>;
 }, z.core.$strip>;
-export declare const testCaseInputSchema: z.ZodUnion<readonly [z.ZodObject<{
-    id: z.ZodString;
-    question: z.ZodString;
-    evaluationParameters: z.ZodOptional<z.ZodObject<{
-        approach: z.ZodEnum<typeof EvaluationApproach>;
-        threshold: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    expectedOutcome: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodString;
-    question: z.ZodString;
-    evaluationParameters: z.ZodOptional<z.ZodObject<{
-        approach: z.ZodEnum<typeof EvaluationApproach>;
-        threshold: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    expectedOutcome: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        label: z.ZodString;
-        required: z.ZodOptional<z.ZodBoolean>;
-        placeholder: z.ZodOptional<z.ZodString>;
-        type: z.ZodLiteral<"text">;
-        value: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        label: z.ZodString;
-        required: z.ZodOptional<z.ZodBoolean>;
-        placeholder: z.ZodOptional<z.ZodString>;
-        type: z.ZodLiteral<"textarea">;
-        rows: z.ZodOptional<z.ZodNumber>;
-        value: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        label: z.ZodString;
-        required: z.ZodOptional<z.ZodBoolean>;
-        placeholder: z.ZodOptional<z.ZodString>;
-        type: z.ZodLiteral<"chips-input">;
-        value: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        label: z.ZodString;
-        required: z.ZodOptional<z.ZodBoolean>;
-        placeholder: z.ZodOptional<z.ZodString>;
-        type: z.ZodLiteral<"select">;
-        options: z.ZodArray<z.ZodString>;
-        value: z.ZodString;
-    }, z.core.$strip>], "type">>;
-}, z.core.$strip>]>;
-export declare const testCaseInputArraySchema: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-    id: z.ZodString;
-    question: z.ZodString;
-    evaluationParameters: z.ZodOptional<z.ZodObject<{
-        approach: z.ZodEnum<typeof EvaluationApproach>;
-        threshold: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    expectedOutcome: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+export declare const testCaseInputArraySchema: z.ZodArray<z.ZodObject<{
     id: z.ZodString;
     question: z.ZodString;
-    evaluationParameters: z.ZodOptional<z.ZodObject<{
-        approach: z.ZodEnum<typeof EvaluationApproach>;
-        threshold: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
     expectedOutcome: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         label: z.ZodString;
-        required: z.ZodOptional<z.ZodBoolean>;
         placeholder: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"text">;
+        evaluationParameters: z.ZodOptional<z.ZodObject<{
+            approach: z.ZodEnum<typeof import("../lib/evaluation/constants").EvaluationApproach>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
         value: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         label: z.ZodString;
-        required: z.ZodOptional<z.ZodBoolean>;
         placeholder: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"textarea">;
         rows: z.ZodOptional<z.ZodNumber>;
+        evaluationParameters: z.ZodOptional<z.ZodObject<{
+            approach: z.ZodEnum<typeof import("../lib/evaluation/constants").EvaluationApproach>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
         value: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         label: z.ZodString;
-        required: z.ZodOptional<z.ZodBoolean>;
         placeholder: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"chips-input">;
+        evaluationParameters: z.ZodOptional<z.ZodObject<{
+            approach: z.ZodEnum<typeof import("../lib/evaluation/constants").EvaluationApproach>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
         value: z.ZodArray<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         label: z.ZodString;
-        required: z.ZodOptional<z.ZodBoolean>;
         placeholder: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"select">;
         options: z.ZodArray<z.ZodString>;
+        evaluationParameters: z.ZodOptional<z.ZodObject<{
+            approach: z.ZodEnum<typeof import("../lib/evaluation/constants").EvaluationApproach>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
         value: z.ZodString;
     }, z.core.$strip>], "type">>;
-}, z.core.$strip>]>>;
+}, z.core.$strip>>;
 export declare const testCaseSchema: z.ZodObject<{
     id: z.ZodString;
     question: z.ZodString;
     expectedOutcome: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         label: z.ZodString;
-        required: z.ZodOptional<z.ZodBoolean>;
         placeholder: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"text">;
+        evaluationParameters: z.ZodOptional<z.ZodObject<{
+            approach: z.ZodEnum<typeof import("../lib/evaluation/constants").EvaluationApproach>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
         value: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         label: z.ZodString;
-        required: z.ZodOptional<z.ZodBoolean>;
         placeholder: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"textarea">;
         rows: z.ZodOptional<z.ZodNumber>;
+        evaluationParameters: z.ZodOptional<z.ZodObject<{
+            approach: z.ZodEnum<typeof import("../lib/evaluation/constants").EvaluationApproach>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
         value: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         label: z.ZodString;
-        required: z.ZodOptional<z.ZodBoolean>;
         placeholder: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"chips-input">;
+        evaluationParameters: z.ZodOptional<z.ZodObject<{
+            approach: z.ZodEnum<typeof import("../lib/evaluation/constants").EvaluationApproach>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
         value: z.ZodArray<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         label: z.ZodString;
-        required: z.ZodOptional<z.ZodBoolean>;
         placeholder: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"select">;
         options: z.ZodArray<z.ZodString>;
+        evaluationParameters: z.ZodOptional<z.ZodObject<{
+            approach: z.ZodEnum<typeof import("../lib/evaluation/constants").EvaluationApproach>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
         value: z.ZodString;
     }, z.core.$strip>], "type">>;
-    evaluationParameters: z.ZodOptional<z.ZodObject<{
-        approach: z.ZodEnum<typeof EvaluationApproach>;
-        threshold: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
     output: z.ZodOptional<z.ZodString>;
     isRunning: z.ZodOptional<z.ZodBoolean>;
     error: z.ZodOptional<z.ZodString>;
     evaluationResult: z.ZodOptional<z.ZodCustom<EvaluationResult, EvaluationResult>>;
     responseTime: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-export type EvaluationParameters = z.infer<typeof evaluationParametersSchema>;
 export type TestCaseInput = z.infer<typeof testCaseInputSchema>;
-export type LegacyTestCaseInput = z.infer<typeof legacyTestCaseInputSchema>;
-export type V2TestCaseInput = z.infer<typeof v2TestCaseInputSchema>;
 export type TestCase = z.infer<typeof testCaseSchema>;
 export declare function validateTestCaseInput(data: unknown): asserts data is TestCaseInput;
 export declare function validateTestCaseInputArray(data: unknown): asserts data is TestCaseInput[];

package/dist/types/types/llm-test-runner.d.ts

@@ -1,6 +1,6 @@
 import type { TestCase } from './test-case';
 export type { ExpectedOutcomeFieldType, ExpectedOutcomeBase, ExpectedOutcomeSchema, ExpectedOutcomeSchemaField, ExpectedOutcomeField, TextExpectedOutcomeSchemaField, TextareaExpectedOutcomeSchemaField, ChipsExpectedOutcomeSchemaField, SelectExpectedOutcomeSchemaField, TextExpectedOutcomeField, TextareaExpectedOutcomeField, ChipsExpectedOutcomeField, SelectExpectedOutcomeField, } from './expected-outcome';
-export type { TestCase, TestCaseInput, LegacyTestCaseInput, V2TestCaseInput, } from './test-case';
+export type { TestCase, TestCaseInput, } from './test-case';
 export interface LLMRequestPayload {
     prompt: string;
     resolve: (result: string) => void;

package/dist/types/types/test-case.d.ts

@@ -1 +1 @@
-export type { EvaluationParameters, TestCaseInput, LegacyTestCaseInput, V2TestCaseInput, TestCase, } from '../schemas/test-case';
+export type { TestCaseInput, TestCase, } from '../schemas/test-case';