llm-testrunner-components 1.0.6 → 1.0.9

package/dist/types/lib/evaluation/evaluators/semantic/SemanticEvaluator.d.ts

@@ -0,0 +1,6 @@
+import { EvaluationResult, EvaluationRequest } from '../../types';
+export declare class SemanticEvaluator {
+    private static extractor;
+    initialize(): Promise<void>;
+    performEvaluation(request: EvaluationRequest): Promise<EvaluationResult>;
+}

package/dist/types/lib/evaluation/evaluators/semantic/evaluate-keywords.d.ts

@@ -0,0 +1,7 @@
+import { KeywordMatch } from '../../types';
+import { FeatureExtractionPipeline } from '@xenova/transformers';
+/**
+ * Evaluates whether each keyword is semantically present in the response text.
+ * Uses embeddings and cosine similarity instead of direct string matching.
+ */
+export declare function evaluateKeywordsSemantically(extractor: FeatureExtractionPipeline, response: string, keywords: string[], threshold: number): Promise<KeywordMatch[]>;

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

@@ -0,0 +1,2 @@
+import { EvaluationRequest, EvaluationResult } from '../../types';
+export declare function performSemanticEvaluation(request: EvaluationRequest): Promise<EvaluationResult>;

package/dist/types/lib/evaluation/evaluators/semantic/model-loader.d.ts

@@ -0,0 +1 @@
+export declare function loadSemanticModel(): Promise<import("@xenova/transformers").FeatureExtractionPipeline>;

package/dist/types/lib/evaluation/evaluators/semantic/similarity-utils.d.ts

@@ -0,0 +1 @@
+export declare function cosineSimilarity(vecA: number[], vecB: number[]): number;

package/dist/types/lib/evaluation/evaluators/semantic/tests/evaluate-keywords.test.d.ts

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

package/dist/types/lib/evaluation/evaluators/semantic/text-utils.d.ts

@@ -0,0 +1 @@
+export declare function splitIntoWords(text: string): string[];

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

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

package/dist/types/lib/evaluation/rouge1-evaluator.test.d.ts

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

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

@@ -1,23 +1,35 @@
+import { EvaluationParameters, EvaluationApproachResult } from '../../types/evaluation';
 export interface EvaluationRequest {
     testCaseId: string;
     question: string;
-    expectedKeywords: string[];
-    expectedSourceLinks: string[];
+    expectedOutcome: string;
     actualResponse: string;
+    evaluationParameters: EvaluationParameters;
 }
 export interface EvaluationResult {
     testCaseId: string;
     passed: boolean;
     keywordMatches: KeywordMatch[];
-    sourceLinkMatches: SourceLinkMatch[];
     timestamp?: string;
+    evaluationParameters: EvaluationParameters;
+    evaluationApproachResult: EvaluationApproachResult;
 }
 export interface KeywordMatch {
     keyword: string;
     found: boolean;
-}
-export interface SourceLinkMatch {
-    link: string;
-    found: boolean;
+    evaluationApproachResult: EvaluationApproachResult;
 }
 export type EvaluationCallback = (result: EvaluationResult) => void;
+export interface RougeKeywordDetails {
+    rouge1: number;
+    rougeL: number;
+    scoreUsed: string;
+    approach: string;
+}
+export interface Rouge1OverallDetails {
+    keywordsPassed: number;
+    totalKeywords: number;
+    passRate: string;
+    thresholdUsed: number;
+    approach: string;
+}

package/dist/types/lib/file/file-download.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Downloads a file to the user's device
+ * @param content - The content to download
+ * @param filename - The name of the file to download
+ * @param mimeType - The MIME type of the file
+ */
+export declare function downloadFile(content: string, filename: string, mimeType: string): void;

package/dist/types/lib/file/file-reader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reads a file asynchronously and returns its content as a string
+ * @param file - The File object to read
+ * @returns Promise that resolves with the file content as a string
+ */
+export declare function readFileAsync(file: File): Promise<string>;

package/dist/types/lib/form/components/app-chips.d.ts

@@ -0,0 +1,20 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { ChipsConfig } from '../schema';
+export declare class AppChips {
+    value: string[];
+    config: ChipsConfig;
+    testCaseId: string;
+    addChip: EventEmitter<{
+        key: string;
+        value: string;
+        testCaseId: string;
+    }>;
+    removeChip: EventEmitter<{
+        key: string;
+        index: number;
+        testCaseId: string;
+    }>;
+    private emitAddChip;
+    private emitRemoveChip;
+    render(): any;
+}

package/dist/types/lib/form/components/app-select.d.ts

@@ -0,0 +1,7 @@
+import { SelectConfig } from '../schema';
+export declare class AppSelect {
+    value: any;
+    onChange: (value: any) => void;
+    config: SelectConfig;
+    render(): any;
+}

package/dist/types/lib/form/components/app-textarea.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { TextAreaConfig } from '../schema';
+export declare class AppTextarea {
+    testCaseId: string;
+    value: string;
+    config: TextAreaConfig;
+    valueChange: EventEmitter<{
+        key: string;
+        value: string;
+        testCaseId: string;
+    }>;
+    private handleChange;
+    render(): any;
+}

package/dist/types/lib/form/form-builder.d.ts

@@ -0,0 +1,24 @@
+import { FieldConfig } from './schema';
+import { TestCase } from '../../types/llm-test-runner';
+export declare class FormBuilder {
+    fields: FieldConfig[];
+    onUpdateApproach: (testCase: TestCase, approach: any) => void;
+    testCase: TestCase;
+    handleTestCaseChange: (e: CustomEvent<{
+        testCaseId: string;
+        key: string;
+        value: string;
+    }>) => void;
+    addChip: (e: CustomEvent<{
+        testCaseId: string;
+        key: string;
+        value: string;
+    }>) => void;
+    removeChip: (e: CustomEvent<{
+        testCaseId: string;
+        key: string;
+        index: number;
+    }>) => void;
+    renderField(field: FieldConfig): any;
+    render(): any;
+}

package/dist/types/lib/form/schema/base-input-field-config.d.ts

@@ -0,0 +1,37 @@
+import { FormFieldType } from '.';
+/**
+ * - minLength / maxLength: character limits
+ * - min / max: numeric or date boundaries
+ * - step: allowed increment between numeric values (e.g., 0.5 → 0, 0.5, 1.0...)
+ * - custom: custom validator returning error message or null
+ */
+export interface InputFieldValidation {
+    required?: boolean | string;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp | string;
+    min?: number | string | Date;
+    max?: number | string | Date;
+    step?: number;
+    custom?: (value: any, allValues?: Record<string, any>) => string | null;
+}
+/**
+ * - helpText:Field Support text
+ */
+export interface BaseInputFieldConfig {
+    name: string;
+    fieldType: FormFieldType;
+    type?: string;
+    label?: string;
+    placeholder?: string;
+    defaultValue?: any;
+    autocomplete?: string;
+    required?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    helpText?: string;
+    validation?: InputFieldValidation;
+    hidden?: boolean;
+    className?: string;
+    style?: Record<string, any>;
+}

package/dist/types/lib/form/schema/form-control-config.d.ts

@@ -0,0 +1,13 @@
+import { FormFieldType } from '.';
+import { BaseInputFieldConfig } from './base-input-field-config';
+export interface TextAreaConfig extends BaseInputFieldConfig {
+    fieldType: FormFieldType.TEXT_AREA;
+    rows?: number;
+}
+export interface ChipsConfig extends BaseInputFieldConfig {
+    fieldType: FormFieldType.CHIPS;
+}
+export interface SelectConfig extends BaseInputFieldConfig {
+    fieldType: FormFieldType.SELECT;
+    optionList: any[];
+}

package/dist/types/lib/form/schema/index.d.ts

@@ -0,0 +1,9 @@
+import { InputFieldValidation, BaseInputFieldConfig } from './base-input-field-config';
+import { ChipsConfig, TextAreaConfig, SelectConfig } from './form-control-config';
+type FieldConfig = TextAreaConfig | ChipsConfig | SelectConfig;
+declare enum FormFieldType {
+    TEXT_AREA = "textarea",
+    CHIPS = "chips",
+    SELECT = "select"
+}
+export { InputFieldValidation, BaseInputFieldConfig, TextAreaConfig, ChipsConfig, SelectConfig, FieldConfig, FormFieldType, };

package/dist/types/lib/import-export/test-results-csv.d.ts

@@ -0,0 +1,13 @@
+import { TestCase } from '../../types/llm-test-runner';
+/**
+ * Escapes a CSV field by wrapping it in quotes if it contains special characters
+ * @param field - The field to escape
+ * @returns Escaped field string
+ */
+export declare function escapeCsvField(field: string): string;
+/**
+ * Exports test results to a CSV string
+ * @param testCases - Array of test cases with results to export
+ * @returns CSV string representation of the test results
+ */
+export declare function exportTestResultsToCsv(testCases: TestCase[]): string;

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

@@ -0,0 +1,16 @@
+import { TestCase } from '../../types/llm-test-runner';
+export interface TestSuiteExportData {
+    id: string;
+    question: string;
+    expectedOutcome: string;
+    evaluationParameters?: {
+        approach: string;
+        threshold?: number;
+    };
+}
+/**
+ * Formats test cases as a JSON string suitable for saving as a test suite
+ * @param testCases - Array of test cases to format
+ * @returns JSON string representation of the test suite
+ */
+export declare function formatTestSuiteAsJson(testCases: TestCase[]): string;

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

@@ -0,0 +1,12 @@
+import { TestCase } from '../../types/llm-test-runner';
+export interface ImportValidationResult {
+    success: boolean;
+    testCases?: TestCase[];
+    error?: string;
+}
+/**
+ * Validates and imports test cases from JSON content
+ * @param jsonContent - The JSON string to parse and validate
+ * @returns Validation result with test cases or error message
+ */
+export declare function importTestSuite(jsonContent: string): ImportValidationResult;

package/dist/types/lib/rate-limited-fetcher/rate-limited-fetcher.d.ts

@@ -1,7 +1,7 @@
 export declare class RateLimitedFetcher {
     private queue;
     private delay;
-    private intervalId?;
+    private timer?;
     constructor(delayMs: number);
     private startQueue;
     schedule<T>(task: () => Promise<T>): Promise<T>;

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

@@ -0,0 +1,12 @@
+import { TestCase } from '../../types/llm-test-runner';
+/**
+ * Creates a new test case with default values
+ * @returns A new TestCase object with a unique ID
+ */
+export declare function createTestCase(): TestCase;
+/**
+ * Creates a test case from imported data with defaults
+ * @param data - Partial test case data from import
+ * @returns A new TestCase object with defaults applied
+ */
+export declare function createTestCaseFromImport(data: unknown): TestCase;

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

@@ -0,0 +1,9 @@
+import { TestCase } from '../../types/llm-test-runner';
+import { EvaluationApproach } from '../evaluation/constants';
+/**
+ * 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
+ */
+export declare function updateApproach(testCase: TestCase, approach: EvaluationApproach): TestCase;

package/dist/types/lib/ui/button/button.d.ts

@@ -0,0 +1,13 @@
+import { FunctionalComponent } from '../../../stencil-public-runtime';
+export interface ButtonProps {
+    'variant'?: 'primary' | 'secondary' | 'outline' | 'destructive';
+    'size'?: 'sm' | 'md' | 'lg';
+    'disabled'?: boolean;
+    'loading'?: boolean;
+    'onClick'?: (event: MouseEvent) => void;
+    'type'?: 'button' | 'submit' | 'reset';
+    'class'?: string;
+    'icon'?: string;
+    'aria-label'?: string;
+}
+export declare const Button: FunctionalComponent<ButtonProps>;

package/dist/types/lib/ui/button/index.d.ts

@@ -0,0 +1,2 @@
+export { Button } from './button';
+export type { ButtonProps } from './button';

package/dist/types/lib/ui/icon-button/icon-button.d.ts

@@ -0,0 +1,11 @@
+import { FunctionalComponent } from '../../../stencil-public-runtime';
+export interface IconButtonProps {
+    variant?: 'primary' | 'secondary' | 'outline' | 'destructive';
+    disabled?: boolean;
+    loading?: boolean;
+    onClick?: (event: MouseEvent) => void;
+    type?: 'button' | 'submit' | 'reset';
+    title?: string;
+    class?: string;
+}
+export declare const IconButton: FunctionalComponent<IconButtonProps>;

package/dist/types/lib/ui/icon-button/index.d.ts

@@ -0,0 +1,2 @@
+export { IconButton } from './icon-button';
+export type { IconButtonProps } from './icon-button';

package/dist/types/services/adapters.d.ts

@@ -0,0 +1,3 @@
+export interface LlmAdapter {
+    invoke: Awaited<unknown>;
+}

package/dist/types/services/models/gemini.d.ts

@@ -0,0 +1,11 @@
+import type { LlmAdapter } from '../adapters';
+export declare const enum GeminiModels {
+    Gemini3Pro__Preview = "gemini-3-pro-preview",
+    Gemini3ProImage__Preview = "gemini-3-pro-image-preview",
+    Gemini3Flash__Preview = "gemini-3-flash-preview"
+}
+export declare class GeminiAdapter implements LlmAdapter {
+    private readonly sdk;
+    constructor(key: string);
+    invoke(text: string): Promise<any>;
+}

package/dist/types/stencil-public-runtime.d.ts

@@ -63,6 +63,12 @@ export interface ShadowRootOptions {
      * focusable part is given focus, and the shadow host is given any available `:focus` styling.
      */
     delegatesFocus?: boolean;
+    /**
+     * Sets the slot assignment mode for the shadow root. When set to `'manual'`, enables imperative
+     * slotting using the `HTMLSlotElement.assign()` method. Defaults to `'named'` for standard
+     * declarative slotting behavior.
+     */
+    slotAssignment?: 'manual' | 'named';
 }
 export interface ModeStyles {
     [modeName: string]: string | string[];
@@ -119,12 +125,34 @@ export interface EventOptions {
      */
     composed?: boolean;
 }
+export interface AttachInternalsOptions {
+    /**
+     * Initial custom states to set on the ElementInternals.states CustomStateSet.
+     * Each key is the state name and the value is the initial boolean state.
+     *
+     * These states can be targeted with the CSS `:state()` pseudo-class.
+     *
+     * @example
+     * ```tsx
+     * @AttachInternals({ states: { open: true, active: false } })
+     * internals: ElementInternals;
+     * ```
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/CustomStateSet
+     */
+    states?: {
+        [stateName: string]: boolean;
+    };
+}
 export interface AttachInternalsDecorator {
-    (): PropertyDecorator;
+    (opts?: AttachInternalsOptions): PropertyDecorator;
 }
 export interface ListenDecorator {
     (eventName: string, opts?: ListenOptions): CustomMethodDecorator<any>;
 }
+export interface ResolveVarFunction {
+    <T>(variable: T): string;
+}
 export interface ListenOptions {
     /**
      * Handlers can also be registered for an event other than the host itself.
@@ -153,7 +181,9 @@ export interface StateDecorator {
     (): PropertyDecorator;
 }
 export interface WatchDecorator {
-    (propName: any): CustomMethodDecorator<(newValue?: any, oldValue?: any, propName?: any, ...args: any[]) => any | void>;
+    (propName: any, watchOptions?: {
+        immediate?: boolean;
+    }): CustomMethodDecorator<(newValue?: any, oldValue?: any, propName?: any, ...args: any[]) => any | void>;
 }
 export interface PropSerializeDecorator {
     (propName: any): CustomMethodDecorator<(newValue?: any, propName?: string, ...args: any[]) => string | null>;
@@ -208,6 +238,24 @@ export declare const AttachInternals: AttachInternalsDecorator;
  * https://stenciljs.com/docs/events#listen-decorator
  */
 export declare const Listen: ListenDecorator;
+/**
+ * The `resolveVar()` function is a compile-time utility that resolves const variables
+ * and object properties to their string literal values. This allows variables to be
+ * used in `@Listen` and `@Event` decorators instead of hardcoded strings.
+ *
+ * @example
+ * ```ts
+ * const MY_EVENT = 'myEvent';
+ * @Listen(resolveVar(MY_EVENT))
+ * ```
+ *
+ * @example
+ * ```ts
+ * const EVENTS = { MY_EVENT: 'myEvent' } as const;
+ * @Event({ eventName: resolveVar(EVENTS.MY_EVENT) })
+ * ```
+ */
+export declare const resolveVar: ResolveVarFunction;
 /**
  * The `@Method()` decorator is used to expose methods on the public API.
  * Class methods decorated with the @Method() decorator can be called directly
@@ -339,7 +387,7 @@ export declare function forceUpdate(ref: any): void;
  * @returns the rendering ref
  */
 export declare function getRenderingRef(): any;
-export interface HTMLStencilElement extends Omit<HTMLElement, 'autocorrect'> {
+export interface HTMLStencilElement extends HTMLElement {
     componentOnReady(): Promise<this>;
 }
 /**
@@ -365,6 +413,27 @@ export declare function readTask(task: RafCallback): void;
  * Unhandled exception raised while rendering, during event handling, or lifecycles will trigger the custom event handler.
  */
 export declare const setErrorHandler: (handler: ErrorHandler) => void;
+export type TagTransformer = (tag: string) => string;
+/**
+ * Sets a tag transformer to be used when rendering your custom elements.
+ * ```ts
+ * setTagTransformer((tag) => {
+ *  if (tag.startsWith('my-')) return `new-${tag}`
+ *  return tag;
+ * });
+ * ```
+ * Will mean all your components that start with `my-` are defined instead with `new-my-` prefix.
+ *
+ * @param transformer the transformer function to use which must return a string.
+ */
+export declare function setTagTransformer(transformer: TagTransformer): void;
+/**
+ * Transforms a tag name using a transformer set via `setTagTransformer`
+ *
+ * @param tag - the tag to transform e.g. `my-tag`
+ * @returns the transformed tag e.g. `new-my-tag`
+ */
+export declare function transformTag(tag: string): string;
 /**
  * @deprecated - Use `MixedInCtor` instead:
  * ```ts
@@ -568,7 +637,7 @@ export interface FunctionalUtilities {
     map: (children: VNode[], cb: (vnode: ChildNode, index: number, array: ChildNode[]) => ChildNode) => VNode[];
 }
 export interface FunctionalComponent<T = {}> {
-    (props: T, children: VNode[], utils: FunctionalUtilities): VNode | VNode[];
+    (props: T, children: VNode[], utils: FunctionalUtilities): VNode | VNode[] | null;
 }
 /**
  * A Child VDOM node
@@ -610,6 +679,7 @@ export declare namespace h {
     function h(sel: any, data: VNodeData | null, text: string): VNode;
     function h(sel: any, data: VNodeData | null, children: Array<VNode | undefined | null>): VNode;
     function h(sel: any, data: VNodeData | null, children: VNode): VNode;
+    function h(sel: any, data: VNodeData | null, ...children: (VNode | string | number)[]): VNode;
     namespace JSX {
         interface IntrinsicElements extends LocalJSX.IntrinsicElements, JSXBase.IntrinsicElements {
             [tagName: string]: any;
@@ -624,6 +694,36 @@ export declare function h(sel: any, children: Array<VNode | undefined | null>):
 export declare function h(sel: any, data: VNodeData | null, text: string): VNode;
 export declare function h(sel: any, data: VNodeData | null, children: Array<VNode | undefined | null>): VNode;
 export declare function h(sel: any, data: VNodeData | null, children: VNode): VNode;
+export declare function h(sel: any, data: VNodeData | null, ...children: (VNode | string | number)[]): VNode;
+/**
+ * Automatic JSX runtime functions for TypeScript's react-jsx mode.
+ * These functions are called automatically by TypeScript when using "jsx": "react-jsx".
+ * @param type type of node
+ * @param props properties of node
+ * @param key optional key for the node
+ * @returns a jsx vnode
+ */
+export declare function jsx(type: any, props: any, key?: string): VNode;
+/**
+ * Automatic JSX runtime functions for TypeScript's react-jsxmode with multiple children.
+ * @param type type of node
+ * @param props properties of node
+ * @param key optional key for the node
+ * @returns a jsx vnode
+ */
+export declare function jsxs(type: any, props: any, key?: string): VNode;
+/**
+ * Automatic JSX runtime functions for TypeScript's react-jsxdev mode.
+ * These functions are called automatically by TypeScript when using "jsx": "react-jsxdev".
+ * @param type type of node
+ * @param props properties of node
+ * @param key optional key for the node
+ * @param isStaticChildren indicates if the children are static
+ * @param source source information
+ * @param self reference to the component instance
+ * @returns a jsx vnode
+ */
+export declare function jsxDEV(type: any, props: any, key?: string | number, isStaticChildren?: boolean, source?: any, self?: any): VNode;
 /**
  * A virtual DOM node
  */
@@ -653,7 +753,7 @@ declare namespace LocalJSX {
 export { LocalJSX as JSX };
 export declare namespace JSXBase {
     interface IntrinsicElements {
-        slot: JSXBase.SlotAttributes;
+        slot: JSXBase.SlotAttributes<HTMLSlotElement>;
         a: JSXBase.AnchorHTMLAttributes<HTMLAnchorElement>;
         abbr: JSXBase.HTMLAttributes;
         address: JSXBase.HTMLAttributes;
@@ -823,7 +923,7 @@ export declare namespace JSXBase {
         use: JSXBase.SVGAttributes;
         view: JSXBase.SVGAttributes;
     }
-    interface SlotAttributes extends JSXAttributes {
+    interface SlotAttributes<T = HTMLSlotElement> extends JSXAttributes<T> {
         name?: string;
         slot?: string;
         onSlotchange?: (event: Event) => void;
@@ -879,6 +979,9 @@ export declare namespace JSXBase {
         popoverTargetAction?: string;
         popoverTargetElement?: Element | null;
         popoverTarget?: string;
+        command?: string;
+        commandFor?: string;
+        commandfor?: string;
     }
     interface CanvasHTMLAttributes<T> extends HTMLAttributes<T> {
         height?: number | string;
@@ -1747,6 +1850,7 @@ export interface CustomElementsDefineOptions {
     exclude?: string[];
     resourcesUrl?: string;
     syncQueue?: boolean;
+    /** @deprecated in-favour of `setTagTransformer` and `transformTag` */
     transformTagName?: (tagName: string) => string;
     jmp?: (c: Function) => any;
     raf?: (c: FrameRequestCallback) => number;

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

@@ -0,0 +1,9 @@
+import { EvaluationApproach } from '../lib/evaluation/constants';
+export interface EvaluationParameters {
+    approach: EvaluationApproach;
+    threshold?: number;
+}
+export interface EvaluationApproachResult {
+    score: number;
+    approachUsed: EvaluationApproach;
+}

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

@@ -0,0 +1,22 @@
+import { EvaluationParameters } from './evaluation';
+import { EvaluationResult } from '../lib/evaluation/types';
+export interface TestCase {
+    id: string;
+    question: string;
+    expectedOutcome: string;
+    evaluationParameters?: EvaluationParameters;
+    output?: string;
+    isRunning?: boolean;
+    error?: string;
+    evaluationResult?: EvaluationResult;
+    responseTime?: number;
+}
+export interface LLMRequestPayload {
+    prompt: string;
+    resolve: (result: string) => void;
+    reject: (err: Error | unknown) => void;
+}
+export interface SavePayload {
+    timestamp: string;
+    testCases: TestCase[];
+}