@pauly4010/evalai-sdk 1.5.7 → 1.5.8

package/CHANGELOG.md

@@ -5,6 +5,23 @@ All notable changes to the @pauly4010/evalai-sdk package will be documented in t
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.5.8] - 2026-02-22
+
+### 🐛 Fixed
+
+- **secureRoute TypeScript overload compatibility** — Fixed implementation signature to use `ctx: any` for proper overload compatibility
+- **Test infrastructure fixes** — Replaced invalid `expect.unknown()` with `expect.any()` across test files
+- **NextRequest constructor** — Fixed test mocks using incorrect `(NextRequest as any)()` syntax
+- **304 response handling** — Fixed exports API returning invalid 304 response with body
+- **Error catalog tests** — Updated test expectations to match actual EvalAIError behavior
+- **Redis cache timeout** — Added explicit timeout to prevent test hangs
+
+### 🔧 Changed
+
+- **Biome formatting** — Applied consistent line endings across 199 files
+
+---
+
 ## [1.5.7] - 2026-02-20
 
 ### 📚 Documentation
@@ -32,7 +49,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **`--warnDrop <n>`** — Introduce a WARN band when score drops > `warnDrop` but < `maxDrop`
 - **Gate verdicts:** PASS, WARN, FAIL
 - **Profiles:** `strict` (warnDrop: 0), `balanced` (warnDrop: 1), `fast` (warnDrop: 2)
-- **`--fail-on-flake`** — Fail the gate if any case is flagged as flaky (partial pass rate across determinism runs)
+- **`--fail-on-flake`** — Fail the gate if unknown case is flagged as flaky (partial pass rate across determinism runs)
 
 #### Determinism & flake intelligence
 

package/README.md

@@ -99,7 +99,7 @@ Key flags
 
 --maxDrop → hard regression fail
 
---fail-on-flake → fail if any test is unstable
+--fail-on-flake → fail if unknown test is unstable
 
 This lets teams tune signal vs noise in CI.
 
@@ -190,7 +190,7 @@ Option	Description
 --allowWeakEvidence	Permit weak evidence
 --policy <name>	HIPAA, SOC2, GDPR, PCI_DSS, FINRA_4511
 --baseline <mode>	published, previous, production
---fail-on-flake	Fail if any case is flaky
+--fail-on-flake	Fail if unknown case is flaky
 --baseUrl <url>	Override API base URL
 
 Exit codes
@@ -257,7 +257,16 @@ await openai.chat.completions.create({
 
 
 🧭 Changelog
-v1.5.7 (Latest)
+v1.5.8 (Latest)
+Fixed secureRoute TypeScript overload compatibility
+
+Fixed test infrastructure (expect.any, NextRequest constructor)
+
+Fixed 304 response handling in exports API
+
+Improved error catalog test coverage
+
+v1.5.7
 Documentation updates for CJS compatibility
 
 Version alignment across README and changelog

package/dist/assertions.d.ts

@@ -17,26 +17,26 @@
 export interface AssertionResult {
     name: string;
     passed: boolean;
-    expected: any;
-    actual: any;
+    expected: unknown;
+    actual: unknown;
     message?: string;
 }
 export declare class AssertionError extends Error {
-    expected: any;
-    actual: any;
-    constructor(message: string, expected: any, actual: any);
+    expected: unknown;
+    actual: unknown;
+    constructor(message: string, expected: unknown, actual: unknown);
 }
 /**
  * Fluent assertion builder
  */
 export declare class Expectation {
     private value;
-    constructor(value: any);
+    constructor(value: unknown);
     /**
      * Assert value equals expected
      * @example expect(output).toEqual("Hello")
      */
-    toEqual(expected: any, message?: string): AssertionResult;
+    toEqual(expected: unknown, message?: string): AssertionResult;
     /**
      * Assert value contains substring
      * @example expect(output).toContain("help")
@@ -71,7 +71,7 @@ export declare class Expectation {
      * Assert JSON matches schema
      * @example expect(output).toMatchJSON({ status: 'success' })
      */
-    toMatchJSON(schema: Record<string, any>, message?: string): AssertionResult;
+    toMatchJSON(schema: Record<string, unknown>, message?: string): AssertionResult;
     /**
      * Assert value has expected sentiment
      * @example expect(output).toHaveSentiment('positive')
@@ -148,7 +148,7 @@ export declare class Expectation {
  * expect(output).toHaveLength({ min: 10, max: 100 });
  * ```
  */
-export declare function expect(value: any): Expectation;
+export declare function expect(value: unknown): Expectation;
 /**
  * Run multiple assertions and collect results
  *
@@ -178,12 +178,12 @@ export declare function withinRange(value: number, min: number, max: number): bo
 export declare function isValidEmail(email: string): boolean;
 export declare function isValidURL(url: string): boolean;
 export declare function hasNoHallucinations(text: string, groundTruth: string[]): boolean;
-export declare function matchesSchema(value: any, schema: Record<string, any>): boolean;
+export declare function matchesSchema(value: unknown, schema: Record<string, unknown>): boolean;
 export declare function hasReadabilityScore(text: string, minScore: number): boolean;
 export declare function containsLanguage(text: string, language: string): boolean;
 export declare function hasFactualAccuracy(text: string, facts: string[]): boolean;
 export declare function respondedWithinTime(startTime: number, maxMs: number): boolean;
 export declare function hasNoToxicity(text: string): boolean;
 export declare function followsInstructions(text: string, instructions: string[]): boolean;
-export declare function containsAllRequiredFields(obj: any, requiredFields: string[]): boolean;
+export declare function containsAllRequiredFields(obj: unknown, requiredFields: string[]): boolean;
 export declare function hasValidCodeSyntax(code: string, language: string): boolean;

package/dist/assertions.js

@@ -612,7 +612,7 @@ function followsInstructions(text, instructions) {
     });
 }
 function containsAllRequiredFields(obj, requiredFields) {
-    return requiredFields.every((field) => field in obj);
+    return requiredFields.every((field) => obj && typeof obj === "object" && field in obj);
 }
 function hasValidCodeSyntax(code, language) {
     // This is a simplified implementation

package/dist/batch.d.ts

@@ -6,13 +6,13 @@ export interface BatchRequest {
     id: string;
     method: string;
     endpoint: string;
-    body?: any;
+    body?: unknown;
     headers?: Record<string, string>;
 }
 export interface BatchResponse {
     id: string;
     status: number;
-    data?: any;
+    data?: unknown;
     error?: string;
 }
 /**
@@ -32,7 +32,7 @@ export declare class RequestBatcher {
     /**
      * Add request to batch queue
      */
-    enqueue(method: string, endpoint: string, body?: any, headers?: Record<string, string>): Promise<any>;
+    enqueue(method: string, endpoint: string, body?: unknown, headers?: Record<string, string>): Promise<unknown>;
     /**
      * Schedule batch processing after delay
      */

package/dist/batch.js

@@ -85,7 +85,7 @@ class RequestBatcher {
                     }
                 }
             }
-            // Handle any requests that didn't get a response
+            // Handle unknown 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"));

package/dist/cache.d.ts

@@ -17,15 +17,15 @@ export declare class RequestCache {
     /**
      * Get cached response if valid
      */
-    get<T>(method: string, url: string, params?: any): T | null;
+    get<T>(method: string, url: string, params?: unknown): T | null;
     /**
      * Store response in cache
      */
-    set<T>(method: string, url: string, data: T, ttl: number, params?: any): void;
+    set<T>(method: string, url: string, data: T, ttl: number, params?: unknown): void;
     /**
      * Invalidate specific cache entry
      */
-    invalidate(method: string, url: string, params?: any): void;
+    invalidate(method: string, url: string, params?: unknown): void;
     /**
      * Invalidate all cache entries matching a pattern
      */

package/dist/cache.js

@@ -69,7 +69,7 @@ class RequestCache {
      * Invalidate all cache entries matching a pattern
      */
     invalidatePattern(pattern) {
-        for (const key of this.cache.keys()) {
+        for (const key of Array.from(this.cache.keys())) {
             if (key.includes(pattern)) {
                 this.cache.delete(key);
             }

package/dist/cli/formatters/github.js

@@ -81,7 +81,7 @@ function appendStepSummary(report) {
             const exp = (0, snippet_1.truncateSnippet)(fc.expectedOutput ?? fc.expectedSnippet, 80);
             const out = (0, snippet_1.truncateSnippet)(fc.output ?? fc.outputSnippet, 80);
             const reason = out ? `got "${out}"` : "no output";
-            lines.push(`- **${(0, snippet_1.truncateSnippet)(label, 60)}** — expected: ${exp || "(any)"}, ${reason}`);
+            lines.push(`- **${(0, snippet_1.truncateSnippet)(label, 60)}** — expected: ${exp || "(unknown)"}, ${reason}`);
         }
         if (failedCases.length > 10) {
             lines.push(`- _+ ${failedCases.length - 10} more_`);

package/dist/cli/formatters/human.js

@@ -30,7 +30,7 @@ function formatHuman(report) {
             const exp = (0, snippet_1.truncateSnippet)(fc.expectedOutput ?? fc.expectedSnippet, 50);
             const out = (0, snippet_1.truncateSnippet)(fc.output ?? fc.outputSnippet, 50);
             const reason = out ? `got "${out}"` : "no output";
-            lines.push(`  - "${(0, snippet_1.truncateSnippet)(label, 50)}" → expected: ${exp || "(any)"}, ${reason}`);
+            lines.push(`  - "${(0, snippet_1.truncateSnippet)(label, 50)}" → expected: ${exp || "(unknown)"}, ${reason}`);
         }
         if (failedCases.length > toShow.length) {
             lines.push(`  + ${failedCases.length - toShow.length} more`);

package/dist/cli/formatters/pr-comment.js

@@ -49,7 +49,7 @@ function buildPrComment(report) {
         lines.push(`_${escapeMarkdown(report.reasonMessage)}_`);
     }
     lines.push("");
-    // Policy (if any)
+    // Policy (if unknown)
     if (report.policy) {
         lines.push(`**Policy:** ${report.policy}`);
         lines.push("");

package/dist/client.d.ts

@@ -111,7 +111,7 @@ declare class TraceAPI {
      * });
      * ```
      */
-    create<TMetadata = Record<string, any>>(params: CreateTraceParams<TMetadata>): Promise<Trace<TMetadata>>;
+    create<TMetadata = Record<string, unknown>>(params: CreateTraceParams<TMetadata>): Promise<Trace<TMetadata>>;
     /**
      * List traces with optional filtering
      */
@@ -138,7 +138,7 @@ declare class TraceAPI {
      * });
      * ```
      */
-    update<TMetadata = Record<string, any>>(id: number, params: UpdateTraceParams<TMetadata>): Promise<Trace<TMetadata>>;
+    update<TMetadata = Record<string, unknown>>(id: number, params: UpdateTraceParams<TMetadata>): Promise<Trace<TMetadata>>;
     /**
      * Create a span for a trace
      */
@@ -208,7 +208,7 @@ declare class LLMJudgeAPI {
      */
     evaluate(params: RunLLMJudgeParams): Promise<{
         result: LLMJudgeResult;
-        config: any;
+        config: unknown;
     }>;
     /**
      * Create an LLM judge configuration

package/dist/client.js

@@ -94,11 +94,12 @@ class AIEvalClient {
                             results.push({ id: req.id, status: 200, data });
                         }
                         catch (err) {
+                            const errorObj = err;
                             results.push({
                                 id: req.id,
-                                status: err?.statusCode || 500,
+                                status: errorObj?.statusCode || 500,
                                 data: null,
-                                error: err?.message || "Unknown error",
+                                error: errorObj?.message || "Unknown error",
                             });
                         }
                     })();

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

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

package/dist/client.request.test.js

@@ -0,0 +1,157 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const client_1 = require("./client");
+const errorsModule = __importStar(require("./errors"));
+vitest_1.vi.mock("./cache", () => {
+    const cacheTracker = { invalidatedPatterns: [] };
+    const shouldCache = vitest_1.vi.fn().mockReturnValue(true);
+    const getTTL = vitest_1.vi.fn().mockReturnValue(1000);
+    const makeKey = (method, url, params) => `${method}:${url}:${JSON.stringify(params ?? null)}`;
+    return {
+        __esModule: true,
+        shouldCache,
+        getTTL,
+        cacheTracker,
+        RequestCache: class RequestCache {
+            constructor() {
+                this.store = new Map();
+            }
+            get(method, url, params) {
+                const key = makeKey(method, url, params);
+                return this.store.get(key) ?? null;
+            }
+            set(method, url, data, _ttl, params) {
+                const key = makeKey(method, url, params);
+                this.store.set(key, data);
+            }
+            invalidatePattern(pattern) {
+                cacheTracker.invalidatedPatterns.push(pattern);
+            }
+            invalidate(_method, _url, _params) {
+                // no-op for tests
+            }
+            clear() {
+                this.store.clear();
+            }
+        },
+    };
+});
+const cache_1 = require("./cache");
+(0, vitest_1.describe)("AIEvalClient.request", () => {
+    (0, vitest_1.beforeEach)(() => {
+        process.env.EVALAI_API_KEY = "test";
+        cache_1.shouldCache.mockReset().mockReturnValue(true);
+        cache_1.getTTL.mockReset().mockReturnValue(1000);
+        cache_1.cacheTracker.invalidatedPatterns.length = 0;
+    });
+    (0, vitest_1.it)("caches GET responses and reuses data without re-fetching", async () => {
+        const client = new client_1.AIEvalClient({ apiKey: "test", baseUrl: "http://localhost", timeout: 1000 });
+        const payload = { items: [1, 2, 3] };
+        const fetchMock = vitest_1.vi.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: async () => payload,
+        });
+        globalThis.fetch = fetchMock;
+        const first = await client.request("/api/traces", { method: "GET" });
+        const second = await client.request("/api/traces", { method: "GET" });
+        (0, vitest_1.expect)(first).toEqual(payload);
+        (0, vitest_1.expect)(second).toEqual(payload);
+        (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(1);
+    });
+    (0, vitest_1.it)("propagates non-ok responses as SDK errors", async () => {
+        const client = new client_1.AIEvalClient({ apiKey: "test", baseUrl: "http://localhost" });
+        const fetchMock = vitest_1.vi.fn().mockResolvedValue({
+            ok: false,
+            status: 429,
+            json: async () => ({ error: { code: "RATE_LIMIT_EXCEEDED" } }),
+        });
+        globalThis.fetch = fetchMock;
+        const createErrorSpy = vitest_1.vi
+            .spyOn(errorsModule, "createErrorFromResponse")
+            .mockReturnValue(new errorsModule.EvalAIError("rate limited", "RATE_LIMIT_EXCEEDED", 429));
+        await (0, vitest_1.expect)(client.request("/api/fail", { method: "GET" })).rejects.toHaveProperty("code", "RATE_LIMIT_EXCEEDED");
+        createErrorSpy.mockRestore();
+    });
+    (0, vitest_1.it)("retries on retryable SDK errors and eventually succeeds", async () => {
+        const client = new client_1.AIEvalClient({ apiKey: "test", baseUrl: "http://localhost", timeout: 1000 });
+        vitest_1.vi.spyOn(client, "calculateBackoff").mockReturnValue(0);
+        const failureResponse = {
+            ok: false,
+            status: 429,
+            json: async () => ({ error: { code: "RATE_LIMIT_EXCEEDED" } }),
+        };
+        const successResponse = {
+            ok: true,
+            status: 200,
+            json: async () => ({ ok: true }),
+        };
+        const createErrorSpy = vitest_1.vi
+            .spyOn(errorsModule, "createErrorFromResponse")
+            .mockReturnValue(new errorsModule.EvalAIError("rate limited", "RATE_LIMIT_EXCEEDED", 429));
+        const fetchMock = vitest_1.vi
+            .fn()
+            .mockResolvedValueOnce(failureResponse)
+            .mockResolvedValueOnce(successResponse);
+        globalThis.fetch = fetchMock;
+        const result = await client.request("/api/retry", { method: "GET" });
+        (0, vitest_1.expect)(result).toEqual({ ok: true });
+        (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(2);
+        createErrorSpy.mockRestore();
+    });
+    (0, vitest_1.it)("throws a TIMEOUT SDK error when fetch aborts", async () => {
+        const client = new client_1.AIEvalClient({ apiKey: "test", baseUrl: "http://localhost", timeout: 1000 });
+        const abortError = Object.assign(new Error("aborted"), { name: "AbortError" });
+        const fetchMock = vitest_1.vi.fn().mockRejectedValue(abortError);
+        globalThis.fetch = fetchMock;
+        await (0, vitest_1.expect)(client.request("/api/timeout", { method: "GET" })).rejects.toMatchObject({
+            code: "TIMEOUT",
+        });
+    });
+    (0, vitest_1.it)("invalidates related cache entries for mutation requests", async () => {
+        const client = new client_1.AIEvalClient({ apiKey: "test", baseUrl: "http://localhost", timeout: 1000 });
+        cache_1.shouldCache.mockReturnValue(false);
+        const fetchMock = vitest_1.vi.fn().mockResolvedValue({
+            ok: true,
+            status: 201,
+            json: async () => ({ result: "ok" }),
+        });
+        globalThis.fetch = fetchMock;
+        await client.request("/api/evaluations", { method: "POST", body: JSON.stringify({}) });
+        (0, vitest_1.expect)(cache_1.cacheTracker.invalidatedPatterns).toContain("evaluations");
+    });
+});

package/dist/context.d.ts

@@ -22,7 +22,7 @@
  * Context metadata that will be automatically injected
  */
 export interface ContextMetadata {
-    [key: string]: any;
+    [key: string]: unknown;
 }
 /**
  * Context manager for automatic metadata propagation
@@ -75,7 +75,7 @@ export declare class EvalContext {
  */
 export declare function createContext(metadata: ContextMetadata): EvalContext;
 /**
- * Get the current context metadata (if any)
+ * Get the current context metadata (if unknown)
  *
  * @example
  * ```typescript
@@ -98,7 +98,7 @@ export declare function getCurrentContext(): ContextMetadata | undefined;
  * };
  * ```
  */
-export declare function mergeWithContext(metadata?: Record<string, any>): Record<string, any>;
+export declare function mergeWithContext(metadata?: Record<string, unknown>): Record<string, unknown>;
 /**
  * Run with nested context (merges parent context)
  *
@@ -131,4 +131,4 @@ export declare function withContextSync<T>(metadata: ContextMetadata, fn: () =>
  * }
  * ```
  */
-export declare function WithContext(metadata: ContextMetadata): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function WithContext(metadata: ContextMetadata): (_target: unknown, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/context.js

@@ -131,7 +131,7 @@ function createContext(metadata) {
     return new EvalContext(metadata);
 }
 /**
- * Get the current context metadata (if any)
+ * Get the current context metadata (if unknown)
  *
  * @example
  * ```typescript

package/dist/errors.d.ts

@@ -42,14 +42,14 @@ export declare class EvalAIError extends Error {
     /** Whether this error is retryable */
     retryable: boolean;
     /** Additional error details from the API */
-    details?: any;
+    details?: unknown;
     /** When to retry (for rate limit errors) in seconds */
     retryAfter?: number;
     /** When the limit resets (for feature limit errors) */
     resetAt?: Date;
     /** Request ID from API (for correlation/debugging) */
     requestId?: string;
-    constructor(message: string, code: string, statusCode: number, details?: any);
+    constructor(message: string, code: string, statusCode: number, details?: unknown);
     /**
      * Get formatted error message with solutions
      */
@@ -61,12 +61,12 @@ export declare class EvalAIError extends Error {
     /**
      * Convert to JSON for logging
      */
-    toJSON(): Record<string, any>;
+    toJSON(): Record<string, unknown>;
 }
 /**
  * Create an error from an HTTP response
  */
-export declare function createErrorFromResponse(response: Response, data: any): EvalAIError;
+export declare function createErrorFromResponse(response: Response, data: unknown): EvalAIError;
 export declare class RateLimitError extends EvalAIError {
     constructor(message: string, retryAfter?: number);
 }
@@ -74,7 +74,7 @@ export declare class AuthenticationError extends EvalAIError {
     constructor(message?: string);
 }
 export declare class ValidationError extends EvalAIError {
-    constructor(message?: string, details?: any);
+    constructor(message?: string, details?: unknown);
 }
 export declare class NetworkError extends EvalAIError {
     constructor(message?: string);

package/dist/errors.js

@@ -160,27 +160,21 @@ class EvalAIError extends Error {
         this.code = code;
         this.statusCode = statusCode;
         this.details = details;
-        // Get documentation and solutions
-        const errorDoc = ERROR_DOCS[code];
-        if (errorDoc) {
-            this.documentation = errorDoc.documentation;
-            this.solutions = errorDoc.solutions;
-            this.retryable = errorDoc.retryable;
-        }
-        else {
-            this.documentation = "https://docs.ai-eval-platform.com/errors";
-            this.solutions = ["Check the API documentation for more information"];
-            this.retryable = false;
-        }
+        // Initialize required properties from ERROR_DOCS
+        const doc = ERROR_DOCS[code];
+        this.documentation = doc?.documentation ?? `https://docs.ai-eval-platform.com/errors/${code}`;
+        this.solutions = doc?.solutions ?? ["Check the error details for more information"];
+        this.retryable = doc?.retryable ?? false;
         // Extract retry-after for rate limits
-        if (code === "RATE_LIMIT_EXCEEDED" && details?.retryAfter) {
-            this.retryAfter = details.retryAfter;
+        const errorDetails = details;
+        if (code === "RATE_LIMIT_EXCEEDED" && errorDetails?.retryAfter) {
+            this.retryAfter = errorDetails.retryAfter;
         }
         // Extract reset time for feature limits
-        if (code === "FEATURE_LIMIT_REACHED" && details?.resetAt) {
-            this.resetAt = new Date(details.resetAt);
+        if (code === "FEATURE_LIMIT_REACHED" && errorDetails?.resetAt) {
+            this.resetAt = new Date(errorDetails.resetAt);
         }
-        this.requestId = details?.error?.requestId ?? details?.requestId;
+        this.requestId = errorDetails?.error?.requestId ?? errorDetails?.requestId;
         // Ensure proper prototype chain
         Object.setPrototypeOf(this, EvalAIError.prototype);
     }
@@ -234,14 +228,17 @@ exports.SDKError = EvalAIError;
  */
 function createErrorFromResponse(response, data) {
     const status = response.status;
-    const errObj = data?.error && typeof data.error === "object" ? data.error : data;
-    let code = errObj?.code ?? data?.code ?? "UNKNOWN_ERROR";
-    const message = typeof data?.error === "string"
-        ? data.error
-        : (errObj?.message ?? data?.message ?? response.statusText);
-    const requestId = errObj?.requestId ?? data?.requestId ?? response.headers.get("x-request-id") ?? undefined;
+    const errorData = data;
+    const errObj = errorData?.error && typeof errorData.error === "object"
+        ? errorData.error
+        : errorData;
+    let code = errObj?.code ?? errorData?.code ?? "UNKNOWN_ERROR";
+    const message = typeof errorData?.error === "string"
+        ? errorData.error
+        : (errObj?.message ?? errorData?.message ?? response.statusText);
+    const requestId = errObj?.requestId ?? errorData?.requestId ?? response.headers.get("x-request-id") ?? undefined;
     // Map HTTP status to error codes when code not in response
-    if (!errObj?.code && !data?.code) {
+    if (!errObj?.code && !errorData?.code) {
         if (status === 401)
             code = "UNAUTHORIZED";
         else if (status === 403)

package/dist/export.d.ts

@@ -181,7 +181,7 @@ export declare function importFromFile(client: AIEvalClient, filePath: string, o
  * });
  * ```
  */
-export declare function importFromLangSmith(client: AIEvalClient, langsmithData: any, options: ImportOptions): Promise<ImportResult>;
+export declare function importFromLangSmith(client: AIEvalClient, langsmithData: unknown, options: ImportOptions): Promise<ImportResult>;
 /**
  * Convert export data to CSV format
  *

package/dist/export.js

@@ -292,8 +292,10 @@ async function importFromLangSmith(client, langsmithData, options) {
         traces: [],
     };
     // Transform runs to traces
-    if (langsmithData.runs && Array.isArray(langsmithData.runs)) {
-        transformedData.traces = langsmithData.runs.map((run) => ({
+    const lsData = langsmithData;
+    if (lsData.runs && Array.isArray(lsData.runs)) {
+        transformedData.traces = lsData.runs.map((run) => ({
+            id: run.id || 0,
             name: run.name || "Imported Trace",
             traceId: run.id || `langsmith-${Date.now()}-${Math.random()}`,
             organizationId: options.organizationId,

package/dist/integrations/openai-eval.js

@@ -141,7 +141,7 @@ async function openAIChatEval(options) {
                 for (let i = 0; i < result.results.length; i++) {
                     const tcId = cases[i]?.testCaseId;
                     if (tcId == null) {
-                        console.log("reportToEvalAI: All cases must have testCaseId when any has it.");
+                        console.log("reportToEvalAI: All cases must have testCaseId when unknown has it.");
                         return evalResult;
                     }
                     importResults.push({

package/dist/logger.d.ts

@@ -29,7 +29,7 @@ export interface LogEntry {
     level: LogLevel;
     message: string;
     timestamp: string;
-    data?: any;
+    data?: unknown;
     prefix?: string;
 }
 /**
@@ -41,31 +41,31 @@ export declare class Logger {
     /**
      * Log a trace message
      */
-    trace(message: string, data?: any): void;
+    trace(message: string, data?: unknown): void;
     /**
      * Log a debug message
      */
-    debug(message: string, data?: any): void;
+    debug(message: string, data?: unknown): void;
     /**
      * Log an info message
      */
-    info(message: string, data?: any): void;
+    info(message: string, data?: unknown): void;
     /**
      * Log a warning message
      */
-    warn(message: string, data?: any): void;
+    warn(message: string, data?: unknown): void;
     /**
      * Log an error message
      */
-    error(message: string, data?: any): void;
+    error(message: string, data?: unknown): void;
     /**
      * Log HTTP request
      */
-    logRequest(method: string, url: string, data?: any): void;
+    logRequest(method: string, url: string, data?: unknown): void;
     /**
      * Log HTTP response
      */
-    logResponse(method: string, url: string, status: number, duration: number, data?: any): void;
+    logResponse(method: string, url: string, status: number, duration: number, data?: unknown): void;
     /**
      * Create child logger with prefix
      */
@@ -112,7 +112,7 @@ export declare class RequestLogger {
         method: string;
         url: string;
         headers?: Record<string, string>;
-        body?: any;
+        body?: unknown;
     }): void;
     /**
      * Log response after receiving
@@ -123,6 +123,6 @@ export declare class RequestLogger {
         status: number;
         duration: number;
         headers?: Record<string, string>;
-        body?: any;
+        body?: unknown;
     }): void;
 }

package/dist/pagination.d.ts

@@ -56,11 +56,11 @@ export declare function autoPaginate<T>(fetchFn: (offset: number, limit: number)
 /**
  * Encode cursor for pagination (base64)
  */
-export declare function encodeCursor(data: any): string;
+export declare function encodeCursor(data: unknown): string;
 /**
  * Decode cursor from base64
  */
-export declare function decodeCursor(cursor: string): any;
+export declare function decodeCursor(cursor: string): unknown;
 /**
  * Create pagination metadata from response
  */

package/dist/snapshot.d.ts

@@ -26,7 +26,7 @@ export interface SnapshotMetadata {
     /** Optional tags for organization */
     tags?: string[];
     /** Additional metadata */
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
 }
 export interface SnapshotData {
     /** The actual output that was snapshotted */
@@ -75,7 +75,7 @@ export declare class SnapshotManager {
      */
     save(name: string, output: string, options?: {
         tags?: string[];
-        metadata?: Record<string, any>;
+        metadata?: Record<string, unknown>;
         overwrite?: boolean;
     }): Promise<SnapshotData>;
     /**
@@ -140,7 +140,7 @@ export declare class SnapshotManager {
  */
 export declare function snapshot(output: string, name: string, options?: {
     tags?: string[];
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
     overwrite?: boolean;
     dir?: string;
 }): Promise<SnapshotData>;

package/dist/streaming.d.ts

@@ -49,14 +49,14 @@ export interface BatchError {
     /** The error */
     error: Error;
     /** The item that failed */
-    item: any;
+    item: unknown;
 }
 export interface BatchResult<T> {
     /** Successfully processed items */
     successful: T[];
     /** Failed items */
     failed: Array<{
-        item: any;
+        item: unknown;
         error: Error;
     }>;
     /** Summary */
@@ -106,12 +106,12 @@ export declare function batchProcess<TInput, TOutput>(processor: (item: TInput)
  */
 export declare function streamEvaluation<T>(config: {
     cases: T[];
-    executor: (testCase: T) => Promise<any>;
+    executor: (testCase: T) => Promise<unknown>;
     onProgress?: (progress: BatchProgress) => void;
 }): AsyncGenerator<{
     caseId: string;
     case: T;
-    result: any;
+    result: unknown;
     passed: boolean;
     completed: number;
     total: number;

package/dist/testing.d.ts

@@ -34,7 +34,7 @@ export interface TestSuiteCase {
     /** Expected output (optional) */
     expected?: string;
     /** Metadata for the test case */
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
     /** Assertion functions to run */
     assertions?: ((output: string) => AssertionResult)[];
 }

package/dist/types.d.ts

@@ -90,7 +90,7 @@ export interface OrganizationLimits {
  * Trace object representing a single execution trace
  * Generic metadata support for type safety
  */
-export interface Trace<TMetadata = Record<string, any>> {
+export interface Trace<TMetadata = Record<string, unknown>> {
     id: number;
     name: string;
     traceId: string;
@@ -103,7 +103,7 @@ export interface Trace<TMetadata = Record<string, any>> {
 /**
  * Parameters for creating a new trace
  */
-export interface CreateTraceParams<TMetadata = Record<string, any>> {
+export interface CreateTraceParams<TMetadata = Record<string, unknown>> {
     name: string;
     traceId: string;
     organizationId?: number;
@@ -114,7 +114,7 @@ export interface CreateTraceParams<TMetadata = Record<string, any>> {
 /**
  * Parameters for updating an existing trace
  */
-export interface UpdateTraceParams<TMetadata = Record<string, any>> {
+export interface UpdateTraceParams<TMetadata = Record<string, unknown>> {
     status?: "pending" | "success" | "error";
     durationMs?: number;
     metadata?: TMetadata;
@@ -132,7 +132,7 @@ export interface ListTracesParams {
 /**
  * Span object representing a sub-operation within a trace
  */
-export interface Span<TMetadata = Record<string, any>> {
+export interface Span<TMetadata = Record<string, unknown>> {
     id: number;
     traceId: number;
     name: string;
@@ -147,7 +147,7 @@ export interface Span<TMetadata = Record<string, any>> {
 /**
  * Parameters for creating a span
  */
-export interface CreateSpanParams<TMetadata = Record<string, any>> {
+export interface CreateSpanParams<TMetadata = Record<string, unknown>> {
     name: string;
     spanId: string;
     parentSpanId?: string;
@@ -159,7 +159,7 @@ export interface CreateSpanParams<TMetadata = Record<string, any>> {
 /**
  * Evaluation object representing a test evaluation
  */
-export interface Evaluation<TMetadata = Record<string, any>> {
+export interface Evaluation<TMetadata = Record<string, unknown>> {
     id: number;
     name: string;
     description: string | null;
@@ -210,7 +210,7 @@ export interface TestCase {
     evaluationId: number;
     input: string;
     expectedOutput: string | null;
-    metadata: Record<string, any> | null;
+    metadata: Record<string, unknown> | null;
     createdAt: string;
 }
 /**
@@ -219,7 +219,7 @@ export interface TestCase {
 export interface CreateTestCaseParams {
     input: string;
     expectedOutput?: string;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
 }
 /**
  * Evaluation run
@@ -228,7 +228,7 @@ export interface EvaluationRun {
     id: number;
     evaluationId: number;
     status: "pending" | "running" | "completed" | "failed";
-    results: Record<string, any> | null;
+    results: Record<string, unknown> | null;
     createdAt: string;
     completedAt: string | null;
 }
@@ -237,7 +237,7 @@ export interface EvaluationRun {
  */
 export interface CreateRunParams {
     status?: "pending" | "running" | "completed" | "failed";
-    results?: Record<string, any>;
+    results?: Record<string, unknown>;
 }
 /**
  * LLM Judge evaluation result
@@ -249,7 +249,7 @@ export interface LLMJudgeResult {
     output: string;
     score: number | null;
     reasoning: string | null;
-    metadata: Record<string, any> | null;
+    metadata: Record<string, unknown> | null;
     createdAt: string;
 }
 /**
@@ -261,7 +261,7 @@ export interface RunLLMJudgeParams {
     output: string;
     score?: number;
     reasoning?: string;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
 }
 /**
  * SDK Error class with additional error details
@@ -285,26 +285,26 @@ export interface RunLLMJudgeParams {
 export declare class SDKError extends Error {
     code: string;
     statusCode: number;
-    details?: any;
+    details?: unknown;
     documentation?: string;
     solutions?: string[];
     retryable?: boolean;
     retryAfter?: number;
-    constructor(message: string, code: string, statusCode: number, details?: any);
+    constructor(message: string, code: string, statusCode: number, details?: unknown);
 }
 export type AIEvalConfig = ClientConfig;
-export type TraceData<TMetadata = any> = Trace<TMetadata>;
-export type SpanData<TMetadata = any> = Span<TMetadata>;
-export type EvaluationData<TMetadata = any> = Evaluation<TMetadata>;
+export type TraceData<TMetadata = unknown> = Trace<TMetadata>;
+export type SpanData<TMetadata = unknown> = Span<TMetadata>;
+export type EvaluationData<TMetadata = unknown> = Evaluation<TMetadata>;
 export type LLMJudgeData = LLMJudgeResult;
-export type AnnotationData = any;
+export type AnnotationData = unknown;
 export interface RetryConfig {
     maxAttempts?: number;
     backoff?: "exponential" | "linear" | "fixed";
     retryableErrors?: string[];
 }
 export interface GenericMetadata {
-    [key: string]: any;
+    [key: string]: unknown;
 }
 export interface TracedResponse<T> {
     data: T;
@@ -314,14 +314,14 @@ export interface TracedResponse<T> {
 export interface TestResult {
     passed: boolean;
     message?: string;
-    expected?: any;
-    actual?: any;
+    expected?: unknown;
+    actual?: unknown;
     metadata?: GenericMetadata;
 }
 export interface SnapshotData {
     id: string;
     name: string;
-    data: any;
+    data: unknown;
     metadata?: GenericMetadata;
     createdAt: string;
     updatedAt: string;
@@ -346,7 +346,7 @@ export interface ImportOptions {
     dryRun?: boolean;
 }
 export interface StreamOptions {
-    onData: (data: any) => void;
+    onData: (data: unknown) => void;
     onError?: (error: Error) => void;
     onComplete?: () => void;
     signal?: AbortSignal;
@@ -371,8 +371,8 @@ export interface Annotation {
     annotatorId: string;
     rating: number | null;
     feedback: string | null;
-    labels: Record<string, any>;
-    metadata: Record<string, any>;
+    labels: Record<string, unknown>;
+    metadata: Record<string, unknown>;
     createdAt: string;
     annotator?: {
         id: string;
@@ -391,8 +391,8 @@ export interface CreateAnnotationParams {
     testCaseId: number;
     rating?: number;
     feedback?: string;
-    labels?: Record<string, any>;
-    metadata?: Record<string, any>;
+    labels?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
 }
 /**
  * Parameters for listing annotations
@@ -414,7 +414,7 @@ export interface AnnotationTask {
     type: string;
     status: "pending" | "in_progress" | "completed" | "archived";
     organizationId: number;
-    annotationSettings: Record<string, any>;
+    annotationSettings: Record<string, unknown>;
     createdAt: string;
     updatedAt: string;
 }
@@ -427,7 +427,7 @@ export interface CreateAnnotationTaskParams {
     instructions?: string;
     type: string;
     organizationId: number;
-    annotationSettings?: Record<string, any>;
+    annotationSettings?: Record<string, unknown>;
 }
 /**
  * Parameters for listing annotation tasks
@@ -445,7 +445,7 @@ export interface AnnotationItem {
     id: number;
     taskId: number;
     content: string;
-    annotation: any | null;
+    annotation: unknown | null;
     annotatedBy: string | null;
     annotatedAt: string | null;
     createdAt: string;
@@ -455,7 +455,7 @@ export interface AnnotationItem {
  */
 export interface CreateAnnotationItemParams {
     content: string;
-    annotation?: any;
+    annotation?: unknown;
     annotatedBy?: string;
     annotatedAt?: string;
 }
@@ -573,7 +573,7 @@ export interface WebhookDelivery {
     id: number;
     webhookId: number;
     event: string;
-    payload: Record<string, any>;
+    payload: Record<string, unknown>;
     response: string | null;
     statusCode: number | null;
     success: boolean;
@@ -719,5 +719,5 @@ export interface Organization {
     status: "active" | "suspended" | "cancelled";
     createdAt: string;
     updatedAt: string;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
 }

package/dist/workflows.d.ts

@@ -34,7 +34,7 @@ export interface WorkflowNode {
     id: string;
     type: "agent" | "tool" | "decision" | "parallel" | "human" | "llm";
     name: string;
-    config?: Record<string, any>;
+    config?: Record<string, unknown>;
 }
 /**
  * Edge connecting nodes in a workflow DAG
@@ -52,7 +52,17 @@ export interface WorkflowDefinition {
     nodes: WorkflowNode[];
     edges: WorkflowEdge[];
     entrypoint: string;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
+}
+interface LangChainExecutor {
+    invoke?: (input: unknown, config?: unknown) => Promise<unknown>;
+    call?: (input: unknown, config?: unknown) => Promise<unknown>;
+}
+interface CrewAI {
+    kickoff?: (input?: unknown) => Promise<unknown>;
+}
+interface LangChainConversation {
+    initiate_chat?: (...args: unknown[]) => Promise<unknown>;
 }
 /**
  * Active workflow context
@@ -63,7 +73,7 @@ export interface WorkflowContext {
     name: string;
     startedAt: string;
     definition?: WorkflowDefinition;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
 }
 /**
  * Workflow run status
@@ -80,7 +90,7 @@ export interface AgentHandoff {
     fromAgent?: string;
     toAgent: string;
     handoffType: HandoffType;
-    context?: Record<string, any>;
+    context?: Record<string, unknown>;
     timestamp: string;
 }
 /**
@@ -115,7 +125,7 @@ export interface RecordDecisionParams {
     /** Factors that influenced the decision */
     contextFactors?: string[];
     /** Input context at decision time */
-    inputContext?: Record<string, any>;
+    inputContext?: Record<string, unknown>;
 }
 /**
  * LLM provider names
@@ -169,7 +179,7 @@ export interface AgentSpanContext {
     agentName: string;
     startTime: string;
     parentSpanId?: string;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
 }
 /**
  * WorkflowTracer - Instrument multi-agent workflows with tracing, decision auditing, and cost tracking
@@ -213,11 +223,11 @@ export declare class WorkflowTracer {
      * });
      * ```
      */
-    startWorkflow(name: string, definition?: WorkflowDefinition, metadata?: Record<string, any>): Promise<WorkflowContext>;
+    startWorkflow(name: string, definition?: WorkflowDefinition, metadata?: Record<string, unknown>): Promise<WorkflowContext>;
     /**
      * End the current workflow
      */
-    endWorkflow(output?: Record<string, any>, status?: WorkflowStatus): Promise<void>;
+    endWorkflow(output?: Record<string, unknown>, status?: WorkflowStatus): Promise<void>;
     /**
      * Start an agent span within the workflow
      *
@@ -228,11 +238,11 @@ export declare class WorkflowTracer {
      * });
      * ```
      */
-    startAgentSpan(agentName: string, input?: Record<string, any>, parentSpanId?: string): Promise<AgentSpanContext>;
+    startAgentSpan(agentName: string, input?: Record<string, unknown>, parentSpanId?: string): Promise<AgentSpanContext>;
     /**
      * End an agent span
      */
-    endAgentSpan(span: AgentSpanContext, output?: Record<string, any>, error?: string): Promise<void>;
+    endAgentSpan(span: AgentSpanContext, output?: Record<string, unknown>, error?: string): Promise<void>;
     /**
      * Record a handoff between agents
      *
@@ -246,7 +256,7 @@ export declare class WorkflowTracer {
      * );
      * ```
      */
-    recordHandoff(fromAgent: string | undefined, toAgent: string, context?: Record<string, any>, handoffType?: HandoffType): Promise<void>;
+    recordHandoff(fromAgent: string | undefined, toAgent: string, context?: Record<string, unknown>, handoffType?: HandoffType): Promise<void>;
     /**
      * Record a decision made by an agent
      *
@@ -337,9 +347,9 @@ export declare class WorkflowTracer {
  * const result = await tracedExecutor.invoke({ input: 'Hello' });
  * ```
  */
-export declare function traceLangChainAgent(executor: any, tracer: WorkflowTracer, options?: {
+export declare function traceLangChainAgent(executor: LangChainExecutor, tracer: WorkflowTracer, options?: {
     agentName?: string;
-}): any;
+}): LangChainExecutor;
 /**
  * Create a traced wrapper for CrewAI crews
  *
@@ -352,9 +362,9 @@ export declare function traceLangChainAgent(executor: any, tracer: WorkflowTrace
  * const result = await tracedCrew.kickoff({ topic: 'AI Safety' });
  * ```
  */
-export declare function traceCrewAI(crew: any, tracer: WorkflowTracer, options?: {
+export declare function traceCrewAI(crew: CrewAI, tracer: WorkflowTracer, options?: {
     crewName?: string;
-}): any;
+}): CrewAI;
 /**
  * Create a traced wrapper for AutoGen conversations
  *
@@ -365,9 +375,9 @@ export declare function traceCrewAI(crew: any, tracer: WorkflowTracer, options?:
  * });
  * ```
  */
-export declare function traceAutoGen(conversation: any, tracer: WorkflowTracer, options?: {
+export declare function traceAutoGen(conversation: LangChainConversation, tracer: WorkflowTracer, options?: {
     conversationName?: string;
-}): any;
+}): LangChainConversation;
 /**
  * Create a workflow tracer from an existing client
  */
@@ -375,4 +385,5 @@ export declare function createWorkflowTracer(client: AIEvalClient, options?: Wor
 /**
  * Helper to trace an async function as a workflow step
  */
-export declare function traceWorkflowStep<T>(tracer: WorkflowTracer, agentName: string, fn: () => Promise<T>, input?: Record<string, any>): Promise<T>;
+export declare function traceWorkflowStep<T>(tracer: WorkflowTracer, agentName: string, fn: () => Promise<T>, input?: Record<string, unknown>): Promise<T>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pauly4010/evalai-sdk",
-  "version": "1.5.7",
+  "version": "1.5.8",
   "description": "AI Evaluation Platform SDK - Complete API Coverage with Performance Optimizations",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -20,8 +20,7 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "test": "vitest",
-    "prepublishOnly": "npm run build"
+    "test": "vitest"
   },
   "keywords": [
     "ai",