langsmith 0.3.80 → 0.3.82

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;

package/dist/vitest/reporter.mjs

@@ -1,12 +1,31 @@
 /* eslint-disable import/no-extraneous-dependencies */
-import { printVitestReporterTable } from "./utils/reporter.js";
+import { printVitestReporterTable, printVitestTestModulesReporterTable, } from "./utils/reporter.js";
 import { importVitestModule } from "./utils/esm.mjs";
 const vitestReporters = await importVitestModule("reporters");
 const DefaultReporter = vitestReporters.DefaultReporter;
 class LangSmithEvalReporter extends DefaultReporter {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "skipOnFinished", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
     async onFinished(files, errors) {
         super.onFinished(files, errors);
+        // Vitest 3.x will call `onFinished` after `onTestRunEnd`,
+        // thus we need to gate this to avoid double printing.
+        if (this.skipOnFinished)
+            return;
         await printVitestReporterTable(files, this.ctx);
     }
+    // `onFinished` is removed in Vitest 4.x, so we use `onTestRunEnd` instead.
+    async onTestRunEnd(testModules, unhandledErrors, reason) {
+        super.onTestRunEnd(testModules, unhandledErrors, reason);
+        this.skipOnFinished = true;
+        await printVitestTestModulesReporterTable(testModules);
+    }
 }
 export default LangSmithEvalReporter;

package/dist/vitest/utils/reporter.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printVitestReporterTable = void 0;
+exports.printVitestTestModulesReporterTable = exports.printVitestReporterTable = void 0;
 const reporter_js_1 = require("../../utils/jestlike/reporter.cjs");
 // Can't use types here because of module resolution issues
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -23,3 +23,16 @@ const printVitestReporterTable = async (files, ctx) => {
     }
 };
 exports.printVitestReporterTable = printVitestReporterTable;
+const printVitestTestModulesReporterTable = async (testModules) => {
+    for (const testModule of testModules) {
+        const tests = [...testModule.children.allTests()].map((test) => {
+            return {
+                title: test.name,
+                status: test.result()?.state ?? "skipped",
+                duration: Math.round(test.diagnostic()?.duration ?? 0),
+            };
+        });
+        await (0, reporter_js_1.printReporterTable)(testModule.relativeModuleId, tests, testModule.state());
+    }
+};
+exports.printVitestTestModulesReporterTable = printVitestTestModulesReporterTable;

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

@@ -1 +1,31 @@
 export declare const printVitestReporterTable: (files: any, ctx: any) => Promise<void>;
+export interface VitestTestModule {
+    children: {
+        allTests: () => {
+            name: string;
+            result: () => {
+                state: "pending" | "passed" | "failed" | "skipped";
+            };
+            diagnostic: () => {
+                duration: number;
+            };
+        }[];
+    };
+    state: () => "skipped" | "passed" | "failed";
+    relativeModuleId: string;
+}
+export declare const printVitestTestModulesReporterTable: (testModules: {
+    children: {
+        allTests: () => {
+            name: string;
+            result: () => {
+                state: "pending" | "passed" | "failed" | "skipped";
+            };
+            diagnostic: () => {
+                duration: number;
+            };
+        }[];
+    };
+    state: () => "skipped" | "passed" | "failed";
+    relativeModuleId: string;
+}[]) => Promise<void>;

package/dist/vitest/utils/reporter.js

@@ -19,3 +19,15 @@ export const printVitestReporterTable = async (files, ctx) => {
         }
     }
 };
+export const printVitestTestModulesReporterTable = async (testModules) => {
+    for (const testModule of testModules) {
+        const tests = [...testModule.children.allTests()].map((test) => {
+            return {
+                title: test.name,
+                status: test.result()?.state ?? "skipped",
+                duration: Math.round(test.diagnostic()?.duration ?? 0),
+            };
+        });
+        await printReporterTable(testModule.relativeModuleId, tests, testModule.state());
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.3.80",
+  "version": "0.3.82",
   "description": "Client library to connect to the LangSmith Observability and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [
@@ -144,7 +144,6 @@
     "chalk": "^4.1.2",
     "console-table-printer": "^2.12.1",
     "p-queue": "^6.6.2",
-    "p-retry": "4",
     "semver": "^7.6.3",
     "uuid": "^10.0.0"
   },