llm-testrunner-components 1.1.0 → 1.2.0

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

@@ -24,7 +24,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/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';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-testrunner-components",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "A Stencil web component library for LLM test runner functionality",
   "main": "dist/index.cjs.js",
   "module": "dist/index.js",
@@ -36,6 +36,11 @@
     "type": "git",
     "url": "https://github.com/FluxonApps/llm-testrunner-lib.git"
   },
+  "bugs": {
+    "url": "https://github.com/FluxonApps/llm-testrunner-lib/issues"
+  },
+  "homepage": "https://github.com/FluxonApps/llm-testrunner-lib#readme",
+  "author": "Fluxon Apps LLC",
   "files": [
     "dist/",
     "loader/"
@@ -53,7 +58,8 @@
     "build-publish": "npm run build:all && npm run just-publish",
     "just-publish": "npm publish --access=public",
     "lint": "eslint src --ext .ts,.tsx",
-    "lint:fix": "eslint src --ext .ts,.tsx --fix"
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "license-check": "licensee"
   },
   "dependencies": {
     "@google/genai": "^1.40.0",
@@ -78,6 +84,7 @@
     "eslint-config-prettier": "^10.1.8",
     "jest": "^29.7.0",
     "jest-cli": "^29.7.0",
+    "licensee": "^12.0.1",
     "nodemon": "^3.1.11",
     "prettier": "^3.6.2",
     "puppeteer": "^24.3.0",