@pauly4010/evalai-sdk 1.4.1 → 1.5.5

package/dist/assertions.d.ts

@@ -76,7 +76,7 @@ export declare class Expectation {
      * Assert value has expected sentiment
      * @example expect(output).toHaveSentiment('positive')
      */
-    toHaveSentiment(expected: 'positive' | 'negative' | 'neutral', message?: string): AssertionResult;
+    toHaveSentiment(expected: "positive" | "negative" | "neutral", message?: string): AssertionResult;
     /**
      * Assert string length is within range
      * @example expect(output).toHaveLength({ min: 10, max: 100 })
@@ -172,7 +172,7 @@ export declare function hasLength(text: string, range: {
 }): boolean;
 export declare function containsJSON(text: string): boolean;
 export declare function notContainsPII(text: string): boolean;
-export declare function hasSentiment(text: string, expected: 'positive' | 'negative' | 'neutral'): boolean;
+export declare function hasSentiment(text: string, expected: "positive" | "negative" | "neutral"): boolean;
 export declare function similarTo(text1: string, text2: string, threshold?: number): boolean;
 export declare function withinRange(value: number, min: number, max: number): boolean;
 export declare function isValidEmail(email: string): boolean;

package/dist/assertions.js

@@ -67,7 +67,10 @@ class Expectation {
             passed,
             expected,
             actual: this.value,
-            message: message || (passed ? "Values are equal" : `Expected ${JSON.stringify(expected)}, got ${JSON.stringify(this.value)}`)
+            message: message ||
+                (passed
+                    ? "Values are equal"
+                    : `Expected ${JSON.stringify(expected)}, got ${JSON.stringify(this.value)}`),
         };
     }
     /**
@@ -82,7 +85,8 @@ class Expectation {
             passed,
             expected: substring,
             actual: text,
-            message: message || (passed ? `Text contains "${substring}"` : `Text does not contain "${substring}"`)
+            message: message ||
+                (passed ? `Text contains "${substring}"` : `Text does not contain "${substring}"`),
         };
     }
     /**
@@ -91,14 +95,15 @@ class Expectation {
      */
     toContainKeywords(keywords, message) {
         const text = String(this.value).toLowerCase();
-        const missingKeywords = keywords.filter(k => !text.includes(k.toLowerCase()));
+        const missingKeywords = keywords.filter((k) => !text.includes(k.toLowerCase()));
         const passed = missingKeywords.length === 0;
         return {
             name: "toContainKeywords",
             passed,
             expected: keywords,
             actual: text,
-            message: message || (passed ? `Contains all keywords` : `Missing keywords: ${missingKeywords.join(', ')}`)
+            message: message ||
+                (passed ? `Contains all keywords` : `Missing keywords: ${missingKeywords.join(", ")}`),
         };
     }
     /**
@@ -113,7 +118,8 @@ class Expectation {
             passed,
             expected: `not containing "${substring}"`,
             actual: text,
-            message: message || (passed ? `Text does not contain "${substring}"` : `Text contains "${substring}"`)
+            message: message ||
+                (passed ? `Text does not contain "${substring}"` : `Text contains "${substring}"`),
         };
     }
     /**
@@ -127,18 +133,18 @@ class Expectation {
         const ssnPattern = /\b\d{3}-\d{2}-\d{4}\b/;
         const foundPII = [];
         if (emailPattern.test(text))
-            foundPII.push('email');
+            foundPII.push("email");
         if (phonePattern.test(text))
-            foundPII.push('phone number');
+            foundPII.push("phone number");
         if (ssnPattern.test(text))
-            foundPII.push('SSN');
+            foundPII.push("SSN");
         const passed = foundPII.length === 0;
         return {
             name: "toNotContainPII",
             passed,
             expected: "no PII",
-            actual: foundPII.length > 0 ? `Found: ${foundPII.join(', ')}` : "no PII",
-            message: message || (passed ? "No PII detected" : `PII detected: ${foundPII.join(', ')}`)
+            actual: foundPII.length > 0 ? `Found: ${foundPII.join(", ")}` : "no PII",
+            message: message || (passed ? "No PII detected" : `PII detected: ${foundPII.join(", ")}`),
         };
     }
     /**
@@ -153,7 +159,7 @@ class Expectation {
             passed,
             expected: pattern.toString(),
             actual: text,
-            message: message || (passed ? `Matches pattern ${pattern}` : `Does not match pattern ${pattern}`)
+            message: message || (passed ? `Matches pattern ${pattern}` : `Does not match pattern ${pattern}`),
         };
     }
     /**
@@ -167,7 +173,7 @@ class Expectation {
             parsedJson = JSON.parse(String(this.value));
             passed = true;
         }
-        catch (e) {
+        catch (_e) {
             passed = false;
         }
         return {
@@ -175,7 +181,7 @@ class Expectation {
             passed,
             expected: "valid JSON",
             actual: passed ? parsedJson : this.value,
-            message: message || (passed ? "Valid JSON" : "Invalid JSON")
+            message: message || (passed ? "Valid JSON" : "Invalid JSON"),
         };
     }
     /**
@@ -189,9 +195,9 @@ class Expectation {
             parsedJson = JSON.parse(String(this.value));
             const requiredKeys = Object.keys(schema);
             const actualKeys = Object.keys(parsedJson);
-            passed = requiredKeys.every(key => actualKeys.includes(key));
+            passed = requiredKeys.every((key) => actualKeys.includes(key));
         }
-        catch (e) {
+        catch (_e) {
             passed = false;
         }
         return {
@@ -199,7 +205,7 @@ class Expectation {
             passed,
             expected: schema,
             actual: parsedJson,
-            message: message || (passed ? "JSON matches schema" : "JSON does not match schema")
+            message: message || (passed ? "JSON matches schema" : "JSON does not match schema"),
         };
     }
     /**
@@ -208,24 +214,46 @@ class Expectation {
      */
     toHaveSentiment(expected, message) {
         const text = String(this.value).toLowerCase();
-        const positiveWords = ['good', 'great', 'excellent', 'amazing', 'wonderful', 'fantastic', 'love', 'best', 'happy', 'helpful'];
-        const negativeWords = ['bad', 'terrible', 'awful', 'horrible', 'worst', 'hate', 'poor', 'disappointing', 'sad', 'useless'];
-        const positiveCount = positiveWords.filter(w => text.includes(w)).length;
-        const negativeCount = negativeWords.filter(w => text.includes(w)).length;
+        const positiveWords = [
+            "good",
+            "great",
+            "excellent",
+            "amazing",
+            "wonderful",
+            "fantastic",
+            "love",
+            "best",
+            "happy",
+            "helpful",
+        ];
+        const negativeWords = [
+            "bad",
+            "terrible",
+            "awful",
+            "horrible",
+            "worst",
+            "hate",
+            "poor",
+            "disappointing",
+            "sad",
+            "useless",
+        ];
+        const positiveCount = positiveWords.filter((w) => text.includes(w)).length;
+        const negativeCount = negativeWords.filter((w) => text.includes(w)).length;
         let actual;
         if (positiveCount > negativeCount)
-            actual = 'positive';
+            actual = "positive";
         else if (negativeCount > positiveCount)
-            actual = 'negative';
+            actual = "negative";
         else
-            actual = 'neutral';
+            actual = "neutral";
         const passed = actual === expected;
         return {
             name: "toHaveSentiment",
             passed,
             expected,
             actual,
-            message: message || (passed ? `Sentiment is ${expected}` : `Expected ${expected}, got ${actual}`)
+            message: message || (passed ? `Sentiment is ${expected}` : `Expected ${expected}, got ${actual}`),
         };
     }
     /**
@@ -241,7 +269,7 @@ class Expectation {
             passed,
             expected: range,
             actual: length,
-            message: message || (passed ? `Length ${length} is within range` : `Length ${length} not in range`)
+            message: message || (passed ? `Length ${length} is within range` : `Length ${length} not in range`),
         };
     }
     /**
@@ -250,14 +278,15 @@ class Expectation {
      */
     toNotHallucinate(groundTruth, message) {
         const text = String(this.value).toLowerCase();
-        const missingFacts = groundTruth.filter(fact => !text.includes(fact.toLowerCase()));
+        const missingFacts = groundTruth.filter((fact) => !text.includes(fact.toLowerCase()));
         const passed = missingFacts.length === 0;
         return {
             name: "toNotHallucinate",
             passed,
             expected: "all ground truth facts",
-            actual: missingFacts.length > 0 ? `Missing: ${missingFacts.join(', ')}` : "all facts present",
-            message: message || (passed ? "No hallucinations detected" : `Missing facts: ${missingFacts.join(', ')}`)
+            actual: missingFacts.length > 0 ? `Missing: ${missingFacts.join(", ")}` : "all facts present",
+            message: message ||
+                (passed ? "No hallucinations detected" : `Missing facts: ${missingFacts.join(", ")}`),
         };
     }
     /**
@@ -272,7 +301,7 @@ class Expectation {
             passed,
             expected: `<= ${maxMs}ms`,
             actual: `${duration}ms`,
-            message: message || (passed ? `${duration}ms within limit` : `${duration}ms exceeds ${maxMs}ms`)
+            message: message || (passed ? `${duration}ms within limit` : `${duration}ms exceeds ${maxMs}ms`),
         };
     }
     /**
@@ -286,7 +315,7 @@ class Expectation {
             passed,
             expected: "truthy value",
             actual: this.value,
-            message: message || (passed ? "Value is truthy" : "Value is falsy")
+            message: message || (passed ? "Value is truthy" : "Value is falsy"),
         };
     }
     /**
@@ -294,13 +323,13 @@ class Expectation {
      * @example expect(error).toBeFalsy()
      */
     toBeFalsy(message) {
-        const passed = !Boolean(this.value);
+        const passed = !this.value;
         return {
             name: "toBeFalsy",
             passed,
             expected: "falsy value",
             actual: this.value,
-            message: message || (passed ? "Value is falsy" : "Value is truthy")
+            message: message || (passed ? "Value is falsy" : "Value is truthy"),
         };
     }
     /**
@@ -315,7 +344,7 @@ class Expectation {
             passed,
             expected: `> ${expected}`,
             actual: value,
-            message: message || (passed ? `${value} > ${expected}` : `${value} <= ${expected}`)
+            message: message || (passed ? `${value} > ${expected}` : `${value} <= ${expected}`),
         };
     }
     /**
@@ -330,7 +359,7 @@ class Expectation {
             passed,
             expected: `< ${expected}`,
             actual: value,
-            message: message || (passed ? `${value} < ${expected}` : `${value} >= ${expected}`)
+            message: message || (passed ? `${value} < ${expected}` : `${value} >= ${expected}`),
         };
     }
     /**
@@ -345,7 +374,7 @@ class Expectation {
             passed,
             expected: `between ${min} and ${max}`,
             actual: value,
-            message: message || (passed ? `${value} is within range` : `${value} is outside range`)
+            message: message || (passed ? `${value} is within range` : `${value} is outside range`),
         };
     }
     /**
@@ -360,7 +389,7 @@ class Expectation {
             passed: hasCodeBlock,
             expected: "code block",
             actual: text,
-            message: message || (hasCodeBlock ? "Contains code block" : "No code block found")
+            message: message || (hasCodeBlock ? "Contains code block" : "No code block found"),
         };
     }
     /**
@@ -369,15 +398,16 @@ class Expectation {
      */
     toBeProfessional(message) {
         const text = String(this.value).toLowerCase();
-        const profanity = ['damn', 'hell', 'shit', 'fuck', 'ass', 'bitch', 'crap'];
-        const foundProfanity = profanity.filter(word => text.includes(word));
+        const profanity = ["damn", "hell", "shit", "fuck", "ass", "bitch", "crap"];
+        const foundProfanity = profanity.filter((word) => text.includes(word));
         const passed = foundProfanity.length === 0;
         return {
             name: "toBeProfessional",
             passed,
             expected: "professional tone",
-            actual: foundProfanity.length > 0 ? `Found: ${foundProfanity.join(', ')}` : "professional",
-            message: message || (passed ? "Professional tone" : `Unprofessional language: ${foundProfanity.join(', ')}`)
+            actual: foundProfanity.length > 0 ? `Found: ${foundProfanity.join(", ")}` : "professional",
+            message: message ||
+                (passed ? "Professional tone" : `Unprofessional language: ${foundProfanity.join(", ")}`),
         };
     }
     /**
@@ -388,21 +418,21 @@ class Expectation {
         const text = String(this.value);
         const issues = [];
         // Check for double spaces
-        if (/  +/.test(text))
-            issues.push('double spaces');
+        if (/ {2,}/.test(text))
+            issues.push("double spaces");
         // Check for missing periods at end
         if (text.length > 10 && !/[.!?]$/.test(text.trim()))
-            issues.push('missing ending punctuation');
+            issues.push("missing ending punctuation");
         // Check for lowercase sentence starts
         if (/\.\s+[a-z]/.test(text))
-            issues.push('lowercase after period');
+            issues.push("lowercase after period");
         const passed = issues.length === 0;
         return {
             name: "toHaveProperGrammar",
             passed,
             expected: "proper grammar",
-            actual: issues.length > 0 ? `Issues: ${issues.join(', ')}` : "proper grammar",
-            message: message || (passed ? "Proper grammar" : `Grammar issues: ${issues.join(', ')}`)
+            actual: issues.length > 0 ? `Issues: ${issues.join(", ")}` : "proper grammar",
+            message: message || (passed ? "Proper grammar" : `Grammar issues: ${issues.join(", ")}`),
         };
     }
 }
@@ -447,14 +477,14 @@ function runAssertions(assertions) {
                 passed: false,
                 expected: null,
                 actual: null,
-                message: error instanceof Error ? error.message : "Unknown error"
+                message: error instanceof Error ? error.message : "Unknown error",
             };
         }
     });
 }
 // Standalone assertion functions
 function containsKeywords(text, keywords) {
-    return keywords.every(keyword => text.toLowerCase().includes(keyword.toLowerCase()));
+    return keywords.every((keyword) => text.toLowerCase().includes(keyword.toLowerCase()));
 }
 function matchesPattern(text, pattern) {
     return pattern.test(text);
@@ -485,18 +515,18 @@ function notContainsPII(text) {
         /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/, // Email
         /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/, // IP address
     ];
-    return !piiPatterns.some(pattern => pattern.test(text));
+    return !piiPatterns.some((pattern) => pattern.test(text));
 }
 function hasSentiment(text, expected) {
     // This is a simplified implementation
-    const positiveWords = ['good', 'great', 'excellent', 'awesome'];
-    const negativeWords = ['bad', 'terrible', 'awful', 'poor'];
+    const positiveWords = ["good", "great", "excellent", "awesome"];
+    const negativeWords = ["bad", "terrible", "awful", "poor"];
     const words = text.toLowerCase().split(/\s+/);
-    const positiveCount = words.filter(word => positiveWords.includes(word)).length;
-    const negativeCount = words.filter(word => negativeWords.includes(word)).length;
-    if (expected === 'positive')
+    const positiveCount = words.filter((word) => positiveWords.includes(word)).length;
+    const negativeCount = words.filter((word) => negativeWords.includes(word)).length;
+    if (expected === "positive")
         return positiveCount > negativeCount;
-    if (expected === 'negative')
+    if (expected === "negative")
         return negativeCount > positiveCount;
     return positiveCount === negativeCount; // neutral
 }
@@ -504,7 +534,7 @@ function similarTo(text1, text2, threshold = 0.8) {
     // Simple similarity check - in a real app, you'd use a proper string similarity algorithm
     const words1 = new Set(text1.toLowerCase().split(/\s+/));
     const words2 = new Set(text2.toLowerCase().split(/\s+/));
-    const intersection = new Set([...words1].filter(word => words2.has(word)));
+    const intersection = new Set([...words1].filter((word) => words2.has(word)));
     const union = new Set([...words1, ...words2]);
     return intersection.size / union.size >= threshold;
 }
@@ -525,13 +555,13 @@ function isValidURL(url) {
 }
 function hasNoHallucinations(text, groundTruth) {
     // This is a simplified implementation
-    return groundTruth.every(truth => text.includes(truth));
+    return groundTruth.every((truth) => text.includes(truth));
 }
 function matchesSchema(value, schema) {
     // This is a simplified implementation
-    if (typeof value !== 'object' || value === null)
+    if (typeof value !== "object" || value === null)
         return false;
-    return Object.keys(schema).every(key => key in value);
+    return Object.keys(schema).every((key) => key in value);
 }
 function hasReadabilityScore(text, minScore) {
     // This is a simplified implementation
@@ -545,47 +575,50 @@ function syllables(word) {
     word = word.toLowerCase();
     if (word.length <= 3)
         return 1;
-    return word.replace(/[^aeiouy]+/g, ' ').trim().split(/\s+/).length;
+    return word
+        .replace(/[^aeiouy]+/g, " ")
+        .trim()
+        .split(/\s+/).length;
 }
 function containsLanguage(text, language) {
     // This is a simplified implementation
     // In a real app, you'd use a language detection library
     const languageKeywords = {
-        'en': ['the', 'and', 'you', 'that', 'was', 'for', 'are', 'with'],
-        'es': ['el', 'la', 'los', 'las', 'de', 'que', 'y', 'en'],
-        'fr': ['le', 'la', 'les', 'de', 'et', 'à', 'un', 'une'],
+        en: ["the", "and", "you", "that", "was", "for", "are", "with"],
+        es: ["el", "la", "los", "las", "de", "que", "y", "en"],
+        fr: ["le", "la", "les", "de", "et", "à", "un", "une"],
     };
     const keywords = languageKeywords[language.toLowerCase()] || [];
-    return keywords.some(keyword => text.toLowerCase().includes(keyword));
+    return keywords.some((keyword) => text.toLowerCase().includes(keyword));
 }
 function hasFactualAccuracy(text, facts) {
     // This is a simplified implementation
-    return facts.every(fact => text.includes(fact));
+    return facts.every((fact) => text.includes(fact));
 }
 function respondedWithinTime(startTime, maxMs) {
     return Date.now() - startTime <= maxMs;
 }
 function hasNoToxicity(text) {
     // This is a simplified implementation
-    const toxicWords = ['hate', 'stupid', 'idiot', 'dumb'];
-    return !toxicWords.some(word => text.toLowerCase().includes(word));
+    const toxicWords = ["hate", "stupid", "idiot", "dumb"];
+    return !toxicWords.some((word) => text.toLowerCase().includes(word));
 }
 function followsInstructions(text, instructions) {
-    return instructions.every(instruction => {
-        if (instruction.startsWith('!')) {
+    return instructions.every((instruction) => {
+        if (instruction.startsWith("!")) {
             return !text.includes(instruction.slice(1));
         }
         return text.includes(instruction);
     });
 }
 function containsAllRequiredFields(obj, requiredFields) {
-    return requiredFields.every(field => field in obj);
+    return requiredFields.every((field) => field in obj);
 }
 function hasValidCodeSyntax(code, language) {
     // This is a simplified implementation
     // In a real app, you'd use a proper parser for each language
     try {
-        if (language === 'json')
+        if (language === "json")
             JSON.parse(code);
         // Add more language validations as needed
         return true;

package/dist/batch.js

@@ -57,7 +57,7 @@ class RequestBatcher {
      */
     async processBatch() {
         if (this.batchTimer) {
-            if (typeof this.batchTimer === 'number') {
+            if (typeof this.batchTimer === "number") {
                 clearTimeout(this.batchTimer);
             }
             else {
@@ -70,12 +70,12 @@ class RequestBatcher {
         }
         // Take items from queue
         const batch = this.queue.splice(0, this.maxBatchSize);
-        const requests = batch.map(item => item.request);
+        const requests = batch.map((item) => item.request);
         try {
             const responses = await this.executeBatch(requests);
             // Match responses to requests and resolve/reject
             for (const response of responses) {
-                const pendingRequest = batch.find(item => item.id === response.id);
+                const pendingRequest = batch.find((item) => item.id === response.id);
                 if (pendingRequest) {
                     if (response.status >= 200 && response.status < 300) {
                         pendingRequest.resolve(response.data);
@@ -87,8 +87,8 @@ class RequestBatcher {
             }
             // Handle any requests that didn't get a response
             for (const item of batch) {
-                if (!responses.find(r => r.id === item.id)) {
-                    item.reject(new Error('No response received for request'));
+                if (!responses.find((r) => r.id === item.id)) {
+                    item.reject(new Error("No response received for request"));
                 }
             }
         }
@@ -116,7 +116,7 @@ class RequestBatcher {
      */
     clear() {
         if (this.batchTimer) {
-            if (typeof this.batchTimer === 'number') {
+            if (typeof this.batchTimer === "number") {
                 clearTimeout(this.batchTimer);
             }
             else {
@@ -126,7 +126,7 @@ class RequestBatcher {
         }
         // Reject all pending requests
         for (const item of this.queue) {
-            item.reject(new Error('Batch queue cleared'));
+            item.reject(new Error("Batch queue cleared"));
         }
         this.queue = [];
     }
@@ -146,16 +146,11 @@ exports.RequestBatcher = RequestBatcher;
  * Check if requests can be batched together
  */
 function canBatch(method, endpoint) {
-    if (method !== 'GET') {
+    if (method !== "GET") {
         return false;
     }
-    const batchableEndpoints = [
-        '/traces',
-        '/evaluations',
-        '/annotations',
-        '/results',
-    ];
-    return batchableEndpoints.some(pattern => endpoint.includes(pattern));
+    const batchableEndpoints = ["/traces", "/evaluations", "/annotations", "/results"];
+    return batchableEndpoints.some((pattern) => endpoint.includes(pattern));
 }
 /**
  * Batch multiple async operations with concurrency limit
@@ -164,13 +159,13 @@ async function batchProcess(items, processor, concurrency = 5) {
     const results = [];
     const executing = [];
     for (const item of items) {
-        const promise = processor(item).then(result => {
+        const promise = processor(item).then((result) => {
             results.push(result);
         });
         executing.push(promise);
         if (executing.length >= concurrency) {
             await Promise.race(executing);
-            executing.splice(executing.findIndex(p => p === promise), 1);
+            executing.splice(executing.indexOf(promise), 1);
         }
     }
     await Promise.all(executing);

package/dist/cache.js

@@ -16,7 +16,7 @@ class RequestCache {
      * Generate cache key from request parameters
      */
     generateKey(method, url, params) {
-        const paramString = params ? JSON.stringify(params) : '';
+        const paramString = params ? JSON.stringify(params) : "";
         return `${method}:${url}:${paramString}`;
     }
     /**
@@ -107,28 +107,24 @@ exports.CacheTTL = {
  * Determine if a request should be cached based on method and endpoint
  */
 function shouldCache(method, endpoint) {
-    if (method !== 'GET') {
+    if (method !== "GET") {
         return false;
     }
-    const noCacheEndpoints = [
-        '/health',
-        '/usage',
-        '/deliveries',
-    ];
-    return !noCacheEndpoints.some(pattern => endpoint.includes(pattern));
+    const noCacheEndpoints = ["/health", "/usage", "/deliveries"];
+    return !noCacheEndpoints.some((pattern) => endpoint.includes(pattern));
 }
 /**
  * @internal - Internal SDK logic, not part of public API
  * Get appropriate TTL for an endpoint
  */
 function getTTL(endpoint) {
-    if (endpoint.includes('/api-keys') || endpoint.includes('/webhooks')) {
+    if (endpoint.includes("/api-keys") || endpoint.includes("/webhooks")) {
         return exports.CacheTTL.LONG;
     }
-    if (endpoint.includes('/evaluations') || endpoint.includes('/configs')) {
+    if (endpoint.includes("/evaluations") || endpoint.includes("/configs")) {
         return exports.CacheTTL.MEDIUM;
     }
-    if (endpoint.includes('/traces') || endpoint.includes('/results')) {
+    if (endpoint.includes("/traces") || endpoint.includes("/results")) {
         return exports.CacheTTL.SHORT;
     }
     return exports.CacheTTL.MEDIUM;