llm-testrunner-components 1.2.2 → 1.2.4

package/dist/esm/index.js

@@ -103,6 +103,10 @@ function formatTestSuiteAsJson(testCases) {
         id: testCase.id,
         question: testCase.question,
         expectedOutcome: testCase.expectedOutcome,
+        chatHistory: {
+            enabled: testCase.chatHistory.enabled,
+            value: testCase.chatHistory.value,
+        },
     }));
     return JSON.stringify(exportData, null, 2);
 }
@@ -300,6 +304,7 @@ function createTestCase(expectedOutcomeSchema = DEFAULT_EXPECTED_OUTCOME_SCHEMA)
         id: v4(),
         question: '',
         expectedOutcome: createExpectedOutcomeFromSchema(expectedOutcomeSchema),
+        chatHistory: { enabled: false, value: '' },
         isRunning: false,
     };
 }
@@ -359,6 +364,7 @@ function createExpectedOutcomeFromSchema(expectedOutcomeSchema) {
 function createTestCaseFromInput(data) {
     return {
         ...data,
+        chatHistory: data.chatHistory ?? { enabled: false, value: '' },
         expectedOutcome: data.expectedOutcome.map(normalizeExpectedOutcomeField),
     };
 }
@@ -4952,6 +4958,7 @@ const optionalPositiveInt = number().int().positive().optional();
 const optionalString = string().optional();
 const selectOptionsSchema = array(nonEmptyString).min(1);
 const optionalNumber = number().optional();
+const expectedOutcomeModeSchema = _enum(['static', 'dynamic']);
 const evaluationParametersSchema = object({
     approach: _enum(EvaluationApproach),
     threshold: optionalNumber,
@@ -5013,8 +5020,21 @@ const expectedOutcomeFieldSchema = discriminatedUnion('type', [
     defaultFieldDefinitions.text.extend({
         value: string(),
     }),
-    defaultFieldDefinitions.textarea.extend({
+    defaultFieldDefinitions.textarea
+        .extend({
         value: string(),
+        outcomeMode: expectedOutcomeModeSchema.default('static'),
+        resolutionQuery: string().optional(),
+    })
+        .superRefine((field, ctx) => {
+        if (field.outcomeMode === 'dynamic' &&
+            (!field.resolutionQuery || field.resolutionQuery.trim().length === 0)) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['resolutionQuery'],
+                message: 'resolutionQuery is required when outcomeMode is dynamic.',
+            });
+        }
     }),
     defaultFieldDefinitions.chipsInput.extend({
         value: array(string()).superRefine((values, ctx) => {
@@ -5048,16 +5068,22 @@ function validateExpectedOutcomeSchema(schema) {
     }
 }
 
+const testCaseChatHistorySchema = object({
+    enabled: boolean(),
+    value: string(),
+});
 const testCaseInputSchema = object({
     id: string(),
     question: string(),
     expectedOutcome: expectedOutcomeArraySchema,
+    chatHistory: testCaseChatHistorySchema.optional(),
 });
 const testCaseInputArraySchema = array(testCaseInputSchema);
 object({
     id: string(),
     question: string(),
     expectedOutcome: expectedOutcomeArraySchema,
+    chatHistory: testCaseChatHistorySchema,
     output: string().optional(),
     isRunning: boolean().optional(),
     error: string().optional(),
@@ -5108,6 +5134,50 @@ function importTestSuite(jsonContent) {
     }
 }
 
+const MISSING_RESOLVER_MESSAGE = 'resolveExpectedOutcome is required when a test case has dynamic expected outcomes.';
+function isDynamicTextareaField(field) {
+    return field.type === 'textarea' && field.outcomeMode === 'dynamic';
+}
+function applyResolvedDynamicValues(testCase, resolvedValues) {
+    if (resolvedValues.length === 0) {
+        return testCase;
+    }
+    const expectedOutcome = [...(testCase.expectedOutcome || [])];
+    for (const resolved of resolvedValues) {
+        const field = expectedOutcome[resolved.index];
+        if (!field || !isDynamicTextareaField(field)) {
+            continue;
+        }
+        expectedOutcome[resolved.index] = {
+            ...field,
+            value: resolved.value,
+        };
+    }
+    return {
+        ...testCase,
+        expectedOutcome,
+    };
+}
+async function resolveDynamicExpectedOutcomes(testCase, resolver) {
+    const dynamicFields = (testCase.expectedOutcome || []).flatMap((field, index) => {
+        if (!isDynamicTextareaField(field)) {
+            return [];
+        }
+        return [{ field, index }];
+    });
+    if (dynamicFields.length === 0) {
+        return testCase;
+    }
+    if (!resolver) {
+        throw new Error(MISSING_RESOLVER_MESSAGE);
+    }
+    const resolvedValues = await Promise.all(dynamicFields.map(async ({ field, index }) => ({
+        index,
+        value: await resolver(field.resolutionQuery || '', { testCase, fieldIndex: index }),
+    })));
+    return applyResolvedDynamicValues(testCase, resolvedValues);
+}
+
 function applyExpectedOutcomeChange(testCase, change) {
     const { index } = change;
     const expectedOutcome = [...(testCase.expectedOutcome || [])];
@@ -5120,6 +5190,9 @@ function applyExpectedOutcomeChange(testCase, change) {
             if (target.type === 'chips-input') {
                 return testCase;
             }
+            if (target.type === 'textarea' && target.outcomeMode === 'dynamic') {
+                return testCase;
+            }
             expectedOutcome[index] = {
                 ...target,
                 value: change.value,
@@ -5148,6 +5221,38 @@ function applyExpectedOutcomeChange(testCase, change) {
         }
         case 'set-evaluation-approach':
             return updateExpectedOutcomeFieldApproach(testCase, index, change.value);
+        case 'set-outcome-mode': {
+            if (target.type !== 'textarea') {
+                return testCase;
+            }
+            const mode = change.value;
+            if (mode === 'static') {
+                const { resolutionQuery: _, ...rest } = target;
+                expectedOutcome[index] = {
+                    ...rest,
+                    outcomeMode: 'static',
+                    value: '',
+                };
+            }
+            else {
+                expectedOutcome[index] = {
+                    ...target,
+                    outcomeMode: 'dynamic',
+                    value: '',
+                };
+            }
+            return { ...testCase, expectedOutcome };
+        }
+        case 'set-resolution-query': {
+            if (target.type !== 'textarea' || target.outcomeMode !== 'dynamic') {
+                return testCase;
+            }
+            expectedOutcome[index] = {
+                ...target,
+                resolutionQuery: change.value,
+            };
+            return { ...testCase, expectedOutcome };
+        }
     }
 }
 /**
@@ -30015,13 +30120,20 @@ class EvaluationService {
             console.warn('⚠️ No output to evaluate for test case:', testCase.id);
             return;
         }
-        const fields = (testCase.expectedOutcome || []).map((field, index) => ({
-            index,
-            label: field.label,
-            type: field.type,
-            expectedValue: getFieldExpectedValue(field),
-            evaluationParameters: normalizeEvaluationParametersForField(field.type, field.evaluationParameters),
-        }));
+        const fields = (testCase.expectedOutcome || []).flatMap((field, index) => {
+            if (field.type === 'textarea' && field.outcomeMode === 'dynamic') {
+                return [];
+            }
+            return [
+                {
+                    index,
+                    label: field.label,
+                    type: field.type,
+                    expectedValue: getFieldExpectedValue(field),
+                    evaluationParameters: normalizeEvaluationParametersForField(field.type, field.evaluationParameters),
+                },
+            ];
+        });
         const evaluationRequest = {
             testCaseId: testCase.id,
             question: testCase.question,
@@ -30116,7 +30228,7 @@ var FormFieldType;
     FormFieldType["SELECT"] = "select";
 })(FormFieldType || (FormFieldType = {}));
 
-const ExpectedOutcomeRenderer = ({ testCaseId, fields, onExpectedOutcomeChange, }) => {
+const ExpectedOutcomeRenderer = ({ testCaseId, fields, dynamicResolutionSupported = false, onExpectedOutcomeChange, }) => {
     const emit = (detail) => onExpectedOutcomeChange({
         detail,
     });
@@ -30129,6 +30241,23 @@ const ExpectedOutcomeRenderer = ({ testCaseId, fields, onExpectedOutcomeChange,
         optionList,
         defaultValue: EvaluationApproach.EXACT,
     });
+    const buildOutcomeModeConfig = (index) => ({
+        name: `expectedOutcomeMode-${index}`,
+        fieldType: FormFieldType.SELECT,
+        label: 'Outcome Mode',
+        placeholder: 'Select outcome mode',
+        required: true,
+        optionList: ['static', 'dynamic'],
+        defaultValue: 'static',
+    });
+    const buildResolutionQueryConfig = (index) => ({
+        name: `expectedOutcomeResolutionQuery-${index}`,
+        fieldType: FormFieldType.TEXT_AREA,
+        label: 'Resolution Query',
+        placeholder: 'Query used to resolve expected value',
+        required: false,
+        rows: 2,
+    });
     const renderEvaluationSelector = (field, index) => {
         const optionList = getAllowedApproachesForFieldType(field.type);
         return (h("app-select", { config: buildEvaluationConfig(index, optionList), value: field.evaluationParameters?.approach, onValueChange: (e) => emit({
@@ -30140,12 +30269,17 @@ const ExpectedOutcomeRenderer = ({ testCaseId, fields, onExpectedOutcomeChange,
     };
     return (h("div", { class: "expected-outcome-renderer" }, (fields || []).map((field, index) => {
         if (field.type === 'textarea') {
+            const isDynamic = dynamicResolutionSupported && field.outcomeMode === 'dynamic';
             const config = {
                 name: `expectedOutcome-${index}`,
                 fieldType: FormFieldType.TEXT_AREA,
                 label: field.label,
-                placeholder: field.placeholder,
-                required: true,
+                placeholder: isDynamic ? 'Resolved on run' : field.placeholder,
+                required: !isDynamic,
+                readOnly: isDynamic,
+                helpText: isDynamic
+                    ? 'Filled automatically when the test is run'
+                    : undefined,
                 rows: field.rows || 2,
             };
             return (h("div", { class: "expected-outcome-renderer__group" }, h("app-textarea", { config: config, value: field.value, onValueChange: (e) => emit({
@@ -30153,7 +30287,18 @@ const ExpectedOutcomeRenderer = ({ testCaseId, fields, onExpectedOutcomeChange,
                     index,
                     operation: 'set-value',
                     value: e.detail.value,
-                }) }), renderEvaluationSelector(field, index)));
+                }) }), dynamicResolutionSupported && (h("app-select", { config: buildOutcomeModeConfig(index), value: field.outcomeMode || 'static', onValueChange: (e) => emit({
+                    testCaseId,
+                    index,
+                    operation: 'set-outcome-mode',
+                    value: e.detail.value,
+                }) })), dynamicResolutionSupported &&
+                field.outcomeMode === 'dynamic' && (h("app-textarea", { config: buildResolutionQueryConfig(index), value: field.resolutionQuery || '', onValueChange: (e) => emit({
+                    testCaseId,
+                    index,
+                    operation: 'set-resolution-query',
+                    value: e.detail.value,
+                }) })), !isDynamic && renderEvaluationSelector(field, index)));
         }
         if (field.type === 'chips-input') {
             const config = {
@@ -30200,7 +30345,7 @@ const ExpectedOutcomeRenderer = ({ testCaseId, fields, onExpectedOutcomeChange,
     })));
 };
 
-const LLMTestCaseRow = ({ testCase, onRun, onDelete, handleTestCaseChange, onExpectedOutcomeChange, }) => {
+const LLMTestCaseRow = ({ testCase, dynamicResolutionSupported = false, onRun, onDelete, handleTestCaseChange, onExpectedOutcomeChange, onChatHistoryChange, }) => {
     const questionConfig = {
         name: 'question',
         fieldType: FormFieldType.TEXT_AREA,
@@ -30216,11 +30361,21 @@ const LLMTestCaseRow = ({ testCase, onRun, onDelete, handleTestCaseChange, onExp
                 key: 'question',
                 value: e.detail.value,
             },
-        }) }), h(ExpectedOutcomeRenderer, { testCaseId: testCase.id, fields: testCase.expectedOutcome || [], onExpectedOutcomeChange: onExpectedOutcomeChange })), h(ResponseOutput, { output: testCase.output, isRunning: testCase.isRunning }), h(EvaluationSummary, { result: testCase.evaluationResult, isRunning: testCase.isRunning }), h(RowActions, { isRunning: testCase.isRunning, canRun: !!testCase.question.trim(), onRun: () => onRun(testCase), onDelete: () => onDelete(testCase.id) })));
+        }) }), h("chat-history", { chatHistoryEnabled: testCase.chatHistory?.enabled ?? false, chatHistoryValue: testCase.chatHistory?.value ?? '', onChatHistoryChange: (e) => {
+            const { enabled, value } = e
+                .detail;
+            onChatHistoryChange({
+                detail: {
+                    testCaseId: testCase.id,
+                    enabled,
+                    value,
+                },
+            });
+        } }), h(ExpectedOutcomeRenderer, { testCaseId: testCase.id, fields: testCase.expectedOutcome || [], dynamicResolutionSupported: dynamicResolutionSupported, onExpectedOutcomeChange: onExpectedOutcomeChange })), h(ResponseOutput, { output: testCase.output, isRunning: testCase.isRunning }), h(EvaluationSummary, { result: testCase.evaluationResult, isRunning: testCase.isRunning }), h(RowActions, { isRunning: testCase.isRunning, canRun: !!testCase.question.trim(), onRun: () => onRun(testCase), onDelete: () => onDelete(testCase.id) })));
 };
 
-const LLMTestCases = ({ testCases, onRun, onDelete, onAddTestCase, handleTestCaseChange, onExpectedOutcomeChange, }) => {
-    return (h("div", { class: "test-cases" }, h("div", { class: "test-cases__column-headers" }, h("div", { class: "test-cases__column-header" }, "Input"), h("div", { class: "test-cases__column-header" }, "Output"), h("div", { class: "test-cases__column-header" }, "Evaluation"), h("div", { class: "test-cases__column-header" }, "Actions")), testCases.map(testCase => (h(LLMTestCaseRow, { testCase: testCase, onRun: onRun, onDelete: onDelete, handleTestCaseChange: handleTestCaseChange, onExpectedOutcomeChange: onExpectedOutcomeChange }))), h("div", { class: "test-cases__add-section" }, h(Button, { variant: "outline", size: "md", onClick: onAddTestCase }, "+ Add Question"))));
+const LLMTestCases = ({ testCases, dynamicResolutionSupported = false, onRun, onDelete, onAddTestCase, handleTestCaseChange, onExpectedOutcomeChange, onChatHistoryChange, }) => {
+    return (h("div", { class: "test-cases" }, h("div", { class: "test-cases__column-headers" }, h("div", { class: "test-cases__column-header" }, "Input"), h("div", { class: "test-cases__column-header" }, "Output"), h("div", { class: "test-cases__column-header" }, "Evaluation"), h("div", { class: "test-cases__column-header" }, "Actions")), testCases.map(testCase => (h(LLMTestCaseRow, { testCase: testCase, dynamicResolutionSupported: dynamicResolutionSupported, onRun: onRun, onDelete: onDelete, handleTestCaseChange: handleTestCaseChange, onExpectedOutcomeChange: onExpectedOutcomeChange, onChatHistoryChange: onChatHistoryChange }))), h("div", { class: "test-cases__add-section" }, h(Button, { variant: "outline", size: "md", onClick: onAddTestCase }, "+ Add Question"))));
 };
 
 const tokensCss = () => `:host{--spacing:0.25rem;--spacing-1:calc(var(--spacing) * 1);--spacing-2:calc(var(--spacing) * 2);--spacing-3:calc(var(--spacing) * 3);--spacing-4:calc(var(--spacing) * 4);--spacing-5:calc(var(--spacing) * 5);--spacing-6:calc(var(--spacing) * 6);--spacing-8:calc(var(--spacing) * 8);--spacing-10:calc(var(--spacing) * 10);--spacing-12:calc(var(--spacing) * 12);--spacing-16:calc(var(--spacing) * 16);--spacing-20:calc(var(--spacing) * 20);--spacing-24:calc(var(--spacing) * 24);--radius-none:0;--radius-sm:0.125rem;--radius-md:0.375rem;--radius-lg:0.5rem;--radius-xl:0.75rem;--radius-2xl:1rem;--radius-3xl:1.5rem;--radius-full:9999px;--radius:var(--radius-lg);--font-size-xs:0.75rem;--font-size-sm:0.875rem;--font-size-base:1rem;--font-size-lg:1.125rem;--font-size-xl:1.25rem;--font-size-2xl:1.5rem;--font-size-3xl:1.875rem;--font-size-4xl:2.25rem;--font-weight-normal:400;--font-weight-medium:500;--font-weight-semibold:600;--font-weight-bold:700;--line-height-none:1;--line-height-tight:1.25;--line-height-snug:1.375;--line-height-normal:1.5;--line-height-relaxed:1.625;--line-height-loose:2;--letter-spacing-tight:-0.025em;--letter-spacing-normal:0;--letter-spacing-wide:0.05em;--shadow-sm:0 1px 2px 0 rgba(0, 0, 0, 0.05);--shadow-md:0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);--shadow-lg:0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);--shadow-xl:0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);--shadow-2xl:0 25px 50px -12px rgba(0, 0, 0, 0.25);--border-width:1px;--z-base:0;--z-dropdown:1000;--z-sticky:1100;--z-modal:1200;--z-popover:1300;--z-tooltip:1400;--opacity-disabled:0.5;--opacity-hover:0.8;--opacity-muted:0.6;--max-w-sm:24rem;--max-w-md:28rem;--max-w-lg:32rem;--max-w-xl:42rem;--max-w-2xl:48rem;--max-w-full:100%;--breakpoint-sm:640px;--breakpoint-md:768px;--breakpoint-lg:1024px;--breakpoint-xl:1280px;--breakpoint-2xl:1536px;--background:#ffffff;--foreground:#0a0a0a;--card:#ffffff;--card-foreground:#0a0a0a;--popover:#ffffff;--popover-foreground:#0a0a0a;--primary:#0a0a0a;--primary-foreground:#fafafa;--secondary:#f4f4f5;--secondary-foreground:#0a0a0a;--muted:#f4f4f5;--muted-foreground:#71717a;--accent:#f4f4f5;--accent-foreground:#0a0a0a;--destructive:#ef4444;--destructive-foreground:#fafafa;--border:#e4e4e7;--input:#e4e4e7;--ring:#3b82f6;--success:#10b981;--success-foreground:#fafafa;--warning:#f59e0b;--warning-foreground:#fafafa;--info:#3b82f6;--info-foreground:#fafafa}:host([data-theme='dark']){--background:#0a0a0a;--foreground:#fafafa;--card:#171717;--card-foreground:#fafafa;--popover:#171717;--popover-foreground:#fafafa;--primary:#fafafa;--primary-foreground:#0a0a0a;--secondary:#27272a;--secondary-foreground:#fafafa;--muted:#27272a;--muted-foreground:#a1a1aa;--accent:#27272a;--accent-foreground:#fafafa;--destructive:#dc2626;--destructive-foreground:#fafafa;--border:#27272a;--input:#27272a;--ring:#3b82f6;--success:#059669;--success-foreground:#fafafa;--warning:#d97706;--warning-foreground:#fafafa;--info:#2563eb;--info-foreground:#fafafa}`;
@@ -30256,6 +30411,7 @@ const LLMTestRunner = class {
     delayMs = 500;
     useSave = false;
     usePromptEditor = false;
+    resolveExpectedOutcome;
     initialTestCases;
     defaultExpectedOutcomeSchema;
     testCases = [
@@ -30269,6 +30425,7 @@ const LLMTestRunner = class {
                     value: '',
                 },
             ],
+            chatHistory: { enabled: false, value: '' },
             isRunning: false,
         },
     ];
@@ -30326,6 +30483,12 @@ const LLMTestRunner = class {
         const { testCaseId, key, value } = event.detail;
         this.testCases = this.testCases.map(tc => tc.id === testCaseId ? { ...tc, [key]: value } : tc);
     };
+    handleChatHistoryChange = (event) => {
+        const { testCaseId, enabled, value } = event.detail;
+        this.updateTestCase(testCaseId, {
+            chatHistory: { enabled, value },
+        });
+    };
     addNewTestCase() {
         try {
             const schema = this.getResolvedExpectedOutcomeSchema();
@@ -30342,38 +30505,66 @@ const LLMTestRunner = class {
     updateTestCase(id, updates) {
         this.testCases = this.testCases.map(tc => tc.id === id ? { ...tc, ...updates } : tc);
     }
+    requestLlmText(testCase) {
+        return new Promise((resolve, reject) => {
+            const payload = {
+                prompt: testCase.question,
+                resolve,
+                reject,
+            };
+            if (testCase.chatHistory?.enabled) {
+                payload.chatHistory = testCase.chatHistory.value;
+            }
+            this.llmRequest.emit(payload);
+        });
+    }
+    throwError(reason) {
+        throw reason instanceof Error ? reason : new Error(String(reason));
+    }
+    addErrorMessage(reason, fallback) {
+        return reason instanceof Error ? reason.message : fallback;
+    }
     async runSingleTest(testCase) {
         const startTime = Date.now();
         this.updateTestCase(testCase.id, { isRunning: true });
-        return new Promise((resolve, reject) => {
-            this.llmRequest.emit({
-                prompt: testCase.question,
-                resolve: async (aiResponse) => {
-                    const endTime = Date.now();
-                    const responseTime = endTime - startTime;
-                    this.updateTestCase(testCase.id, {
-                        isRunning: false,
-                        output: aiResponse,
-                        error: null,
-                        responseTime: responseTime,
-                    });
-                    await this.evaluateResponse({
-                        ...testCase,
-                        output: aiResponse,
-                        responseTime: responseTime,
-                    });
-                    resolve();
-                },
-                reject: (error) => {
-                    this.updateTestCase(testCase.id, {
-                        isRunning: false,
-                        output: null,
-                        error: error instanceof Error ? error.message : 'Unknown error',
-                    });
-                    reject(error);
-                },
+        const [llmSettled, resolutionSettled] = await Promise.allSettled([
+            this.requestLlmText(testCase),
+            resolveDynamicExpectedOutcomes(testCase, this.resolveExpectedOutcome),
+        ]);
+        const responseTime = Date.now() - startTime;
+        if (llmSettled.status === 'rejected') {
+            this.updateTestCase(testCase.id, {
+                isRunning: false,
+                output: null,
+                error: this.addErrorMessage(llmSettled.reason, 'Unknown error'),
+                responseTime,
             });
+            this.throwError(llmSettled.reason);
+        }
+        const aiResponse = llmSettled.value;
+        if (resolutionSettled.status === 'rejected') {
+            this.updateTestCase(testCase.id, {
+                isRunning: false,
+                output: aiResponse,
+                error: this.addErrorMessage(resolutionSettled.reason, 'Failed to resolve dynamic expected outcome.'),
+                responseTime,
+            });
+            this.throwError(resolutionSettled.reason);
+        }
+        const resolvedTestCase = resolutionSettled.value;
+        const forEvaluationTestCase = {
+            ...resolvedTestCase,
+            output: aiResponse,
+            responseTime,
+        };
+        this.updateTestCase(testCase.id, {
+            isRunning: false,
+            output: aiResponse,
+            error: null,
+            responseTime,
+            expectedOutcome: forEvaluationTestCase.expectedOutcome,
         });
+        await this.evaluateResponse(forEvaluationTestCase);
     }
     deleteTestCase(id) {
         this.testCases = this.testCases.filter(tc => tc.id !== id);
@@ -30484,7 +30675,7 @@ const LLMTestRunner = class {
         }
     }
     render() {
-        return (h("div", { key: '29cf8a93402ebad6f6df43e147fa10406577c9aa', class: "test-runner-container" }, h(LLMTestRunnerHeader, { key: 'a07d3d1d823f8d473808752932cd1b2ab72d9e08', isExportingTestSuite: this.isExportingTestSuite, isExportingTestResults: this.isExportingTestResults, isRunningAll: this.isRunningAll, useSave: this.useSave, isSaving: this.isSaving, usePromptEditor: this.usePromptEditor, onImport: file => this.handleImport(file), onExportSuite: () => this.handleExportTestSuite(), onExportResults: () => this.handleExportTestResults(), onRunAll: () => this.runAllTests(), onSave: () => this.handleSave() }), h(ErrorMessage, { key: 'ec68912728b06fc4a76c330fb1b7d5acde92c3d1', message: this.error, onClear: () => (this.error = '') }), h("div", { key: 'ce308dd4bd5437c94ae6e3e8a28970b799865281', class: "test-runner-container__content" }, h(LLMTestCases, { key: '3368df0bb7de4d099da1fad400f59dfc9a2cfb62', testCases: this.testCases, onRun: testCase => this.runSingleTest(testCase).catch(() => { }), onDelete: id => this.deleteTestCase(id), onAddTestCase: () => this.addNewTestCase(), handleTestCaseChange: this.handleTestCaseChange, onExpectedOutcomeChange: this.handleExpectedOutcomeChange }))));
+        return (h("div", { key: 'cc808096f929b2e1c570c53144aab195d177c187', class: "test-runner-container" }, h(LLMTestRunnerHeader, { key: 'b91cf3df7df0e95bfd4908a2f91c7310b5b7a09a', isExportingTestSuite: this.isExportingTestSuite, isExportingTestResults: this.isExportingTestResults, isRunningAll: this.isRunningAll, useSave: this.useSave, isSaving: this.isSaving, usePromptEditor: this.usePromptEditor, onImport: file => this.handleImport(file), onExportSuite: () => this.handleExportTestSuite(), onExportResults: () => this.handleExportTestResults(), onRunAll: () => this.runAllTests(), onSave: () => this.handleSave() }), h(ErrorMessage, { key: 'c7991497173fa9843e7aa42f5283d0897ddff2e2', message: this.error, onClear: () => (this.error = '') }), h("div", { key: '2b57132564442b8047d8672c6adcba62cdc9ae87', class: "test-runner-container__content" }, h(LLMTestCases, { key: '146e9d8c76a34980a2a274dd856887c22e1ed0e9', testCases: this.testCases, dynamicResolutionSupported: !!this.resolveExpectedOutcome, onRun: testCase => this.runSingleTest(testCase).catch(() => { }), onDelete: id => this.deleteTestCase(id), onAddTestCase: () => this.addNewTestCase(), handleTestCaseChange: this.handleTestCaseChange, onExpectedOutcomeChange: this.handleExpectedOutcomeChange, onChatHistoryChange: this.handleChatHistoryChange }))));
     }
 };
 LLMTestRunner.style = tokensCss() + (llmTestRunnerCss() + (llmTestRunnerHeaderCss() + (llmTestCasesCss() + (llmTestCaseRowCss() + (rowActionsCss() + (evaluationSummaryCss() + (responseOutputCss() + (errorMessageCss() + (buttonCss() + iconButtonCss())))))))));