@pauly4010/evalai-sdk 1.3.0 → 1.4.0

package/ADDITIONAL_ISSUES_FOUND.md

@@ -0,0 +1,174 @@
+# Additional Issues Found in Second Review
+
+## 🔴 Issues Discovered
+
+### 1. **process.env Usage in Browser Context** ⚠️ HIGH PRIORITY
+
+**Files**: `client.ts` (lines 105, 116, 178)
+
+**Problem**: The SDK uses `process.env` directly, which is undefined in browsers:
+
+```typescript
+// Line 105
+this.apiKey = config.apiKey || process.env.EVALAI_API_KEY || ...
+
+// Line 116
+const orgIdFromEnv = process.env.EVALAI_ORGANIZATION_ID || ...
+
+// Line 178 (in static init method)
+baseUrl: process.env.EVALAI_BASE_URL,
+```
+
+**Impact**: 
+- Will cause "Cannot read property of undefined" errors in browsers
+- Breaks zero-config initialization in browsers
+- `AIEvalClient.init()` won't work in browsers
+
+**Severity**: HIGH - Core functionality breaks in browsers
+
+---
+
+### 2. **Type Name Collision** 🟡 MEDIUM PRIORITY
+
+**Files**: `types.ts` (line 209) and `testing.ts` (line 27)
+
+**Problem**: Two different `TestCase` interfaces with same name but different purposes:
+
+**types.ts** (Database Model):
+```typescript
+export interface TestCase {
+  id: number;
+  evaluationId: number;
+  input: string;
+  expectedOutput: string | null;
+  metadata: Record<string, any> | null;
+  createdAt: string;
+}
+```
+
+**testing.ts** (Test Suite Model):
+```typescript
+export interface TestCase {
+  id?: string;
+  input: string;
+  expected?: string;
+  metadata?: Record<string, any>;
+  assertions?: ((output: string) => AssertionResult)[];
+}
+```
+
+**Impact**:
+- Confusing for developers
+- IDE autocomplete shows wrong interface
+- Only `types.ts` version is exported from index.ts (line 117)
+- Could cause type errors if both are imported
+
+**Severity**: MEDIUM - Causes confusion but only types.ts version is publicly exported
+
+---
+
+### 3. **Dynamic Import Pattern in export.ts** 🟢 LOW PRIORITY
+
+**Files**: `export.ts` (lines 296, 316)
+
+**Pattern**:
+```typescript
+const fs = await import('fs');
+fs.writeFileSync(filePath, ...);
+```
+
+**Issue**: 
+- Dynamic import returns a module namespace object
+- Works but is unusual pattern (normally use static imports in Node.js-only files)
+- Could fail in some bundler configurations
+
+**Impact**: 
+- Works but non-standard
+- Tree-shaking friendly but unnecessary for Node.js-only code
+- Some bundlers might have issues
+
+**Severity**: LOW - Works but not best practice
+
+---
+
+### 4. **TypeScript Module Configuration** 🟢 INFO
+
+**File**: `tsconfig.json`
+
+**Current**:
+```json
+{
+  "module": "commonjs"
+}
+```
+
+**Observation**: 
+- Using CommonJS but package.json has ES module exports
+- CLI uses `.js` extensions in imports (which is correct for ES modules)
+- Mismatch between TypeScript config and runtime expectations
+
+**Impact**: 
+- May cause issues with module resolution
+- CLI imports might not work as expected
+- Bundlers might be confused
+
+**Severity**: LOW - Currently working but could cause subtle issues
+
+---
+
+## 📊 Summary
+
+| Issue | Severity | Impact | Affected |
+|-------|----------|--------|----------|
+| process.env in browser | 🔴 HIGH | Breaks in browsers | Core client |
+| TestCase collision | 🟡 MEDIUM | Developer confusion | Types |
+| Dynamic imports | 🟢 LOW | Unusual pattern | export.ts |
+| Module config | 🟢 INFO | Potential confusion | Build system |
+
+---
+
+## ✅ Recommended Fixes
+
+### Fix 1: Safe process.env Access
+
+Add helper function:
+```typescript
+// utils.ts or client.ts
+function getEnvVar(name: string): string | undefined {
+  if (typeof process !== 'undefined' && process.env) {
+    return process.env[name];
+  }
+  return undefined;
+}
+```
+
+Then use:
+```typescript
+this.apiKey = config.apiKey || getEnvVar('EVALAI_API_KEY') || ...
+```
+
+### Fix 2: Rename Test Suite TestCase
+
+Rename in `testing.ts`:
+```typescript
+export interface TestSuiteCase {  // Was: TestCase
+  id?: string;
+  input: string;
+  expected?: string;
+  // ...
+}
+```
+
+### Fix 3: Static Imports in export.ts
+
+Since already checked for Node.js environment:
+```typescript
+import * as fs from 'fs';  // Instead of: const fs = await import('fs')
+```
+
+### Fix 4: Consider ES Modules
+
+Either:
+- Change tsconfig to `"module": "es2020"` 
+- Or change package.json exports to use `.cjs` extensions
+

package/README.md

@@ -1,5 +1,8 @@
 # @pauly4010/evalai-sdk
 
+[![npm version](https://img.shields.io/npm/v/@pauly4010/evalai-sdk.svg)](https://www.npmjs.com/package/@pauly4010/evalai-sdk)
+[![npm downloads](https://img.shields.io/npm/dm/@pauly4010/evalai-sdk.svg)](https://www.npmjs.com/package/@pauly4010/evalai-sdk)
+
 Official TypeScript/JavaScript SDK for the AI Evaluation Platform. Build confidence in your AI systems with comprehensive evaluation tools.
 
 ## Installation
@@ -498,9 +501,78 @@ console.log("Plan:", org.plan);
 console.log("Status:", org.status);
 ```
 
+## evalai CLI (v1.4.0)
+
+The SDK includes a CLI for CI/CD evaluation gates. Install globally or use via `npx`:
+
+```bash
+# Via npx (no global install)
+npx @pauly4010/evalai-sdk check --minScore 92 --evaluationId 42 --apiKey $EVALAI_API_KEY
+
+# Or install globally
+npm install -g @pauly4010/evalai-sdk
+evalai check --minScore 92 --evaluationId 42
+```
+
+### evalai check
+
+Gate deployments on quality scores, regression, and compliance:
+
+| Option | Description |
+|--------|-------------|
+| `--evaluationId <id>` | **Required.** Evaluation to gate on |
+| `--apiKey <key>` | API key (or `EVALAI_API_KEY` env) |
+| `--minScore <n>` | Fail if score &lt; n (0–100) |
+| `--maxDrop <n>` | Fail if score dropped &gt; n from baseline |
+| `--minN <n>` | Fail if total test cases &lt; n |
+| `--allowWeakEvidence` | Permit weak evidence level |
+| `--policy <name>` | Enforce HIPAA, SOC2, GDPR, PCI_DSS, FINRA_4511 |
+| `--baseline <mode>` | `published` or `previous` |
+| `--baseUrl <url>` | API base URL |
+
+**Exit codes:** 0=pass, 1=score below, 2=regression, 3=policy violation, 4=API error, 5=bad args, 6=low N, 7=weak evidence
+
 ## Changelog
 
-### v1.2.1 (Latest - Bug Fixes)
+### v1.4.0 (Latest)
+
+- **evalai CLI** — Command-line tool for CI/CD evaluation gates
+  - `evalai check` — Gate deployments on quality scores, regression, and compliance
+  - `--minScore <n>` — Fail if quality score &lt; n (0–100)
+  - `--maxDrop <n>` — Fail if score dropped &gt; n points from baseline
+  - `--minN <n>` — Fail if total test cases &lt; n
+  - `--allowWeakEvidence` — Permit weak evidence level (default: fail)
+  - `--policy <name>` — Enforce compliance (HIPAA, SOC2, GDPR, PCI_DSS, FINRA_4511)
+  - `--baseline <mode>` — Compare to `published` or `previous` run
+  - `--evaluationId <id>` — Required. Evaluation to gate on
+  - Environment: `EVALAI_API_KEY`, `EVALAI_BASE_URL`
+  - Exit codes: 0=pass, 1=score below, 2=regression, 3=policy violation, 4=API error, 5=bad args, 6=low N, 7=weak evidence
+- **CLI Exports** — `parseArgs`, `runCheck`, `EXIT` from `@pauly4010/evalai-sdk` for programmatic use
+
+### v1.3.0
+
+- **Workflow Tracing** — Multi-agent orchestration with full lifecycle instrumentation
+  - `WorkflowTracer` class with `startWorkflow`, `endWorkflow`, `startAgentSpan`, `endAgentSpan`
+  - `createWorkflowTracer` convenience factory
+  - `traceWorkflowStep` generic wrapper for any async function
+  - Agent handoff recording (`delegation`, `escalation`, `parallel`, `fallback`)
+  - Decision auditing with alternatives, confidence scores, reasoning, and context factors
+  - Cost tracking per span/workflow with automatic pricing (16+ models)
+  - Cost breakdown by category (`llm`, `tool`, `embedding`, `other`)
+- **Framework Integrations** — Wrap popular multi-agent frameworks:
+  - `traceLangChainAgent` — wraps `.invoke()` and `.call()` with auto-tracing
+  - `traceCrewAI` — wraps `.kickoff()` with workflow start/end
+  - `traceAutoGen` — wraps `.initiate_chat()` with workflow start/end
+- **Performance Utilities**
+  - `RequestCache` with configurable TTL (`CacheTTL` presets)
+  - `PaginatedIterator` / `createPaginatedIterator` / `autoPaginate` for cursor-based pagination
+  - `RequestBatcher` for batching API calls
+  - `RateLimiter` client-side rate limit handling
+- **Cost Tracking Types** — `CostRecord`, `CostBreakdown`, `ProviderPricing` interfaces
+- **Agent Decision Auditing Types** — `AgentDecision`, `DecisionAlternative`, `RecordDecisionParams` interfaces
+- **Benchmark Types** — `Benchmark`, `BenchmarkResult`, `AgentConfig` interfaces
+
+### v1.2.1 (Bug Fixes)
 
 - 🐛 **Critical Fixes**
   - Fixed CLI import paths for proper npm package distribution
@@ -560,6 +632,5 @@ MIT
 
 ## Support
 
-- Documentation: https://docs.evalai.com
-- Issues: https://github.com/evalai/sdk/issues
-- Discord: https://discord.gg/evalai
+- Documentation: https://v0-ai-evaluation-platform-nu.vercel.app/documentation
+- Issues: https://github.com/pauly7610/ai-evaluation-platform/issues

package/dist/__tests__/assertions.test.d.ts

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

package/dist/__tests__/assertions.test.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const assertions_1 = require("../assertions");
+(0, vitest_1.describe)('Expectation fluent API', () => {
+    (0, vitest_1.describe)('toEqual', () => {
+        (0, vitest_1.it)('should pass when values are equal', () => {
+            const result = (0, assertions_1.expect)('hello').toEqual('hello');
+            (0, vitest_1.expect)(result.passed).toBe(true);
+            (0, vitest_1.expect)(result.name).toBe('toEqual');
+        });
+        (0, vitest_1.it)('should fail when values differ', () => {
+            const result = (0, assertions_1.expect)('hello').toEqual('world');
+            (0, vitest_1.expect)(result.passed).toBe(false);
+        });
+        (0, vitest_1.it)('should handle objects', () => {
+            const result = (0, assertions_1.expect)({ a: 1 }).toEqual({ a: 1 });
+            (0, vitest_1.expect)(result.passed).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)('toContain', () => {
+        (0, vitest_1.it)('should pass when substring is found', () => {
+            const result = (0, assertions_1.expect)('Hello, world!').toContain('world');
+            (0, vitest_1.expect)(result.passed).toBe(true);
+        });
+        (0, vitest_1.it)('should fail when substring is missing', () => {
+            const result = (0, assertions_1.expect)('Hello, world!').toContain('foo');
+            (0, vitest_1.expect)(result.passed).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('toContainKeywords', () => {
+        (0, vitest_1.it)('should pass when all keywords are present (case insensitive)', () => {
+            const result = (0, assertions_1.expect)('The quick Brown fox').toContainKeywords(['quick', 'brown']);
+            (0, vitest_1.expect)(result.passed).toBe(true);
+        });
+        (0, vitest_1.it)('should fail when keywords are missing', () => {
+            const result = (0, assertions_1.expect)('The quick fox').toContainKeywords(['quick', 'brown']);
+            (0, vitest_1.expect)(result.passed).toBe(false);
+            (0, vitest_1.expect)(result.message).toContain('brown');
+        });
+    });
+    (0, vitest_1.describe)('toNotContain', () => {
+        (0, vitest_1.it)('should pass when substring is absent', () => {
+            const result = (0, assertions_1.expect)('safe text').toNotContain('danger');
+            (0, vitest_1.expect)(result.passed).toBe(true);
+        });
+        (0, vitest_1.it)('should fail when substring is present', () => {
+            const result = (0, assertions_1.expect)('some danger ahead').toNotContain('danger');
+            (0, vitest_1.expect)(result.passed).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('toNotContainPII', () => {
+        (0, vitest_1.it)('should pass with no PII', () => {
+            const result = (0, assertions_1.expect)('Just a normal sentence').toNotContainPII();
+            (0, vitest_1.expect)(result.passed).toBe(true);
+        });
+        (0, vitest_1.it)('should fail with an email', () => {
+            const result = (0, assertions_1.expect)('Contact me at user@example.com').toNotContainPII();
+            (0, vitest_1.expect)(result.passed).toBe(false);
+        });
+        (0, vitest_1.it)('should fail with a phone number', () => {
+            const result = (0, assertions_1.expect)('Call 555-123-4567').toNotContainPII();
+            (0, vitest_1.expect)(result.passed).toBe(false);
+        });
+        (0, vitest_1.it)('should fail with an SSN', () => {
+            const result = (0, assertions_1.expect)('SSN is 123-45-6789').toNotContainPII();
+            (0, vitest_1.expect)(result.passed).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('toMatchPattern', () => {
+        (0, vitest_1.it)('should pass when pattern matches', () => {
+            const result = (0, assertions_1.expect)('Order #12345').toMatchPattern(/Order #\d+/);
+            (0, vitest_1.expect)(result.passed).toBe(true);
+        });
+        (0, vitest_1.it)('should fail when pattern does not match', () => {
+            const result = (0, assertions_1.expect)('No order here').toMatchPattern(/Order #\d+/);
+            (0, vitest_1.expect)(result.passed).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('toBeValidJSON', () => {
+        (0, vitest_1.it)('should pass for valid JSON', () => {
+            const result = (0, assertions_1.expect)('{"key": "value"}').toBeValidJSON();
+            (0, vitest_1.expect)(result.passed).toBe(true);
+        });
+        (0, vitest_1.it)('should fail for invalid JSON', () => {
+            const result = (0, assertions_1.expect)('not json').toBeValidJSON();
+            (0, vitest_1.expect)(result.passed).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('toMatchJSON', () => {
+        (0, vitest_1.it)('should pass when all schema keys exist', () => {
+            const result = (0, assertions_1.expect)('{"status":"ok","data":1}').toMatchJSON({ status: '', data: '' });
+            (0, vitest_1.expect)(result.passed).toBe(true);
+        });
+        (0, vitest_1.it)('should fail when schema keys are missing', () => {
+            const result = (0, assertions_1.expect)('{"status":"ok"}').toMatchJSON({ status: '', missing: '' });
+            (0, vitest_1.expect)(result.passed).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('toHaveSentiment', () => {
+        (0, vitest_1.it)('should detect positive sentiment', () => {
+            const result = (0, assertions_1.expect)('This is great and amazing!').toHaveSentiment('positive');
+            (0, vitest_1.expect)(result.passed).toBe(true);
+        });
+        (0, vitest_1.it)('should detect negative sentiment', () => {
+            const result = (0, assertions_1.expect)('This is terrible and awful').toHaveSentiment('negative');
+            (0, vitest_1.expect)(result.passed).toBe(true);
+        });
+        (0, vitest_1.it)('should detect neutral sentiment', () => {
+            const result = (0, assertions_1.expect)('The sky is blue').toHaveSentiment('neutral');
+            (0, vitest_1.expect)(result.passed).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)('toHaveLength', () => {
+        (0, vitest_1.it)('should pass when within range', () => {
+            const result = (0, assertions_1.expect)('hello').toHaveLength({ min: 3, max: 10 });
+            (0, vitest_1.expect)(result.passed).toBe(true);
+        });
+        (0, vitest_1.it)('should fail when too short', () => {
+            const result = (0, assertions_1.expect)('hi').toHaveLength({ min: 5 });
+            (0, vitest_1.expect)(result.passed).toBe(false);
+        });
+        (0, vitest_1.it)('should fail when too long', () => {
+            const result = (0, assertions_1.expect)('a very long string').toHaveLength({ max: 5 });
+            (0, vitest_1.expect)(result.passed).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('toNotHallucinate', () => {
+        (0, vitest_1.it)('should pass when all facts are present', () => {
+            const result = (0, assertions_1.expect)('Paris is the capital of France').toNotHallucinate(['paris', 'france']);
+            (0, vitest_1.expect)(result.passed).toBe(true);
+        });
+        (0, vitest_1.it)('should fail when facts are missing', () => {
+            const result = (0, assertions_1.expect)('Berlin is great').toNotHallucinate(['paris', 'france']);
+            (0, vitest_1.expect)(result.passed).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('toBeFasterThan', () => {
+        (0, vitest_1.it)('should pass when value is under threshold', () => {
+            const result = (0, assertions_1.expect)(500).toBeFasterThan(1000);
+            (0, vitest_1.expect)(result.passed).toBe(true);
+        });
+        (0, vitest_1.it)('should fail when value exceeds threshold', () => {
+            const result = (0, assertions_1.expect)(1500).toBeFasterThan(1000);
+            (0, vitest_1.expect)(result.passed).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('toBeTruthy / toBeFalsy', () => {
+        (0, vitest_1.it)('should pass for truthy values', () => {
+            (0, vitest_1.expect)((0, assertions_1.expect)('hello').toBeTruthy().passed).toBe(true);
+            (0, vitest_1.expect)((0, assertions_1.expect)(1).toBeTruthy().passed).toBe(true);
+        });
+        (0, vitest_1.it)('should pass for falsy values', () => {
+            (0, vitest_1.expect)((0, assertions_1.expect)('').toBeFalsy().passed).toBe(true);
+            (0, vitest_1.expect)((0, assertions_1.expect)(0).toBeFalsy().passed).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)('toBeGreaterThan / toBeLessThan / toBeBetween', () => {
+        (0, vitest_1.it)('should work for greater than', () => {
+            (0, vitest_1.expect)((0, assertions_1.expect)(10).toBeGreaterThan(5).passed).toBe(true);
+            (0, vitest_1.expect)((0, assertions_1.expect)(3).toBeGreaterThan(5).passed).toBe(false);
+        });
+        (0, vitest_1.it)('should work for less than', () => {
+            (0, vitest_1.expect)((0, assertions_1.expect)(3).toBeLessThan(5).passed).toBe(true);
+            (0, vitest_1.expect)((0, assertions_1.expect)(10).toBeLessThan(5).passed).toBe(false);
+        });
+        (0, vitest_1.it)('should work for between', () => {
+            (0, vitest_1.expect)((0, assertions_1.expect)(5).toBeBetween(1, 10).passed).toBe(true);
+            (0, vitest_1.expect)((0, assertions_1.expect)(15).toBeBetween(1, 10).passed).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('toContainCode', () => {
+        (0, vitest_1.it)('should detect code blocks', () => {
+            const result = (0, assertions_1.expect)('Here is code:\n```js\nconsole.log("hi")\n```').toContainCode();
+            (0, vitest_1.expect)(result.passed).toBe(true);
+        });
+        (0, vitest_1.it)('should fail without code blocks', () => {
+            const result = (0, assertions_1.expect)('No code here').toContainCode();
+            (0, vitest_1.expect)(result.passed).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('toBeProfessional', () => {
+        (0, vitest_1.it)('should pass for professional text', () => {
+            const result = (0, assertions_1.expect)('Thank you for your inquiry.').toBeProfessional();
+            (0, vitest_1.expect)(result.passed).toBe(true);
+        });
+        (0, vitest_1.it)('should fail for unprofessional text', () => {
+            const result = (0, assertions_1.expect)('This is damn stupid').toBeProfessional();
+            (0, vitest_1.expect)(result.passed).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('toHaveProperGrammar', () => {
+        (0, vitest_1.it)('should pass for properly formatted text', () => {
+            const result = (0, assertions_1.expect)('This is a sentence.').toHaveProperGrammar();
+            (0, vitest_1.expect)(result.passed).toBe(true);
+        });
+        (0, vitest_1.it)('should fail for double spaces', () => {
+            const result = (0, assertions_1.expect)('This  has double spaces.').toHaveProperGrammar();
+            (0, vitest_1.expect)(result.passed).toBe(false);
+        });
+    });
+});
+(0, vitest_1.describe)('runAssertions', () => {
+    (0, vitest_1.it)('should collect all results', () => {
+        const results = (0, assertions_1.runAssertions)([
+            () => (0, assertions_1.expect)('hello').toContain('hello'),
+            () => (0, assertions_1.expect)('hello').toContain('missing'),
+        ]);
+        (0, vitest_1.expect)(results).toHaveLength(2);
+        (0, vitest_1.expect)(results[0].passed).toBe(true);
+        (0, vitest_1.expect)(results[1].passed).toBe(false);
+    });
+    (0, vitest_1.it)('should catch thrown errors', () => {
+        const results = (0, assertions_1.runAssertions)([
+            () => { throw new Error('boom'); },
+        ]);
+        (0, vitest_1.expect)(results[0].passed).toBe(false);
+        (0, vitest_1.expect)(results[0].message).toBe('boom');
+    });
+});
+(0, vitest_1.describe)('Standalone assertion functions', () => {
+    (0, vitest_1.it)('containsKeywords', () => {
+        (0, vitest_1.expect)((0, assertions_1.containsKeywords)('The quick brown fox', ['quick', 'brown'])).toBe(true);
+        (0, vitest_1.expect)((0, assertions_1.containsKeywords)('The quick fox', ['quick', 'brown'])).toBe(false);
+    });
+    (0, vitest_1.it)('matchesPattern', () => {
+        (0, vitest_1.expect)((0, assertions_1.matchesPattern)('abc123', /\d+/)).toBe(true);
+        (0, vitest_1.expect)((0, assertions_1.matchesPattern)('abc', /\d+/)).toBe(false);
+    });
+    (0, vitest_1.it)('hasLength', () => {
+        (0, vitest_1.expect)((0, assertions_1.hasLength)('hello', { min: 3, max: 10 })).toBe(true);
+        (0, vitest_1.expect)((0, assertions_1.hasLength)('hi', { min: 5 })).toBe(false);
+    });
+    (0, vitest_1.it)('containsJSON', () => {
+        (0, vitest_1.expect)((0, assertions_1.containsJSON)('{"a":1}')).toBe(true);
+        (0, vitest_1.expect)((0, assertions_1.containsJSON)('not json')).toBe(false);
+    });
+    (0, vitest_1.it)('notContainsPII', () => {
+        (0, vitest_1.expect)((0, assertions_1.notContainsPII)('Just a normal text')).toBe(true);
+        (0, vitest_1.expect)((0, assertions_1.notContainsPII)('Email: user@example.com')).toBe(false);
+    });
+    (0, vitest_1.it)('hasSentiment', () => {
+        (0, vitest_1.expect)((0, assertions_1.hasSentiment)('This is great', 'positive')).toBe(true);
+        (0, vitest_1.expect)((0, assertions_1.hasSentiment)('This is terrible', 'negative')).toBe(true);
+    });
+    (0, vitest_1.it)('similarTo', () => {
+        (0, vitest_1.expect)((0, assertions_1.similarTo)('the quick brown fox', 'the quick brown dog', 0.5)).toBe(true);
+        (0, vitest_1.expect)((0, assertions_1.similarTo)('hello world', 'completely different', 0.8)).toBe(false);
+    });
+    (0, vitest_1.it)('withinRange', () => {
+        (0, vitest_1.expect)((0, assertions_1.withinRange)(5, 1, 10)).toBe(true);
+        (0, vitest_1.expect)((0, assertions_1.withinRange)(15, 1, 10)).toBe(false);
+    });
+    (0, vitest_1.it)('isValidEmail', () => {
+        (0, vitest_1.expect)((0, assertions_1.isValidEmail)('user@example.com')).toBe(true);
+        (0, vitest_1.expect)((0, assertions_1.isValidEmail)('not-an-email')).toBe(false);
+    });
+    (0, vitest_1.it)('isValidURL', () => {
+        (0, vitest_1.expect)((0, assertions_1.isValidURL)('https://example.com')).toBe(true);
+        (0, vitest_1.expect)((0, assertions_1.isValidURL)('not a url')).toBe(false);
+    });
+    (0, vitest_1.it)('hasNoHallucinations', () => {
+        (0, vitest_1.expect)((0, assertions_1.hasNoHallucinations)('Paris is in France', ['Paris', 'France'])).toBe(true);
+        (0, vitest_1.expect)((0, assertions_1.hasNoHallucinations)('Berlin is great', ['Paris'])).toBe(false);
+    });
+    (0, vitest_1.it)('matchesSchema', () => {
+        (0, vitest_1.expect)((0, assertions_1.matchesSchema)({ name: 'test', value: 1 }, { name: '', value: '' })).toBe(true);
+        (0, vitest_1.expect)((0, assertions_1.matchesSchema)({ name: 'test' }, { name: '', missing: '' })).toBe(false);
+        (0, vitest_1.expect)((0, assertions_1.matchesSchema)('not an object', { key: '' })).toBe(false);
+    });
+    (0, vitest_1.it)('hasNoToxicity', () => {
+        (0, vitest_1.expect)((0, assertions_1.hasNoToxicity)('Have a nice day')).toBe(true);
+        (0, vitest_1.expect)((0, assertions_1.hasNoToxicity)('You are an idiot')).toBe(false);
+    });
+    (0, vitest_1.it)('followsInstructions', () => {
+        (0, vitest_1.expect)((0, assertions_1.followsInstructions)('Hello world', ['Hello'])).toBe(true);
+        (0, vitest_1.expect)((0, assertions_1.followsInstructions)('Hello world', ['!goodbye'])).toBe(true);
+        (0, vitest_1.expect)((0, assertions_1.followsInstructions)('Hello world', ['missing'])).toBe(false);
+    });
+    (0, vitest_1.it)('containsAllRequiredFields', () => {
+        (0, vitest_1.expect)((0, assertions_1.containsAllRequiredFields)({ a: 1, b: 2 }, ['a', 'b'])).toBe(true);
+        (0, vitest_1.expect)((0, assertions_1.containsAllRequiredFields)({ a: 1 }, ['a', 'b'])).toBe(false);
+    });
+    (0, vitest_1.it)('hasValidCodeSyntax', () => {
+        (0, vitest_1.expect)((0, assertions_1.hasValidCodeSyntax)('{"valid": true}', 'json')).toBe(true);
+        (0, vitest_1.expect)((0, assertions_1.hasValidCodeSyntax)('{invalid}', 'json')).toBe(false);
+    });
+});

package/dist/__tests__/client.test.d.ts

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