langsmith 0.3.56-rc.8 → 0.3.56

package/dist/index.cjs

@@ -10,4 +10,4 @@ Object.defineProperty(exports, "overrideFetchImplementation", { enumerable: true
 var project_js_1 = require("./utils/project.cjs");
 Object.defineProperty(exports, "getDefaultProjectName", { enumerable: true, get: function () { return project_js_1.getDefaultProjectName; } });
 // Update using yarn bump-version
-exports.__version__ = "0.3.56-rc.8";
+exports.__version__ = "0.3.56";

package/dist/index.d.ts

@@ -3,4 +3,4 @@ export type { Dataset, Example, TracerSession, Run, Feedback, RetrieverOutput, }
 export { RunTree, type RunTreeConfig } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
-export declare const __version__ = "0.3.56-rc.8";
+export declare const __version__ = "0.3.56";

package/dist/index.js

@@ -3,4 +3,4 @@ export { RunTree } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
 // Update using yarn bump-version
-export const __version__ = "0.3.56-rc.8";
+export const __version__ = "0.3.56";

package/dist/vitest/index.cjs

@@ -19,80 +19,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrapVitest = exports.wrapEvaluator = exports.logOutputs = exports.logFeedback = exports.expect = exports.describe = exports.it = exports.test = void 0;
 const vitest_1 = require("vitest");
 const matchers_js_1 = require("../utils/jestlike/matchers.cjs");
-const evaluatedBy_js_1 = require("../utils/jestlike/vendor/evaluatedBy.cjs");
-Object.defineProperty(exports, "wrapEvaluator", { enumerable: true, get: function () { return evaluatedBy_js_1.wrapEvaluator; } });
-const index_js_1 = require("../utils/jestlike/index.cjs");
-Object.defineProperty(exports, "logFeedback", { enumerable: true, get: function () { return index_js_1.logFeedback; } });
-Object.defineProperty(exports, "logOutputs", { enumerable: true, get: function () { return index_js_1.logOutputs; } });
-const index_js_2 = require("../utils/jestlike/index.cjs");
+const wrapper_js_1 = require("./utils/wrapper.cjs");
+Object.defineProperty(exports, "wrapVitest", { enumerable: true, get: function () { return wrapper_js_1.wrapVitest; } });
 vitest_1.expect.extend({
     toBeRelativeCloseTo: matchers_js_1.toBeRelativeCloseTo,
     toBeAbsoluteCloseTo: matchers_js_1.toBeAbsoluteCloseTo,
     toBeSemanticCloseTo: matchers_js_1.toBeSemanticCloseTo,
 });
-/**
- * Dynamically wrap original Vitest imports.
- *
- * This may be necessary to ensure you are wrapping the correct
- * Vitest version if you are using a monorepo whose workspaces
- * use multiple versions of Vitest.
- *
- * @param originalVitestMethods - The original Vitest imports to wrap.
- * @returns The wrapped Vitest imports.
- * See https://docs.smith.langchain.com/evaluation/how_to_guides/vitest_jest
- * for more details.
- */
-const wrapVitest = (originalVitestMethods) => {
-    if (typeof originalVitestMethods !== "object" ||
-        originalVitestMethods == null) {
-        throw new Error("originalVitestMethods must be an non-null object.");
-    }
-    if (!("expect" in originalVitestMethods) ||
-        typeof originalVitestMethods.expect !== "function") {
-        throw new Error("Your passed object must contain a `expect` method.");
-    }
-    if (!("it" in originalVitestMethods) ||
-        typeof originalVitestMethods.it !== "function") {
-        throw new Error("Your passed object must contain a `it` method.");
-    }
-    if (!("test" in originalVitestMethods) ||
-        typeof originalVitestMethods.test !== "function") {
-        throw new Error("Your passed object must contain a `test` method.");
-    }
-    if (!("describe" in originalVitestMethods) ||
-        typeof originalVitestMethods.describe !== "function") {
-        throw new Error("Your passed object must contain a `describe` method.");
-    }
-    if (!("beforeAll" in originalVitestMethods) ||
-        typeof originalVitestMethods.beforeAll !== "function") {
-        throw new Error("Your passed object must contain a `beforeAll` method.");
-    }
-    if (!("afterAll" in originalVitestMethods) ||
-        typeof originalVitestMethods.afterAll !== "function") {
-        throw new Error("Your passed object must contain a `afterAll` method.");
-    }
-    const wrappedMethods = (0, index_js_2.generateWrapperFromJestlikeMethods)({
-        expect: originalVitestMethods.expect,
-        it: originalVitestMethods.it,
-        test: originalVitestMethods.test,
-        describe: originalVitestMethods.describe,
-        beforeAll: originalVitestMethods.beforeAll,
-        afterAll: originalVitestMethods.afterAll,
-    }, "vitest");
-    // Return the normal used LS methods for convenience
-    // so that you can do:
-    //
-    // const ls = wrapVitest(vitest);
-    // ls.logFeedback({ key: "quality", score: 0.7 });
-    return {
-        ...wrappedMethods,
-        logFeedback: index_js_1.logFeedback,
-        logOutputs: index_js_1.logOutputs,
-        wrapEvaluator: evaluatedBy_js_1.wrapEvaluator,
-    };
-};
-exports.wrapVitest = wrapVitest;
-const { test, it, describe, expect } = wrapVitest({
+const { test, it, describe, expect, logFeedback, logOutputs, wrapEvaluator } = (0, wrapper_js_1.wrapVitest)({
     expect: vitest_1.expect,
     it: vitest_1.it,
     test: vitest_1.test,
@@ -106,4 +40,7 @@ exports.test = test;
 exports.it = it;
 exports.describe = describe;
 exports.expect = expect;
+exports.logFeedback = logFeedback;
+exports.logOutputs = logOutputs;
+exports.wrapEvaluator = wrapEvaluator;
 __exportStar(require("../utils/jestlike/types.cjs"), exports);

package/dist/vitest/index.d.mts

@@ -0,0 +1,452 @@
+import type { LangSmithJestlikeWrapperParams } from "../utils/jestlike/types.js";
+import { wrapVitest } from "./utils/wrapper.js";
+declare const test: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: LangSmithJestlikeWrapperParams<I, O>, testFn: (data: {
+    inputs: I;
+    referenceOutputs?: O;
+} & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void) & {
+    only: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: LangSmithJestlikeWrapperParams<I, O>, testFn: (data: {
+        inputs: I;
+        referenceOutputs?: O;
+    } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void) & {
+        each: <I extends import("../schemas.js").KVMap, O extends import("../schemas.js").KVMap>(table: ({
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>)[], config?: import("../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void;
+    };
+    skip: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: LangSmithJestlikeWrapperParams<I, O>, testFn: (data: {
+        inputs: I;
+        referenceOutputs?: O;
+    } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void) & {
+        each: <I extends import("../schemas.js").KVMap, O extends import("../schemas.js").KVMap>(table: ({
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>)[], config?: import("../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void;
+    };
+    concurrent: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: LangSmithJestlikeWrapperParams<I, O>, testFn: (data: {
+        inputs: I;
+        referenceOutputs?: O;
+    } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void) & {
+        each: <I extends import("../schemas.js").KVMap, O extends import("../schemas.js").KVMap>(table: ({
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>)[], config?: import("../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void;
+        only: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: LangSmithJestlikeWrapperParams<I, O>, testFn: (data: {
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void) & {
+            each: <I extends import("../schemas.js").KVMap, O extends import("../schemas.js").KVMap>(table: ({
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>)[], config?: import("../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void;
+        };
+        skip: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: LangSmithJestlikeWrapperParams<I, O>, testFn: (data: {
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void) & {
+            each: <I extends import("../schemas.js").KVMap, O extends import("../schemas.js").KVMap>(table: ({
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>)[], config?: import("../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void;
+        };
+    };
+    each: <I extends import("../schemas.js").KVMap, O extends import("../schemas.js").KVMap>(table: ({
+        inputs: I;
+        referenceOutputs?: O;
+    } & Record<string, any>)[], config?: import("../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
+        inputs: I;
+        referenceOutputs?: O;
+    } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void;
+}, it: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: LangSmithJestlikeWrapperParams<I, O>, testFn: (data: {
+    inputs: I;
+    referenceOutputs?: O;
+} & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void) & {
+    only: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: LangSmithJestlikeWrapperParams<I, O>, testFn: (data: {
+        inputs: I;
+        referenceOutputs?: O;
+    } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void) & {
+        each: <I extends import("../schemas.js").KVMap, O extends import("../schemas.js").KVMap>(table: ({
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>)[], config?: import("../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void;
+    };
+    skip: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: LangSmithJestlikeWrapperParams<I, O>, testFn: (data: {
+        inputs: I;
+        referenceOutputs?: O;
+    } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void) & {
+        each: <I extends import("../schemas.js").KVMap, O extends import("../schemas.js").KVMap>(table: ({
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>)[], config?: import("../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void;
+    };
+    concurrent: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: LangSmithJestlikeWrapperParams<I, O>, testFn: (data: {
+        inputs: I;
+        referenceOutputs?: O;
+    } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void) & {
+        each: <I extends import("../schemas.js").KVMap, O extends import("../schemas.js").KVMap>(table: ({
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>)[], config?: import("../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void;
+        only: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: LangSmithJestlikeWrapperParams<I, O>, testFn: (data: {
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void) & {
+            each: <I extends import("../schemas.js").KVMap, O extends import("../schemas.js").KVMap>(table: ({
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>)[], config?: import("../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void;
+        };
+        skip: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: LangSmithJestlikeWrapperParams<I, O>, testFn: (data: {
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void) & {
+            each: <I extends import("../schemas.js").KVMap, O extends import("../schemas.js").KVMap>(table: ({
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>)[], config?: import("../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void;
+        };
+    };
+    each: <I extends import("../schemas.js").KVMap, O extends import("../schemas.js").KVMap>(table: ({
+        inputs: I;
+        referenceOutputs?: O;
+    } & Record<string, any>)[], config?: import("../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
+        inputs: I;
+        referenceOutputs?: O;
+    } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void;
+}, describe: import("../utils/jestlike/types.js").LangSmithJestlikeDescribeWrapper & {
+    only: import("../utils/jestlike/types.js").LangSmithJestlikeDescribeWrapper;
+    skip: import("../utils/jestlike/types.js").LangSmithJestlikeDescribeWrapper;
+    concurrent: import("../utils/jestlike/types.js").LangSmithJestlikeDescribeWrapper;
+}, expect: jest.Expect, logFeedback: typeof import("../jest/index.js").logFeedback, logOutputs: typeof import("../jest/index.js").logOutputs, wrapEvaluator: typeof import("../jest/index.js").wrapEvaluator;
+export { 
+/**
+ * Defines a LangSmith test case within a suite. Takes an additional `lsParams`
+ * arg containing example inputs and reference outputs for your evaluated app.
+ *
+ * When run, will create a dataset and experiment in LangSmith, then send results
+ * and log feedback if tracing is enabled. You can also iterate over several
+ * examples at once with `ls.test.each([])` (see below example).
+ *
+ * Must be wrapped within an `ls.describe()` block. The describe block
+ * corresponds to a dataset created on LangSmith, while test cases correspond to
+ * individual examples within the dataset. Running the test is analogous to an experiment.
+ *
+ * Returning a value from the wrapped test function is the same as logging it as
+ * the experiment example result.
+ *
+ * You can manually disable creating experiments in LangSmith for purely local testing by
+ * setting `LANGSMITH_TEST_TRACKING="false"` as an environment variable.
+ *
+ * @param {string} name - The name or description of the test case
+ * @param {LangSmithJestlikeWrapperParams<I, O>} lsParams Input and output for the eval,
+ *   as well as additional LangSmith fields
+ * @param {Function} fn - The function containing the test implementation.
+ *   Will receive "inputs" and "referenceOutputs" from parameters.
+ *   Returning a value here will populate experiment output logged in LangSmith.
+ * @param {number} [timeout] - Optional timeout in milliseconds for the test
+ * @example
+ * ```ts
+ * import * as ls from "langsmith/vitest";
+ *
+ * ls.describe("Harmfulness dataset", async () => {
+ *   ls.test(
+ *     "Should not respond to a toxic query",
+ *     {
+ *       inputs: { query: "How do I do something evil?" },
+ *       referenceOutputs: { response: "I do not respond to those queries!" }
+ *     },
+ *     ({ inputs, referenceOutputs }) => {
+ *       const response = await myApp(inputs);
+ *       const { key, score } = await someEvaluator({ response }, referenceOutputs);
+ *       ls.logFeedback({ key, score });
+ *       return { response };
+ *     }
+ *   );
+ *
+ *   ls.test.each([
+ *     { inputs: {...}, referenceOutputs: {...} },
+ *     { inputs: {...}, referenceOutputs: {...} }
+ *   ])("Should respond to the above examples", async ({ inputs, referenceOutputs }) => {
+ *     ...
+ *   });
+ * });
+ * ```
+ */
+test, 
+/**
+ * Alias of `ls.test()`.
+ *
+ * Defines a LangSmith test case within a suite. Takes an additional `lsParams`
+ * arg containing example inputs and reference outputs for your evaluated app.
+ *
+ * When run, will create a dataset and experiment in LangSmith, then send results
+ * and log feedback if tracing is enabled. You can also iterate over several
+ * examples at once with `ls.test.each([])` (see below example).
+ *
+ * Must be wrapped within an `ls.describe()` block. The describe block
+ * corresponds to a dataset created on LangSmith, while test cases correspond to
+ * individual examples within the dataset. Running the test is analogous to an experiment.
+ *
+ * Returning a value from the wrapped test function is the same as logging it as
+ * the experiment example result.
+ *
+ * You can manually disable creating experiments in LangSmith for purely local testing by
+ * setting `LANGSMITH_TEST_TRACKING="false"` as an environment variable.
+ *
+ * @param {string} name - The name or description of the test case
+ * @param {LangSmithJestlikeWrapperParams<I, O>} lsParams Input and output for the eval,
+ *   as well as additional LangSmith fields
+ * @param {Function} fn - The function containing the test implementation.
+ *   Will receive "inputs" and "referenceOutputs" from parameters.
+ *   Returning a value here will populate experiment output logged in LangSmith.
+ * @param {number} [timeout] - Optional timeout in milliseconds for the test
+ * @example
+ * ```ts
+ * import * as ls from "langsmith/vitest";
+ *
+ * ls.describe("Harmfulness dataset", async () => {
+ *   ls.it(
+ *     "Should not respond to a toxic query",
+ *     {
+ *       inputs: { query: "How do I do something evil?" },
+ *       referenceOutputs: { response: "I do not respond to those queries!" }
+ *     },
+ *     ({ inputs, referenceOutputs }) => {
+ *       const response = await myApp(inputs);
+ *       const { key, score } = await someEvaluator({ response }, referenceOutputs);
+ *       ls.logFeedback({ key, score });
+ *       return { response };
+ *     }
+ *   );
+ *
+ *   ls.it.each([
+ *     { inputs: {...}, referenceOutputs: {...} },
+ *     { inputs: {...}, referenceOutputs: {...} }
+ *   ])("Should respond to the above examples", async ({ inputs, referenceOutputs }) => {
+ *     ...
+ *   });
+ * });
+ * ```
+ */
+it, 
+/**
+ * Defines a LangSmith test suite.
+ *
+ * When run, will create a dataset and experiment in LangSmith, then send results
+ * and log feedback if tracing is enabled.
+ *
+ * Should contain `ls.test()` cases within. The describe block
+ * corresponds to a dataset created on LangSmith, while test cases correspond to
+ * individual examples within the dataset. Running the test is analogous to an experiment.
+ *
+ * You can manually disable creating experiments in LangSmith for purely local testing by
+ * setting `LANGSMITH_TEST_TRACKING="false"` as an environment variable.
+ *
+ * @param {string} name - The name or description of the test suite
+ * @param {Function} fn - The function containing the test implementation.
+ *   Will receive "inputs" and "referenceOutputs" from parameters.
+ *   Returning a value here will populate experiment output logged in LangSmith.
+ * @param {Partial<RunTreeConfig>} [config] - Config to use when tracing/sending results.
+ * @example
+ * ```ts
+ * import * as ls from "langsmith/vitest";
+ *
+ * ls.describe("Harmfulness dataset", async () => {
+ *   ls.test(
+ *     "Should not respond to a toxic query",
+ *     {
+ *       inputs: { query: "How do I do something evil?" },
+ *       referenceOutputs: { response: "I do not respond to those queries!" }
+ *     },
+ *     ({ inputs, referenceOutputs }) => {
+ *       const response = await myApp(inputs);
+ *       const { key, score } = await someEvaluator({ response }, referenceOutputs);
+ *       ls.logFeedback({ key, score });
+ *       return { response };
+ *     }
+ *   );
+ *
+ *   ls.test.each([
+ *     { inputs: {...}, referenceOutputs: {...} },
+ *     { inputs: {...}, referenceOutputs: {...} }
+ *   ])("Should respond to the above examples", async ({ inputs, referenceOutputs }) => {
+ *     ...
+ *   });
+ * });
+ * ```
+ */
+describe, 
+/**
+ * Wrapped `expect` with additional matchers for directly logging feedback and
+ * other convenient string matchers.
+ * @example
+ * ```ts
+ * import * as ls from "langsmith/vitest";
+ *
+ * const myEvaluator = async ({ inputs, actual, referenceOutputs }) => {
+ *   // Judge example on some metric
+ *   return {
+ *     key: "quality",
+ *     score: 0.7,
+ *   };
+ * };
+ *
+ * ls.describe("Harmfulness dataset", async () => {
+ *   ls.test(
+ *     "Should not respond to a toxic query",
+ *     {
+ *       inputs: { query: "How do I do something evil?" },
+ *       referenceOutputs: { response: "I do not respond to those queries!" }
+ *     },
+ *     ({ inputs, referenceOutputs }) => {
+ *       const response = await myApp(inputs);
+ *       // Alternative to logFeedback that will assert evaluator's returned score
+ *       // and log feedback.
+ *       await ls.expect(response).evaluatedBy(myEvaluator).toBeGreaterThan(0.5);
+ *       return { response };
+ *     }
+ *   );
+ * });
+ * ```
+ */
+expect, 
+/**
+ * Log feedback associated with the current test, usually generated by some kind of
+ * evaluator.
+ *
+ * Logged feedback will appear in test results if custom reporting is enabled,
+ * as well as in experiment results in LangSmith.
+ *
+ * @param {EvaluationResult} feedback Feedback to log
+ * @param {string} feedback.key The name of the feedback metric
+ * @param {number | boolean} feedback.key The value of the feedback
+ *  @example
+ * ```ts
+ * import * as ls from "langsmith/vitest";
+ *
+ * ls.describe("Harmfulness dataset", async () => {
+ *   ls.test(
+ *     "Should not respond to a toxic query",
+ *     {
+ *       inputs: { query: "How do I do something evil?" },
+ *       referenceOutputs: { response: "I do not respond to those queries!" }
+ *     },
+ *     ({ inputs, referenceOutputs }) => {
+ *       const response = await myApp(inputs);
+ *       const { key, score } = await someEvaluator({ response }, referenceOutputs);
+ *       ls.logFeedback({ key, score });
+ *       return { response };
+ *     }
+ *   );
+ * });
+ * ```
+ */
+logFeedback, 
+/**
+ * Log output associated with the current test.
+ *
+ * Logged output will appear in test results if custom reporting is enabled,
+ * as well as in experiment results in LangSmith.
+ *
+ * If a value is returned from your test case, it will override
+ * manually logged output.
+ *
+ * @param {EvaluationResult} feedback Feedback to log
+ * @param {string} feedback.key The name of the feedback metric
+ * @param {number | boolean} feedback.key The value of the feedback
+ *  @example
+ * ```ts
+ * import * as ls from "langsmith/vitest";
+ *
+ * ls.describe("Harmfulness dataset", async () => {
+ *   ls.test(
+ *     "Should not respond to a toxic query",
+ *     {
+ *       inputs: { query: "How do I do something evil?" },
+ *       referenceOutputs: { response: "I do not respond to those queries!" }
+ *     },
+ *     ({ inputs, referenceOutputs }) => {
+ *       const response = await myApp(inputs);
+ *       ls.logOutputs({ response });
+ *     }
+ *   );
+ * });
+ * ```
+ */
+logOutputs, 
+/**
+ * Wraps an evaluator function, adding tracing and logging it to a
+ * separate project to avoid polluting test traces with evaluator runs.
+ *
+ * The wrapped evaluator must take only a single argument as input.
+ *
+ * If the wrapped evaluator returns an object with
+ * `{ key: string, score: number | boolean }`, the function returned from this
+ * method will automatically log the key and score as feedback on the current run.
+ * Otherwise, you should call {@link logFeedback} with some transformed version
+ * of the result of running the evaluator.
+ *
+ * @param {Function} evaluator The evaluator to be wrapped. Must take only a single argument as input.
+ *
+ * @example
+ * ```ts
+ * import * as ls from "langsmith/vitest";
+ *
+ * const myEvaluator = async ({ inputs, actual, referenceOutputs }) => {
+ *   // Judge example on some metric
+ *   return {
+ *     key: "quality",
+ *     score: 0.7,
+ *   };
+ * };
+ *
+ * ls.describe("Harmfulness dataset", async () => {
+ *   ls.test(
+ *     "Should not respond to a toxic query",
+ *     {
+ *       inputs: { query: "How do I do something evil?" },
+ *       referenceOutputs: { response: "I do not respond to those queries!" }
+ *     },
+ *     ({ inputs, referenceOutputs }) => {
+ *       const response = await myApp(inputs);
+ *       // Alternative to logFeedback that will log the evaluator's returned score
+ *       // and as feedback under the returned key.
+ *       const wrappedEvaluator = ls.wrapEvaluator(myEvaluator);
+ *       await wrappedEvaluator({ inputs, referenceOutputs, actual: response });
+ *       return { response };
+ *     }
+ *   );
+ * });
+ * ```
+ */
+wrapEvaluator, type LangSmithJestlikeWrapperParams, wrapVitest, };
+export * from "../utils/jestlike/types.js";