langsmith 0.3.81 → 0.3.82

package/dist/utils/async_caller.cjs

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncCaller = void 0;
-const p_retry_1 = __importDefault(require("p-retry"));
+const index_js_1 = __importDefault(require("../utils/p-retry/index.cjs"));
 const p_queue_1 = __importDefault(require("p-queue"));
 const STATUS_RETRYABLE = [
     408, // Request Timeout
@@ -100,7 +100,7 @@ class AsyncCaller {
             this.queueSizeBytes += sizeBytes;
         }
         const onFailedResponseHook = this.onFailedResponseHook;
-        let promise = this.queue.add(() => (0, p_retry_1.default)(() => callable(...args).catch((error) => {
+        let promise = this.queue.add(() => (0, index_js_1.default)(() => callable(...args).catch((error) => {
             // eslint-disable-next-line no-instanceof/no-instanceof
             if (error instanceof Error) {
                 throw error;
@@ -110,7 +110,7 @@ class AsyncCaller {
             }
         }), {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            async onFailedAttempt(error) {
+            async onFailedAttempt({ error }) {
                 if (error.message.startsWith("Cancel") ||
                     error.message.startsWith("TimeoutError") ||
                     error.name === "TimeoutError" ||

package/dist/utils/async_caller.js

@@ -1,4 +1,4 @@
-import pRetry from "p-retry";
+import pRetry from "../utils/p-retry/index.js";
 import PQueueMod from "p-queue";
 const STATUS_RETRYABLE = [
     408, // Request Timeout
@@ -104,7 +104,7 @@ export class AsyncCaller {
             }
         }), {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            async onFailedAttempt(error) {
+            async onFailedAttempt({ error }) {
                 if (error.message.startsWith("Cancel") ||
                     error.message.startsWith("TimeoutError") ||
                     error.name === "TimeoutError" ||

package/dist/utils/context_vars.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContextVar = getContextVar;
+exports.setContextVar = setContextVar;
+const constants_js_1 = require("../singletons/constants.cjs");
+/**
+ * Get a context variable from a run tree instance
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getContextVar(runTree, key) {
+    if (constants_js_1._LC_CONTEXT_VARIABLES_KEY in runTree) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const contextVars = runTree[constants_js_1._LC_CONTEXT_VARIABLES_KEY];
+        return contextVars[key];
+    }
+    return undefined;
+}
+/**
+ * Set a context variable on a run tree instance
+ */
+function setContextVar(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+runTree, key, value) {
+    const contextVars = constants_js_1._LC_CONTEXT_VARIABLES_KEY in runTree
+        ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            runTree[constants_js_1._LC_CONTEXT_VARIABLES_KEY]
+        : {};
+    contextVars[key] = value;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    runTree[constants_js_1._LC_CONTEXT_VARIABLES_KEY] = contextVars;
+}

package/dist/utils/context_vars.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Get a context variable from a run tree instance
+ */
+export declare function getContextVar(runTree: any, key: symbol): unknown;
+/**
+ * Set a context variable on a run tree instance
+ */
+export declare function setContextVar(runTree: any, key: symbol, value: unknown): void;

package/dist/utils/context_vars.js

@@ -0,0 +1,27 @@
+import { _LC_CONTEXT_VARIABLES_KEY } from "../singletons/constants.js";
+/**
+ * Get a context variable from a run tree instance
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getContextVar(runTree, key) {
+    if (_LC_CONTEXT_VARIABLES_KEY in runTree) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const contextVars = runTree[_LC_CONTEXT_VARIABLES_KEY];
+        return contextVars[key];
+    }
+    return undefined;
+}
+/**
+ * Set a context variable on a run tree instance
+ */
+export function setContextVar(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+runTree, key, value) {
+    const contextVars = _LC_CONTEXT_VARIABLES_KEY in runTree
+        ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            runTree[_LC_CONTEXT_VARIABLES_KEY]
+        : {};
+    contextVars[key] = value;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    runTree[_LC_CONTEXT_VARIABLES_KEY] = contextVars;
+}

package/dist/utils/is-network-error/index.cjs

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isNetworkError;
+/* eslint-disable */
+// @ts-nocheck
+// is-network-error vendored to avoid import issues
+// Source: https://github.com/sindresorhus/is-network-error
+const objectToString = Object.prototype.toString;
+const isError = (value) => objectToString.call(value) === "[object Error]";
+const errorMessages = new Set([
+    "network error", // Chrome
+    "Failed to fetch", // Chrome
+    "NetworkError when attempting to fetch resource.", // Firefox
+    "The Internet connection appears to be offline.", // Safari 16
+    "Network request failed", // `cross-fetch`
+    "fetch failed", // Undici (Node.js)
+    "terminated", // Undici (Node.js)
+    " A network error occurred.", // Bun (WebKit)
+    "Network connection lost", // Cloudflare Workers (fetch)
+]);
+function isNetworkError(error) {
+    const isValid = error &&
+        isError(error) &&
+        error.name === "TypeError" &&
+        typeof error.message === "string";
+    if (!isValid) {
+        return false;
+    }
+    const { message, stack } = error;
+    // Safari 17+ has generic message but no stack for network errors
+    if (message === "Load failed") {
+        return (stack === undefined ||
+            // Sentry adds its own stack trace to the fetch error, so also check for that
+            "__sentry_captured__" in error);
+    }
+    // Deno network errors start with specific text
+    if (message.startsWith("error sending request for url")) {
+        return true;
+    }
+    // Standard network error messages
+    return errorMessages.has(message);
+}

package/dist/utils/is-network-error/index.d.ts

@@ -0,0 +1 @@
+export default function isNetworkError(error: any): boolean;

package/dist/utils/is-network-error/index.js

@@ -0,0 +1,39 @@
+/* eslint-disable */
+// @ts-nocheck
+// is-network-error vendored to avoid import issues
+// Source: https://github.com/sindresorhus/is-network-error
+const objectToString = Object.prototype.toString;
+const isError = (value) => objectToString.call(value) === "[object Error]";
+const errorMessages = new Set([
+    "network error", // Chrome
+    "Failed to fetch", // Chrome
+    "NetworkError when attempting to fetch resource.", // Firefox
+    "The Internet connection appears to be offline.", // Safari 16
+    "Network request failed", // `cross-fetch`
+    "fetch failed", // Undici (Node.js)
+    "terminated", // Undici (Node.js)
+    " A network error occurred.", // Bun (WebKit)
+    "Network connection lost", // Cloudflare Workers (fetch)
+]);
+export default function isNetworkError(error) {
+    const isValid = error &&
+        isError(error) &&
+        error.name === "TypeError" &&
+        typeof error.message === "string";
+    if (!isValid) {
+        return false;
+    }
+    const { message, stack } = error;
+    // Safari 17+ has generic message but no stack for network errors
+    if (message === "Load failed") {
+        return (stack === undefined ||
+            // Sentry adds its own stack trace to the fetch error, so also check for that
+            "__sentry_captured__" in error);
+    }
+    // Deno network errors start with specific text
+    if (message.startsWith("error sending request for url")) {
+        return true;
+    }
+    // Standard network error messages
+    return errorMessages.has(message);
+}

package/dist/utils/jestlike/reporter.d.ts

@@ -2,4 +2,4 @@ export declare function printReporterTable(testSuiteName: string, results: {
     title: string;
     duration: number;
     status: "pass" | "passed" | "fail" | "failed" | "pending" | "skipped";
-}[], testStatus: "pass" | "skip" | "fail", failureMessage?: string): Promise<void>;
+}[], testStatus: "pass" | "skip" | "fail" | "passed" | "failed" | "skipped", failureMessage?: string): Promise<void>;

package/dist/utils/p-retry/index.cjs

@@ -0,0 +1,200 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbortError = void 0;
+exports.default = pRetry;
+exports.makeRetriable = makeRetriable;
+/* eslint-disable */
+// @ts-nocheck
+// p-retry code vendored to avoid import issues
+// Source: https://github.com/sindresorhus/p-retry
+const index_js_1 = __importDefault(require("../is-network-error/index.cjs"));
+function validateRetries(retries) {
+    if (typeof retries === "number") {
+        if (retries < 0) {
+            throw new TypeError("Expected `retries` to be a non-negative number.");
+        }
+        if (Number.isNaN(retries)) {
+            throw new TypeError("Expected `retries` to be a valid number or Infinity, got NaN.");
+        }
+    }
+    else if (retries !== undefined) {
+        throw new TypeError("Expected `retries` to be a number or Infinity.");
+    }
+}
+function validateNumberOption(name, value, { min = 0, allowInfinity = false } = {}) {
+    if (value === undefined) {
+        return;
+    }
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        throw new TypeError(`Expected \`${name}\` to be a number${allowInfinity ? " or Infinity" : ""}.`);
+    }
+    if (!allowInfinity && !Number.isFinite(value)) {
+        throw new TypeError(`Expected \`${name}\` to be a finite number.`);
+    }
+    if (value < min) {
+        throw new TypeError(`Expected \`${name}\` to be \u2265 ${min}.`);
+    }
+}
+class AbortError extends Error {
+    constructor(message) {
+        super();
+        if (message instanceof Error) {
+            this.originalError = message;
+            ({ message } = message);
+        }
+        else {
+            this.originalError = new Error(message);
+            this.originalError.stack = this.stack;
+        }
+        this.name = "AbortError";
+        this.message = message;
+    }
+}
+exports.AbortError = AbortError;
+function calculateDelay(retriesConsumed, options) {
+    const attempt = Math.max(1, retriesConsumed + 1);
+    const random = options.randomize ? Math.random() + 1 : 1;
+    let timeout = Math.round(random * options.minTimeout * options.factor ** (attempt - 1));
+    timeout = Math.min(timeout, options.maxTimeout);
+    return timeout;
+}
+function calculateRemainingTime(start, max) {
+    if (!Number.isFinite(max)) {
+        return max;
+    }
+    return max - (performance.now() - start);
+}
+async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTime, options, }) {
+    const normalizedError = error instanceof Error
+        ? error
+        : new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`);
+    if (normalizedError instanceof AbortError) {
+        throw normalizedError.originalError;
+    }
+    const retriesLeft = Number.isFinite(options.retries)
+        ? Math.max(0, options.retries - retriesConsumed)
+        : options.retries;
+    const maxRetryTime = options.maxRetryTime ?? Number.POSITIVE_INFINITY;
+    const context = Object.freeze({
+        error: normalizedError,
+        attemptNumber,
+        retriesLeft,
+        retriesConsumed,
+    });
+    await options.onFailedAttempt(context);
+    if (calculateRemainingTime(startTime, maxRetryTime) <= 0) {
+        throw normalizedError;
+    }
+    const consumeRetry = await options.shouldConsumeRetry(context);
+    const remainingTime = calculateRemainingTime(startTime, maxRetryTime);
+    if (remainingTime <= 0 || retriesLeft <= 0) {
+        throw normalizedError;
+    }
+    if (normalizedError instanceof TypeError &&
+        !(0, index_js_1.default)(normalizedError)) {
+        if (consumeRetry) {
+            throw normalizedError;
+        }
+        options.signal?.throwIfAborted();
+        return false;
+    }
+    if (!(await options.shouldRetry(context))) {
+        throw normalizedError;
+    }
+    if (!consumeRetry) {
+        options.signal?.throwIfAborted();
+        return false;
+    }
+    const delayTime = calculateDelay(retriesConsumed, options);
+    const finalDelay = Math.min(delayTime, remainingTime);
+    if (finalDelay > 0) {
+        await new Promise((resolve, reject) => {
+            const onAbort = () => {
+                clearTimeout(timeoutToken);
+                options.signal?.removeEventListener("abort", onAbort);
+                reject(options.signal.reason);
+            };
+            const timeoutToken = setTimeout(() => {
+                options.signal?.removeEventListener("abort", onAbort);
+                resolve();
+            }, finalDelay);
+            if (options.unref) {
+                timeoutToken.unref?.();
+            }
+            options.signal?.addEventListener("abort", onAbort, { once: true });
+        });
+    }
+    options.signal?.throwIfAborted();
+    return true;
+}
+async function pRetry(input, options = {}) {
+    options = { ...options };
+    validateRetries(options.retries);
+    if (Object.hasOwn(options, "forever")) {
+        throw new Error("The `forever` option is no longer supported. For many use-cases, you can set `retries: Infinity` instead.");
+    }
+    options.retries ??= 10;
+    options.factor ??= 2;
+    options.minTimeout ??= 1000;
+    options.maxTimeout ??= Number.POSITIVE_INFINITY;
+    options.maxRetryTime ??= Number.POSITIVE_INFINITY;
+    options.randomize ??= false;
+    options.onFailedAttempt ??= () => { };
+    options.shouldRetry ??= () => true;
+    options.shouldConsumeRetry ??= () => true;
+    // Validate numeric options and normalize edge cases
+    validateNumberOption("factor", options.factor, {
+        min: 0,
+        allowInfinity: false,
+    });
+    validateNumberOption("minTimeout", options.minTimeout, {
+        min: 0,
+        allowInfinity: false,
+    });
+    validateNumberOption("maxTimeout", options.maxTimeout, {
+        min: 0,
+        allowInfinity: true,
+    });
+    validateNumberOption("maxRetryTime", options.maxRetryTime, {
+        min: 0,
+        allowInfinity: true,
+    });
+    // Treat non-positive factor as 1 to avoid zero backoff or negative behavior
+    if (!(options.factor > 0)) {
+        options.factor = 1;
+    }
+    options.signal?.throwIfAborted();
+    let attemptNumber = 0;
+    let retriesConsumed = 0;
+    const startTime = performance.now();
+    while (Number.isFinite(options.retries) ? retriesConsumed <= options.retries : true) {
+        attemptNumber++;
+        try {
+            options.signal?.throwIfAborted();
+            const result = await input(attemptNumber);
+            options.signal?.throwIfAborted();
+            return result;
+        }
+        catch (error) {
+            if (await onAttemptFailure({
+                error,
+                attemptNumber,
+                retriesConsumed,
+                startTime,
+                options,
+            })) {
+                retriesConsumed++;
+            }
+        }
+    }
+    // Should not reach here, but in case it does, throw an error
+    throw new Error("Retry attempts exhausted without throwing an error.");
+}
+function makeRetriable(function_, options) {
+    return function (...arguments_) {
+        return pRetry(() => function_.apply(this, arguments_), options);
+    };
+}

package/dist/utils/p-retry/index.d.ts

@@ -0,0 +1,5 @@
+export declare class AbortError extends Error {
+    constructor(message: any);
+}
+export default function pRetry(input: any, options?: {}): Promise<any>;
+export declare function makeRetriable(function_: any, options: any): (...arguments_: any[]) => Promise<any>;

package/dist/utils/p-retry/index.js

@@ -0,0 +1,191 @@
+/* eslint-disable */
+// @ts-nocheck
+// p-retry code vendored to avoid import issues
+// Source: https://github.com/sindresorhus/p-retry
+import isNetworkError from "../is-network-error/index.js";
+function validateRetries(retries) {
+    if (typeof retries === "number") {
+        if (retries < 0) {
+            throw new TypeError("Expected `retries` to be a non-negative number.");
+        }
+        if (Number.isNaN(retries)) {
+            throw new TypeError("Expected `retries` to be a valid number or Infinity, got NaN.");
+        }
+    }
+    else if (retries !== undefined) {
+        throw new TypeError("Expected `retries` to be a number or Infinity.");
+    }
+}
+function validateNumberOption(name, value, { min = 0, allowInfinity = false } = {}) {
+    if (value === undefined) {
+        return;
+    }
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        throw new TypeError(`Expected \`${name}\` to be a number${allowInfinity ? " or Infinity" : ""}.`);
+    }
+    if (!allowInfinity && !Number.isFinite(value)) {
+        throw new TypeError(`Expected \`${name}\` to be a finite number.`);
+    }
+    if (value < min) {
+        throw new TypeError(`Expected \`${name}\` to be \u2265 ${min}.`);
+    }
+}
+export class AbortError extends Error {
+    constructor(message) {
+        super();
+        if (message instanceof Error) {
+            this.originalError = message;
+            ({ message } = message);
+        }
+        else {
+            this.originalError = new Error(message);
+            this.originalError.stack = this.stack;
+        }
+        this.name = "AbortError";
+        this.message = message;
+    }
+}
+function calculateDelay(retriesConsumed, options) {
+    const attempt = Math.max(1, retriesConsumed + 1);
+    const random = options.randomize ? Math.random() + 1 : 1;
+    let timeout = Math.round(random * options.minTimeout * options.factor ** (attempt - 1));
+    timeout = Math.min(timeout, options.maxTimeout);
+    return timeout;
+}
+function calculateRemainingTime(start, max) {
+    if (!Number.isFinite(max)) {
+        return max;
+    }
+    return max - (performance.now() - start);
+}
+async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTime, options, }) {
+    const normalizedError = error instanceof Error
+        ? error
+        : new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`);
+    if (normalizedError instanceof AbortError) {
+        throw normalizedError.originalError;
+    }
+    const retriesLeft = Number.isFinite(options.retries)
+        ? Math.max(0, options.retries - retriesConsumed)
+        : options.retries;
+    const maxRetryTime = options.maxRetryTime ?? Number.POSITIVE_INFINITY;
+    const context = Object.freeze({
+        error: normalizedError,
+        attemptNumber,
+        retriesLeft,
+        retriesConsumed,
+    });
+    await options.onFailedAttempt(context);
+    if (calculateRemainingTime(startTime, maxRetryTime) <= 0) {
+        throw normalizedError;
+    }
+    const consumeRetry = await options.shouldConsumeRetry(context);
+    const remainingTime = calculateRemainingTime(startTime, maxRetryTime);
+    if (remainingTime <= 0 || retriesLeft <= 0) {
+        throw normalizedError;
+    }
+    if (normalizedError instanceof TypeError &&
+        !isNetworkError(normalizedError)) {
+        if (consumeRetry) {
+            throw normalizedError;
+        }
+        options.signal?.throwIfAborted();
+        return false;
+    }
+    if (!(await options.shouldRetry(context))) {
+        throw normalizedError;
+    }
+    if (!consumeRetry) {
+        options.signal?.throwIfAborted();
+        return false;
+    }
+    const delayTime = calculateDelay(retriesConsumed, options);
+    const finalDelay = Math.min(delayTime, remainingTime);
+    if (finalDelay > 0) {
+        await new Promise((resolve, reject) => {
+            const onAbort = () => {
+                clearTimeout(timeoutToken);
+                options.signal?.removeEventListener("abort", onAbort);
+                reject(options.signal.reason);
+            };
+            const timeoutToken = setTimeout(() => {
+                options.signal?.removeEventListener("abort", onAbort);
+                resolve();
+            }, finalDelay);
+            if (options.unref) {
+                timeoutToken.unref?.();
+            }
+            options.signal?.addEventListener("abort", onAbort, { once: true });
+        });
+    }
+    options.signal?.throwIfAborted();
+    return true;
+}
+export default async function pRetry(input, options = {}) {
+    options = { ...options };
+    validateRetries(options.retries);
+    if (Object.hasOwn(options, "forever")) {
+        throw new Error("The `forever` option is no longer supported. For many use-cases, you can set `retries: Infinity` instead.");
+    }
+    options.retries ??= 10;
+    options.factor ??= 2;
+    options.minTimeout ??= 1000;
+    options.maxTimeout ??= Number.POSITIVE_INFINITY;
+    options.maxRetryTime ??= Number.POSITIVE_INFINITY;
+    options.randomize ??= false;
+    options.onFailedAttempt ??= () => { };
+    options.shouldRetry ??= () => true;
+    options.shouldConsumeRetry ??= () => true;
+    // Validate numeric options and normalize edge cases
+    validateNumberOption("factor", options.factor, {
+        min: 0,
+        allowInfinity: false,
+    });
+    validateNumberOption("minTimeout", options.minTimeout, {
+        min: 0,
+        allowInfinity: false,
+    });
+    validateNumberOption("maxTimeout", options.maxTimeout, {
+        min: 0,
+        allowInfinity: true,
+    });
+    validateNumberOption("maxRetryTime", options.maxRetryTime, {
+        min: 0,
+        allowInfinity: true,
+    });
+    // Treat non-positive factor as 1 to avoid zero backoff or negative behavior
+    if (!(options.factor > 0)) {
+        options.factor = 1;
+    }
+    options.signal?.throwIfAborted();
+    let attemptNumber = 0;
+    let retriesConsumed = 0;
+    const startTime = performance.now();
+    while (Number.isFinite(options.retries) ? retriesConsumed <= options.retries : true) {
+        attemptNumber++;
+        try {
+            options.signal?.throwIfAborted();
+            const result = await input(attemptNumber);
+            options.signal?.throwIfAborted();
+            return result;
+        }
+        catch (error) {
+            if (await onAttemptFailure({
+                error,
+                attemptNumber,
+                retriesConsumed,
+                startTime,
+                options,
+            })) {
+                retriesConsumed++;
+            }
+        }
+    }
+    // Should not reach here, but in case it does, throw an error
+    throw new Error("Retry attempts exhausted without throwing an error.");
+}
+export function makeRetriable(function_, options) {
+    return function (...arguments_) {
+        return pRetry(() => function_.apply(this, arguments_), options);
+    };
+}

package/dist/vitest/reporter.cjs

@@ -10,5 +10,11 @@ class LangSmithEvalReporter extends reporters_1.DefaultReporter {
         super.onFinished(files, errors);
         await (0, reporter_js_1.printVitestReporterTable)(files, this.ctx);
     }
+    // @ts-expect-error Vitest 4.x introduces a new `onTestRunEnd` method
+    async onTestRunEnd(testModules, unhandledErrors, reason) {
+        // @ts-expect-error Vitest 4.x introduces a new `onTestRunEnd` method
+        super.onTestRunEnd(testModules, unhandledErrors, reason);
+        await (0, reporter_js_1.printVitestTestModulesReporterTable)(testModules);
+    }
 }
 exports.default = LangSmithEvalReporter;

package/dist/vitest/reporter.d.mts

@@ -1,5 +1,11 @@
+import { type VitestTestModule } from "./utils/reporter.js";
 declare const DefaultReporter: any;
 declare class LangSmithEvalReporter extends DefaultReporter {
+    private skipOnFinished;
     onFinished(files: unknown[], errors: unknown[]): Promise<void>;
+    onTestRunEnd(testModules: VitestTestModule[], unhandledErrors: {
+        message: string;
+        name?: string;
+    }[], reason: "passed" | "interrupted" | "failed"): Promise<void>;
 }
 export default LangSmithEvalReporter;

package/dist/vitest/reporter.d.ts

@@ -1,6 +1,8 @@
 import { DefaultReporter } from "vitest/reporters";
 import { RunnerTestFile } from "vitest";
+import { type VitestTestModule } from "./utils/reporter.js";
 declare class LangSmithEvalReporter extends DefaultReporter {
     onFinished(files: RunnerTestFile[], errors: unknown[]): Promise<void>;
+    onTestRunEnd(testModules: VitestTestModule[], unhandledErrors: unknown[], reason: "passed" | "interrupted" | "failed"): Promise<void>;
 }
 export default LangSmithEvalReporter;

package/dist/vitest/reporter.js

@@ -2,11 +2,17 @@
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore Import throws an error in internal CJS build, but seems to work fine after build
 import { DefaultReporter } from "vitest/reporters";
-import { printVitestReporterTable } from "./utils/reporter.js";
+import { printVitestReporterTable, printVitestTestModulesReporterTable, } from "./utils/reporter.js";
 class LangSmithEvalReporter extends DefaultReporter {
     async onFinished(files, errors) {
         super.onFinished(files, errors);
         await printVitestReporterTable(files, this.ctx);
     }
+    // @ts-expect-error Vitest 4.x introduces a new `onTestRunEnd` method
+    async onTestRunEnd(testModules, unhandledErrors, reason) {
+        // @ts-expect-error Vitest 4.x introduces a new `onTestRunEnd` method
+        super.onTestRunEnd(testModules, unhandledErrors, reason);
+        await printVitestTestModulesReporterTable(testModules);
+    }
 }
 export default LangSmithEvalReporter;