rippletide 1.0.7 → 1.0.9

package/bin/rippletide

@@ -3,6 +3,15 @@
 const args = process.argv.slice(2);
 const cmd = args[0];
 
+async function loadErrorHandler() {
+  try {
+    const module = await import('../dist/errors/handler.js');
+    return module.ErrorHandler;
+  } catch {
+    return null;
+  }
+}
+
 async function main() {
   if (!cmd || cmd === 'eval') {
     await import('../dist/index.js');
@@ -19,11 +28,13 @@ Usage:
 Options:
   -b, --backend-url <url>     Backend API URL (default: https://rippletide-backend.azurewebsites.net)
   -d, --dashboard-url <url>   Dashboard URL (default: https://eval.rippletide.com)
+  --debug                      Show detailed error information and stack traces
   -h, --help                  Show this help message
 
 Examples:
   rippletide eval
   rippletide eval -b http://localhost:3001 -d http://localhost:5173
+  rippletide eval --debug
 `);
     return;
   }
@@ -33,7 +44,26 @@ Examples:
   process.exit(1);
 }
 
-main().catch((err) => {
-  console.error('Error running rippletide:', err?.message || err);
+main().catch(async (err) => {
+  const ErrorHandler = await loadErrorHandler();
+  
+  if (ErrorHandler) {
+    ErrorHandler.handle(err);
+  } else {
+    const isDebug = args.includes('--debug');
+    console.error('\nError: An error occurred while running the CLI');
+    
+    if (err?.message) {
+      console.error(`   ${err.message}`);
+    }
+    
+    if (isDebug && err?.stack) {
+      console.error('\n[DEBUG] Stack trace:');
+      console.error(err.stack);
+    } else if (!isDebug) {
+      console.error('\nRun with --debug flag for more details');
+    }
+  }
+  
   process.exit(1);
 });

package/dist/App.d.ts

@@ -2,6 +2,16 @@ import React from 'react';
 interface AppProps {
     backendUrl?: string;
     dashboardUrl?: string;
+    nonInteractive?: boolean;
+    agentEndpoint?: string;
+    knowledgeSource?: string;
+    pineconeUrl?: string;
+    pineconeApiKey?: string;
+    postgresqlConnection?: string;
+    customHeaders?: Record<string, string>;
+    customBodyTemplate?: string;
+    customResponseField?: string;
+    templatePath?: string;
 }
 export declare const App: React.FC<AppProps>;
 export {};

package/dist/App.js

@@ -1,5 +1,5 @@
 import React, { useState, useEffect } from 'react';
-import { Box, Text } from 'ink';
+import { Box, Text, useApp } from 'ink';
 import { Header } from './components/Header.js';
 import { TextInput } from './components/TextInput.js';
 import { SelectMenu } from './components/SelectMenu.js';
@@ -9,6 +9,8 @@ import { Summary } from './components/Summary.js';
 import { api } from './api/client.js';
 import { getPineconeQAndA } from './utils/pinecone.js';
 import { getPostgreSQLQAndA, parsePostgreSQLConnectionString } from './utils/postgresql.js';
+import { BaseError, ValidationError } from './errors/types.js';
+import { logger } from './utils/logger.js';
 const knowledgeSources = [
     { label: 'Local Files (qanda.json)', value: 'files', description: 'Use qanda.json from current directory' },
     { label: 'Pinecone', value: 'pinecone', description: 'Fetch Q&A from Pinecone database' },
@@ -18,16 +20,24 @@ const knowledgeSources = [
     { label: 'GitHub Repository', value: 'github', description: 'Import from GitHub repo', disabled: true },
     { label: 'Skip (No Knowledge)', value: 'skip', description: 'Run tests without knowledge base', disabled: true },
 ];
-export const App = ({ backendUrl, dashboardUrl }) => {
-    const [step, setStep] = useState('agent-endpoint');
-    const [agentEndpoint, setAgentEndpoint] = useState('');
-    const [knowledgeSource, setKnowledgeSource] = useState('');
+export const App = ({ backendUrl, dashboardUrl, nonInteractive, agentEndpoint: initialAgentEndpoint, knowledgeSource: initialKnowledgeSource, pineconeUrl: initialPineconeUrl, pineconeApiKey: initialPineconeApiKey, postgresqlConnection: initialPostgresqlConnection, customHeaders, customBodyTemplate, customResponseField, templatePath }) => {
+    const { exit } = useApp();
+    const initialStep = nonInteractive && initialAgentEndpoint ? 'testing-connection' : 'agent-endpoint';
+    const [step, setStep] = useState(initialStep);
+    const [agentEndpoint, setAgentEndpoint] = useState(initialAgentEndpoint || '');
+    const [connectionTestResult, setConnectionTestResult] = useState(null);
+    const [customConfig, setCustomConfig] = useState({
+        headers: customHeaders,
+        bodyTemplate: customBodyTemplate,
+        responseField: customResponseField
+    });
+    const [knowledgeSource, setKnowledgeSource] = useState(initialKnowledgeSource || '');
     const [knowledgeFound, setKnowledgeFound] = useState(false);
-    const [pineconeUrl, setPineconeUrl] = useState('');
-    const [pineconeApiKey, setPineconeApiKey] = useState('');
+    const [pineconeUrl, setPineconeUrl] = useState(initialPineconeUrl || '');
+    const [pineconeApiKey, setPineconeApiKey] = useState(initialPineconeApiKey || '');
     const [pineconeQAndA, setPineconeQAndA] = useState([]);
     const [pineconeProgress, setPineconeProgress] = useState('');
-    const [postgresqlConnectionString, setPostgresqlConnectionString] = useState('');
+    const [postgresqlConnectionString, setPostgresqlConnectionString] = useState(initialPostgresqlConnection || '');
     const [postgresqlQAndA, setPostgresqlQAndA] = useState([]);
     const [postgresqlProgress, setPostgresqlProgress] = useState('');
     const [evaluationProgress, setEvaluationProgress] = useState(0);
@@ -40,6 +50,67 @@ export const App = ({ backendUrl, dashboardUrl }) => {
             api.setBaseUrl(backendUrl);
         }
     }, [backendUrl]);
+    useEffect(() => {
+        if (step === 'complete' && nonInteractive) {
+            setTimeout(() => {
+                if (evaluationResult && !evaluationResult.error) {
+                    exit();
+                }
+                else {
+                    process.exit(1);
+                }
+            }, 1000);
+        }
+    }, [step, nonInteractive, evaluationResult, exit]);
+    useEffect(() => {
+        if (step === 'testing-connection') {
+            (async () => {
+                try {
+                    const result = customConfig.headers || customConfig.bodyTemplate
+                        ? await api.testAgentConnectionWithConfig(agentEndpoint, customConfig)
+                        : await api.testAgentConnection(agentEndpoint);
+                    setConnectionTestResult(result);
+                    if (result.success) {
+                        setTimeout(() => {
+                            setStep('checking-knowledge');
+                        }, 1500);
+                    }
+                    else {
+                        if (nonInteractive) {
+                            console.error('Connection failed:', result.message);
+                            setTimeout(() => {
+                                setStep('checking-knowledge');
+                            }, 2000);
+                        }
+                        else {
+                            setTimeout(() => {
+                                setStep('connection-failed');
+                            }, 2000);
+                        }
+                    }
+                }
+                catch (error) {
+                    logger.error('Error testing connection:', error);
+                    const message = error instanceof BaseError ? error.userMessage : 'Connection test failed';
+                    setConnectionTestResult({
+                        success: false,
+                        message
+                    });
+                    if (nonInteractive) {
+                        console.error('Connection failed:', message);
+                        setTimeout(() => {
+                            setStep('checking-knowledge');
+                        }, 2000);
+                    }
+                    else {
+                        setTimeout(() => {
+                            setStep('connection-failed');
+                        }, 2000);
+                    }
+                }
+            })();
+        }
+    }, [step, agentEndpoint, customConfig]);
     useEffect(() => {
         if (step === 'checking-knowledge') {
             (async () => {
@@ -48,13 +119,42 @@ export const App = ({ backendUrl, dashboardUrl }) => {
                     setKnowledgeFound(result.found);
                 }
                 catch (error) {
-                    console.error('Error checking knowledge:', error);
+                    logger.error('Error checking knowledge:', error);
                     setKnowledgeFound(false);
                 }
-                setStep('select-source');
+                if (nonInteractive && knowledgeSource) {
+                    if (knowledgeSource === 'pinecone') {
+                        if (pineconeUrl && pineconeApiKey) {
+                            setStep('fetching-pinecone');
+                        }
+                        else {
+                            console.error('Pinecone URL and API key required for Pinecone source');
+                            process.exit(1);
+                        }
+                    }
+                    else if (knowledgeSource === 'postgresql') {
+                        if (postgresqlConnectionString) {
+                            setStep('fetching-postgresql');
+                        }
+                        else {
+                            console.error('PostgreSQL connection string required for PostgreSQL source');
+                            process.exit(1);
+                        }
+                    }
+                    else {
+                        setStep('running-evaluation');
+                    }
+                }
+                else if (nonInteractive && !knowledgeSource) {
+                    setKnowledgeSource('files');
+                    setStep('running-evaluation');
+                }
+                else {
+                    setStep('select-source');
+                }
             })();
         }
-    }, [step]);
+    }, [step, nonInteractive, knowledgeSource, pineconeUrl, pineconeApiKey, postgresqlConnectionString]);
     useEffect(() => {
         if (step === 'fetching-pinecone') {
             (async () => {
@@ -64,14 +164,15 @@ export const App = ({ backendUrl, dashboardUrl }) => {
                     setStep('running-evaluation');
                 }
                 catch (error) {
-                    console.error('Error fetching Q&A from Pinecone:', error);
+                    logger.error('Error fetching Q&A from Pinecone:', error);
+                    const errorMessage = error instanceof BaseError ? error.userMessage : error.message;
                     setEvaluationResult({
                         totalTests: 0,
                         passed: 0,
                         failed: 0,
                         duration: 'Failed',
                         evaluationUrl: dashboardUrl || 'https://eval.rippletide.com',
-                        error: error.message,
+                        error: errorMessage,
                     });
                     setStep('complete');
                 }
@@ -89,7 +190,7 @@ export const App = ({ backendUrl, dashboardUrl }) => {
                     else {
                         const parts = postgresqlConnectionString.split(',');
                         if (parts.length !== 5) {
-                            throw new Error('Invalid connection format. Expected: host,port,database,user,password or postgresql://...');
+                            throw new ValidationError('PostgreSQL connection', postgresqlConnectionString, 'Expected format: host,port,database,user,password or postgresql://...');
                         }
                         config = {
                             host: parts[0].trim(),
@@ -104,14 +205,15 @@ export const App = ({ backendUrl, dashboardUrl }) => {
                     setStep('running-evaluation');
                 }
                 catch (error) {
-                    console.error('Error fetching Q&A from PostgreSQL:', error);
+                    logger.error('Error fetching Q&A from PostgreSQL:', error);
+                    const errorMessage = error instanceof BaseError ? error.userMessage : error.message;
                     setEvaluationResult({
                         totalTests: 0,
                         passed: 0,
                         failed: 0,
                         duration: 'Failed',
                         evaluationUrl: dashboardUrl || 'https://eval.rippletide.com',
-                        error: error.message,
+                        error: errorMessage,
                     });
                     setStep('complete');
                 }
@@ -133,22 +235,48 @@ export const App = ({ backendUrl, dashboardUrl }) => {
                     setEvaluationProgress(40);
                     let testPrompts = [];
                     if (knowledgeSource === 'files') {
-                        const knowledgeResult = await api.checkKnowledge();
-                        if (knowledgeResult.found && knowledgeResult.path) {
+                        if (templatePath) {
                             try {
                                 const fs = await import('fs');
-                                const knowledgeData = JSON.parse(fs.readFileSync(knowledgeResult.path, 'utf-8'));
-                                if (Array.isArray(knowledgeData)) {
-                                    testPrompts = knowledgeData.slice(0, 5).map((item) => ({
-                                        question: item.question || item.prompt || item.input || 'Test question',
-                                        answer: item.answer || item.response || item.expectedAnswer
-                                    }));
+                                const path = await import('path');
+                                const qandaPath = path.join(templatePath, 'qanda.json');
+                                if (fs.existsSync(qandaPath)) {
+                                    const knowledgeData = JSON.parse(fs.readFileSync(qandaPath, 'utf-8'));
+                                    if (Array.isArray(knowledgeData)) {
+                                        testPrompts = knowledgeData.map((item) => ({
+                                            question: item.question || item.prompt || item.input || 'Test question',
+                                            answer: item.answer || item.response || item.expectedAnswer
+                                        }));
+                                    }
+                                }
+                                else {
+                                    logger.debug('No qanda.json found in template directory:', templatePath);
                                 }
                             }
                             catch (error) {
+                                logger.debug('Error loading prompts from template:', error);
                                 testPrompts = [];
                             }
                         }
+                        else {
+                            const knowledgeResult = await api.checkKnowledge();
+                            if (knowledgeResult.found && knowledgeResult.path) {
+                                try {
+                                    const fs = await import('fs');
+                                    const knowledgeData = JSON.parse(fs.readFileSync(knowledgeResult.path, 'utf-8'));
+                                    if (Array.isArray(knowledgeData)) {
+                                        testPrompts = knowledgeData.slice(0, 5).map((item) => ({
+                                            question: item.question || item.prompt || item.input || 'Test question',
+                                            answer: item.answer || item.response || item.expectedAnswer
+                                        }));
+                                    }
+                                }
+                                catch (error) {
+                                    logger.debug('Error loading prompts from knowledge:', error);
+                                    testPrompts = [];
+                                }
+                            }
+                        }
                     }
                     else if (knowledgeSource === 'pinecone' && pineconeQAndA.length > 0) {
                         testPrompts = pineconeQAndA.slice(0, 5).map((item) => ({
@@ -175,7 +303,7 @@ export const App = ({ backendUrl, dashboardUrl }) => {
                             logs.push({ question: question || '', response: llmResponse });
                             setEvaluationLogs([...logs]);
                         }
-                    });
+                    }, customConfig);
                     setEvaluationProgress(100);
                     let passed = 0;
                     let failed = 0;
@@ -203,13 +331,15 @@ export const App = ({ backendUrl, dashboardUrl }) => {
                     setStep('complete');
                 }
                 catch (error) {
-                    console.error('Error running evaluation:', error);
+                    logger.error('Error running evaluation:', error);
+                    const errorMessage = error instanceof BaseError ? error.userMessage : 'Evaluation failed';
                     setEvaluationResult({
                         totalTests: 0,
                         passed: 0,
                         failed: 0,
                         duration: 'Failed',
                         evaluationUrl: dashboardUrl || 'https://eval.rippletide.com',
+                        error: errorMessage,
                     });
                     setStep('complete');
                 }
@@ -217,8 +347,12 @@ export const App = ({ backendUrl, dashboardUrl }) => {
         }
     }, [step, agentEndpoint, knowledgeSource, pineconeQAndA, postgresqlQAndA]);
     const handleAgentEndpointSubmit = (value) => {
-        setAgentEndpoint(value);
-        setStep('checking-knowledge');
+        const trimmedValue = value.trim();
+        if (!trimmedValue) {
+            return;
+        }
+        setAgentEndpoint(trimmedValue);
+        setStep('testing-connection');
     };
     const handleSourceSelect = (value) => {
         setKnowledgeSource(value);
@@ -247,7 +381,143 @@ export const App = ({ backendUrl, dashboardUrl }) => {
     return (React.createElement(Box, { flexDirection: "column", padding: 1 },
         React.createElement(Header, null),
         step === 'agent-endpoint' && (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(TextInput, { label: "Agent endpoint", placeholder: "http://localhost:8000", onSubmit: handleAgentEndpointSubmit }))),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "#eba1b5" }, "Enter your agent's endpoint URL")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { dimColor: true }, "Examples:"),
+                React.createElement(Box, { paddingLeft: 2, flexDirection: "column" },
+                    React.createElement(Text, { dimColor: true }, "- localhost:8000"),
+                    React.createElement(Text, { dimColor: true }, "- http://localhost:8000"),
+                    React.createElement(Text, { dimColor: true }, "- https://my-agent.vercel.app"))),
+            React.createElement(TextInput, { label: "Agent endpoint", placeholder: "localhost:8000", onSubmit: handleAgentEndpointSubmit }))),
+        step === 'testing-connection' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Spinner, { label: "Testing agent connection..." })),
+            connectionTestResult && (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: connectionTestResult.success ? "green" : "red" }, connectionTestResult.message))))),
+        step === 'connection-failed' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "red" }, "Connection failed")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null, connectionTestResult?.message || 'Could not connect to the agent')),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "#eba1b5" }, "What would you like to do?")),
+            React.createElement(SelectMenu, { title: "Options", options: [
+                    { label: 'Try again with same endpoint', value: 'retry', description: 'Test connection again' },
+                    { label: 'Change endpoint URL', value: 'change', description: 'Enter a different endpoint' },
+                    { label: 'Configure custom parameters', value: 'custom', description: 'Add headers, auth, custom body format' },
+                    { label: 'Continue anyway', value: 'continue', description: 'Skip connection test (not recommended)' },
+                ], onSelect: (value) => {
+                    if (value === 'retry') {
+                        setStep('testing-connection');
+                    }
+                    else if (value === 'change') {
+                        setStep('agent-endpoint');
+                    }
+                    else if (value === 'custom') {
+                        setStep('custom-config');
+                    }
+                    else if (value === 'continue') {
+                        setStep('checking-knowledge');
+                    }
+                } }))),
+        step === 'custom-config' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "#eba1b5" }, "Configure custom endpoint parameters")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { dimColor: true }, "Choose what to configure:")),
+            React.createElement(SelectMenu, { title: "Configuration", options: [
+                    { label: 'Add custom headers', value: 'headers', description: 'Authorization, API keys, etc.' },
+                    { label: 'Custom request body', value: 'body', description: 'Define exact request structure' },
+                    { label: 'Custom response field', value: 'response', description: 'Specify where to find the answer' },
+                    { label: 'Test with current config', value: 'test', description: 'Try connection with custom settings' },
+                    { label: 'Back', value: 'back', description: 'Return to previous menu' },
+                ], onSelect: (value) => {
+                    if (value === 'headers') {
+                        setStep('custom-headers');
+                    }
+                    else if (value === 'body') {
+                        setStep('custom-body');
+                    }
+                    else if (value === 'response') {
+                        setStep('custom-response');
+                    }
+                    else if (value === 'test') {
+                        setStep('testing-connection');
+                    }
+                    else if (value === 'back') {
+                        setStep('connection-failed');
+                    }
+                } }),
+            (customConfig.headers || customConfig.bodyTemplate || customConfig.responseField) && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Text, { color: "green" }, "Current configuration:"),
+                customConfig.headers && Object.keys(customConfig.headers).length > 0 && (React.createElement(Text, { dimColor: true },
+                    "- Headers: ",
+                    Object.keys(customConfig.headers).join(', '))),
+                customConfig.bodyTemplate && (React.createElement(Text, { dimColor: true }, "- Custom body template configured")),
+                customConfig.responseField && (React.createElement(Text, { dimColor: true },
+                    "- Response field: ",
+                    customConfig.responseField)))))),
+        step === 'custom-headers' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "#eba1b5" }, "Add custom headers")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { dimColor: true }, "Format: Header-Name: value (one per line, or comma-separated)"),
+                React.createElement(Text, { dimColor: true }, "Examples:"),
+                React.createElement(Box, { paddingLeft: 2, flexDirection: "column" },
+                    React.createElement(Text, { dimColor: true }, "- Authorization: Bearer sk-xxxxx"),
+                    React.createElement(Text, { dimColor: true }, "- X-API-Key: your-api-key"),
+                    React.createElement(Text, { dimColor: true }, "- Content-Type: application/json"))),
+            React.createElement(TextInput, { label: "Headers (press Enter when done)", placeholder: "Authorization: Bearer token, X-API-Key: key", onSubmit: (value) => {
+                    const headers = {};
+                    const headerPairs = value.split(/[,\n]+/);
+                    headerPairs.forEach(pair => {
+                        const [key, ...valueParts] = pair.split(':');
+                        if (key && valueParts.length > 0) {
+                            headers[key.trim()] = valueParts.join(':').trim();
+                        }
+                    });
+                    setCustomConfig(prev => ({ ...prev, headers }));
+                    setStep('custom-config');
+                } }))),
+        step === 'custom-body' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "#eba1b5" }, "Define custom request body")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Use ",
+                    '{question}',
+                    " as placeholder for the user's question"),
+                React.createElement(Text, { dimColor: true }, "Examples:"),
+                React.createElement(Box, { paddingLeft: 2, flexDirection: "column" },
+                    React.createElement(Text, { dimColor: true },
+                        "- ",
+                        '{"prompt": "{question}"}'),
+                    React.createElement(Text, { dimColor: true },
+                        "- ",
+                        '{"messages": [{"role": "user", "content": "{question}"}]}'),
+                    React.createElement(Text, { dimColor: true },
+                        "- ",
+                        '{"input": {"text": "{question}"}}'))),
+            React.createElement(TextInput, { label: "Body template (JSON format)", placeholder: '{"prompt": "{question}"}', onSubmit: (value) => {
+                    setCustomConfig(prev => ({ ...prev, bodyTemplate: value }));
+                    setStep('custom-config');
+                } }))),
+        step === 'custom-response' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "#eba1b5" }, "Specify response field")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { dimColor: true }, "Where to find the answer in the response?"),
+                React.createElement(Text, { dimColor: true }, "Examples:"),
+                React.createElement(Box, { paddingLeft: 2, flexDirection: "column" },
+                    React.createElement(Text, { dimColor: true }, "- answer"),
+                    React.createElement(Text, { dimColor: true }, "- data.response"),
+                    React.createElement(Text, { dimColor: true }, "- choices[0].message.content"),
+                    React.createElement(Text, { dimColor: true }, "- result.text"))),
+            React.createElement(TextInput, { label: "Response field path", placeholder: "answer", onSubmit: (value) => {
+                    setCustomConfig(prev => ({ ...prev, responseField: value }));
+                    setStep('custom-config');
+                } }))),
         step === 'checking-knowledge' && (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Spinner, { label: "Checking for knowledge base in current folder..." }))),
         step === 'select-source' && (React.createElement(Box, { flexDirection: "column" },
@@ -279,7 +549,7 @@ export const App = ({ backendUrl, dashboardUrl }) => {
                 React.createElement(Box, null,
                     React.createElement(Box, { width: 12 },
                         React.createElement(Text, { dimColor: true }, "Endpoint:")),
-                    React.createElement(Text, null, agentEndpoint || 'http://localhost:8000')),
+                    React.createElement(Text, null, agentEndpoint)),
                 React.createElement(Box, null,
                     React.createElement(Box, { width: 12 },
                         React.createElement(Text, { dimColor: true }, "Data Source:")),
@@ -295,6 +565,9 @@ export const App = ({ backendUrl, dashboardUrl }) => {
                     React.createElement(Text, { bold: true, color: "green" }, "LLM Response:")),
                 React.createElement(Box, { paddingLeft: 2 },
                     React.createElement(Text, null, currentLLMResponse.length > 200 ? currentLLMResponse.substring(0, 200) + '...' : currentLLMResponse)))))),
-        step === 'complete' && evaluationResult && (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Summary, { totalTests: evaluationResult.totalTests, passed: evaluationResult.passed, failed: evaluationResult.failed, duration: evaluationResult.duration, evaluationUrl: evaluationResult.evaluationUrl })))));
+        step === 'complete' && evaluationResult && (React.createElement(Box, { flexDirection: "column" }, evaluationResult.error ? (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "red" }, "Error: Evaluation Failed"),
+            React.createElement(Text, null, evaluationResult.error),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Run with --debug flag for more details")))) : (React.createElement(Summary, { totalTests: evaluationResult.totalTests, passed: evaluationResult.passed, failed: evaluationResult.failed, duration: evaluationResult.duration, evaluationUrl: evaluationResult.evaluationUrl }))))));
 };

package/dist/api/client.d.ts

@@ -1,59 +1,28 @@
-export interface EvaluationConfig {
-    agentEndpoint: string;
-    knowledgeSource?: string;
-}
-export interface EvaluationResult {
-    totalTests: number;
-    passed: number;
-    failed: number;
-    duration: string;
-    evaluationUrl: string;
-    agentId?: string;
-}
-export interface HallucinationCheckResult {
-    question: string;
-    llmResponse: string;
-    summary: string;
-    facts: string[];
-    status: 'passed' | 'failed' | 'ambiguous';
-    hallucinationLabel: string;
-    hallucinationFindings: any[];
-}
-export interface PromptEvaluationResult {
-    success: boolean;
-    question: string;
-    llmResponse?: string;
-    hallucinationResult?: HallucinationCheckResult;
-    error?: any;
-}
+import { testAgentConnection, testAgentConnectionWithConfig } from './connection.js';
+import { callLLMEndpoint } from './llm.js';
+import { normalizeEndpoint, generatePayloadVariants, type CustomEndpointConfig } from './endpoint.js';
+import { extractResponseText, extractCustomResponseField } from './response.js';
+import { setBackendUrl, generateApiKey, createAgent, addTestPrompts, checkHallucination, runPromptEvaluation, runAllPromptEvaluations, type HallucinationCheckResult, type PromptEvaluationResult } from './evaluation.js';
+import { healthCheck, checkKnowledge, importKnowledge, getTestResults, runEvaluation, type EvaluationConfig, type EvaluationResult } from './knowledge.js';
+export type { CustomEndpointConfig, HallucinationCheckResult, PromptEvaluationResult, EvaluationConfig, EvaluationResult };
 export declare const api: {
-    setBaseUrl(url: string): void;
-    generateApiKey(name?: string): Promise<any>;
-    healthCheck(): Promise<any>;
-    checkKnowledge(folderPath?: string): Promise<{
-        found: boolean;
-        path: string;
-    } | {
-        found: boolean;
-        path?: undefined;
-    }>;
-    createAgent(publicUrl: string): Promise<any>;
-    importKnowledge(agentId: string, knowledgeData: any): Promise<any>;
-    addTestPrompts(agentId: string, prompts?: string[] | Array<{
-        question: string;
-        answer?: string;
-    }>): Promise<any>;
-    checkHallucination(agentId: string, question: string, llmResponse: string, expectedAnswer?: string): Promise<HallucinationCheckResult>;
-    callLLMEndpoint(agentEndpoint: string, question: string): Promise<string>;
-    runPromptEvaluation(agentId: string, promptId: number, promptText: string, agentEndpoint: string, expectedAnswer?: string, onLLMResponse?: (response: string) => void): Promise<PromptEvaluationResult>;
-    runAllPromptEvaluations(agentId: string, prompts: any[], agentEndpoint: string, onProgress?: (current: number, total: number, question?: string, llmResponse?: string) => void): Promise<PromptEvaluationResult[]>;
-    getTestResults(agentId: string): Promise<any>;
-    runEvaluation(config: EvaluationConfig, onProgress?: (progress: number) => void): Promise<{
-        totalTests: any;
-        passed: number;
-        failed: number;
-        duration: string;
-        evaluationUrl: string;
-        agentId: any;
-    }>;
+    setBaseUrl: typeof setBackendUrl;
+    testAgentConnection: typeof testAgentConnection;
+    testAgentConnectionWithConfig: typeof testAgentConnectionWithConfig;
+    normalizeEndpoint: typeof normalizeEndpoint;
+    generatePayloadVariants: typeof generatePayloadVariants;
+    extractResponseText: typeof extractResponseText;
+    extractCustomResponseField: typeof extractCustomResponseField;
+    callLLMEndpoint: typeof callLLMEndpoint;
+    generateApiKey: typeof generateApiKey;
+    healthCheck: typeof healthCheck;
+    checkKnowledge: typeof checkKnowledge;
+    createAgent: typeof createAgent;
+    importKnowledge: typeof importKnowledge;
+    addTestPrompts: typeof addTestPrompts;
+    checkHallucination: typeof checkHallucination;
+    runPromptEvaluation: typeof runPromptEvaluation;
+    runAllPromptEvaluations: typeof runAllPromptEvaluations;
+    getTestResults: typeof getTestResults;
+    runEvaluation: typeof runEvaluation;
 };