@nocobase/plugin-ai 1.9.32 → 1.9.34

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/vitest/index.js

@@ -1,22 +1,23 @@
 /* eslint-disable import/no-extraneous-dependencies */
 /* eslint-disable @typescript-eslint/no-namespace */
-import { expect as vitestExpect, test as vitestTest, describe as vitestDescribe, beforeAll as vitestBeforeAll, afterAll as vitestAfterAll, } from "vitest";
+import { expect as vitestExpect, test as vitestTest, it as vitestIt, describe as vitestDescribe, beforeAll as vitestBeforeAll, afterAll as vitestAfterAll, beforeEach as vitestBeforeEach, afterEach as vitestAfterEach, } from "vitest";
 import { toBeRelativeCloseTo, toBeAbsoluteCloseTo, toBeSemanticCloseTo, } from "../utils/jestlike/matchers.js";
-import { wrapEvaluator } from "../utils/jestlike/vendor/evaluatedBy.js";
-import { logFeedback, logOutputs } from "../utils/jestlike/index.js";
-import { generateWrapperFromJestlikeMethods } from "../utils/jestlike/index.js";
+import { wrapVitest } from "./utils/wrapper.js";
 vitestExpect.extend({
     toBeRelativeCloseTo,
     toBeAbsoluteCloseTo,
     toBeSemanticCloseTo,
 });
-const { test, it, describe, expect } = generateWrapperFromJestlikeMethods({
+const { test, it, describe, expect, logFeedback, logOutputs, wrapEvaluator } = wrapVitest({
     expect: vitestExpect,
+    it: vitestIt,
     test: vitestTest,
     describe: vitestDescribe,
     beforeAll: vitestBeforeAll,
     afterAll: vitestAfterAll,
-}, "vitest");
+    beforeEach: vitestBeforeEach,
+    afterEach: vitestAfterEach,
+});
 export { 
 /**
  * Defines a LangSmith test case within a suite. Takes an additional `lsParams`
@@ -318,5 +319,5 @@ logOutputs,
  * });
  * ```
  */
-wrapEvaluator, };
+wrapEvaluator, wrapVitest, };
 export * from "../utils/jestlike/types.js";

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/vitest/index.mjs

@@ -0,0 +1,324 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import { toBeRelativeCloseTo, toBeAbsoluteCloseTo, toBeSemanticCloseTo, } from "../utils/jestlike/matchers.js";
+import { wrapVitest } from "./utils/wrapper.js";
+import { importVitestModule } from "./utils/esm.mjs";
+const vitestModule = await importVitestModule();
+const { expect: vitestExpect, test: vitestTest, it: vitestIt, describe: vitestDescribe, beforeAll: vitestBeforeAll, afterAll: vitestAfterAll, beforeEach: vitestBeforeEach, afterEach: vitestAfterEach, } = vitestModule;
+vitestExpect.extend({
+    toBeRelativeCloseTo,
+    toBeAbsoluteCloseTo,
+    toBeSemanticCloseTo,
+});
+const { test, it, describe, expect, logFeedback, logOutputs, wrapEvaluator } = wrapVitest({
+    expect: vitestExpect,
+    it: vitestIt,
+    test: vitestTest,
+    describe: vitestDescribe,
+    beforeAll: vitestBeforeAll,
+    afterAll: vitestAfterAll,
+    beforeEach: vitestBeforeEach,
+    afterEach: vitestAfterEach,
+});
+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, wrapVitest, };
+export * from "../utils/jestlike/types.js";

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/vitest/reporter.cjs

@@ -4,26 +4,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // 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
 const reporters_1 = require("vitest/reporters");
-const reporter_js_1 = require("../utils/jestlike/reporter.cjs");
+const reporter_js_1 = require("./utils/reporter.cjs");
 class LangSmithEvalReporter extends reporters_1.DefaultReporter {
     async onFinished(files, errors) {
         super.onFinished(files, errors);
-        for (const file of files) {
-            for (const task of file.tasks) {
-                const testModule = this.ctx.state.getReportedEntity(task);
-                const tests = [...testModule.children.allTests()].map((test) => {
-                    return {
-                        title: test.name,
-                        status: test.result()?.state ?? "skipped",
-                        duration: Math.round(test.diagnostic()?.duration ?? 0),
-                    };
-                });
-                const result = ["pass", "fail", "skip"].includes(task.result?.state ?? "")
-                    ? task.result?.state
-                    : "skip";
-                await (0, reporter_js_1.printReporterTable)(task.name, tests, result);
-            }
-        }
+        await (0, reporter_js_1.printVitestReporterTable)(files, this.ctx);
     }
 }
 exports.default = LangSmithEvalReporter;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/vitest/reporter.d.mts

@@ -0,0 +1,5 @@
+declare const DefaultReporter: any;
+declare class LangSmithEvalReporter extends DefaultReporter {
+    onFinished(files: unknown[], errors: unknown[]): Promise<void>;
+}
+export default LangSmithEvalReporter;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/vitest/reporter.js

@@ -2,26 +2,11 @@
 // 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 { printReporterTable } from "../utils/jestlike/reporter.js";
+import { printVitestReporterTable } from "./utils/reporter.js";
 class LangSmithEvalReporter extends DefaultReporter {
     async onFinished(files, errors) {
         super.onFinished(files, errors);
-        for (const file of files) {
-            for (const task of file.tasks) {
-                const testModule = this.ctx.state.getReportedEntity(task);
-                const tests = [...testModule.children.allTests()].map((test) => {
-                    return {
-                        title: test.name,
-                        status: test.result()?.state ?? "skipped",
-                        duration: Math.round(test.diagnostic()?.duration ?? 0),
-                    };
-                });
-                const result = ["pass", "fail", "skip"].includes(task.result?.state ?? "")
-                    ? task.result?.state
-                    : "skip";
-                await printReporterTable(task.name, tests, result);
-            }
-        }
+        await printVitestReporterTable(files, this.ctx);
     }
 }
 export default LangSmithEvalReporter;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/vitest/reporter.mjs

@@ -0,0 +1,12 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import { printVitestReporterTable } from "./utils/reporter.js";
+import { importVitestModule } from "./utils/esm.mjs";
+const vitestReporters = await importVitestModule("reporters");
+const DefaultReporter = vitestReporters.DefaultReporter;
+class LangSmithEvalReporter extends DefaultReporter {
+    async onFinished(files, errors) {
+        super.onFinished(files, errors);
+        await printVitestReporterTable(files, this.ctx);
+    }
+}
+export default LangSmithEvalReporter;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/vitest/utils/esm.d.mts

@@ -0,0 +1,8 @@
+/**
+ * Resolve vitest ESM module from correct workspace
+ * This is necessary for monorepos where langsmith is hoisted to
+ * the top level of the monorepo but Vitest is not.
+ * This can occur if you have multiple versions of vitest installed in the monorepo
+ * and there is only one shared, hoisted version of langsmith.
+ */
+export declare const importVitestModule: (entrypoint?: string) => Promise<any>;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/vitest/utils/esm.mjs

@@ -0,0 +1,38 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+import { sep } from "path";
+/**
+ * Resolve vitest ESM module from correct workspace
+ * This is necessary for monorepos where langsmith is hoisted to
+ * the top level of the monorepo but Vitest is not.
+ * This can occur if you have multiple versions of vitest installed in the monorepo
+ * and there is only one shared, hoisted version of langsmith.
+ */
+export const importVitestModule = async (entrypoint) => {
+    let importedModule;
+    try {
+        const require = createRequire(import.meta.url);
+        // Find the package.json to get the correct ESM entry point
+        const packagePath = require.resolve(`vitest/package.json`, {
+            paths: [process.cwd()],
+        });
+        const pkg = require(packagePath);
+        const pkgDir = packagePath.replace(`${sep}package.json`, "");
+        const esmEntry = !entrypoint
+            ? pkg.module ?? pkg.exports?.["."]?.import ?? "dist/index.js"
+            : pkg.exports?.[`./${entrypoint}`]?.import ??
+                pkg.exports?.[`./${entrypoint}`]?.default;
+        const modulePath = `${pkgDir}${sep}${esmEntry}`;
+        const path = pathToFileURL(modulePath).href;
+        importedModule = await import(path);
+        if (!importedModule) {
+            throw new Error(`Failed to import vitest entrypoint${entrypoint ? ` ${entrypoint}` : ""}`);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (error) {
+        importedModule = await import(`vitest${entrypoint ? `/${entrypoint}` : ""}`);
+    }
+    return importedModule;
+};

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/vitest/utils/reporter.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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
+const printVitestReporterTable = async (files, ctx) => {
+    for (const file of files) {
+        for (const task of file.tasks) {
+            const testModule = ctx.state.getReportedEntity(task);
+            const tests = [...testModule.children.allTests()].map((test) => {
+                return {
+                    title: test.name,
+                    status: test.result()?.state ?? "skipped",
+                    duration: Math.round(test.diagnostic()?.duration ?? 0),
+                };
+            });
+            const result = ["pass", "fail", "skip"].includes(task.result?.state ?? "")
+                ? task.result?.state
+                : "skip";
+            await (0, reporter_js_1.printReporterTable)(task.name, tests, result);
+        }
+    }
+};
+exports.printVitestReporterTable = printVitestReporterTable;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/vitest/utils/reporter.d.ts

@@ -0,0 +1 @@
+export declare const printVitestReporterTable: (files: any, ctx: any) => Promise<void>;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/vitest/utils/reporter.js

@@ -0,0 +1,21 @@
+import { printReporterTable } from "../../utils/jestlike/reporter.js";
+// Can't use types here because of module resolution issues
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const printVitestReporterTable = async (files, ctx) => {
+    for (const file of files) {
+        for (const task of file.tasks) {
+            const testModule = ctx.state.getReportedEntity(task);
+            const tests = [...testModule.children.allTests()].map((test) => {
+                return {
+                    title: test.name,
+                    status: test.result()?.state ?? "skipped",
+                    duration: Math.round(test.diagnostic()?.duration ?? 0),
+                };
+            });
+            const result = ["pass", "fail", "skip"].includes(task.result?.state ?? "")
+                ? task.result?.state
+                : "skip";
+            await printReporterTable(task.name, tests, result);
+        }
+    }
+};

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/vitest/utils/wrapper.cjs

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapVitest = void 0;
+const index_js_1 = require("../../utils/jestlike/index.cjs");
+const index_js_2 = require("../../utils/jestlike/index.cjs");
+const evaluatedBy_js_1 = require("../../utils/jestlike/vendor/evaluatedBy.cjs");
+/**
+ * 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_1.generateWrapperFromJestlikeMethods)({
+        expect: originalVitestMethods.expect,
+        it: originalVitestMethods.it,
+        test: originalVitestMethods.test,
+        describe: originalVitestMethods.describe,
+        beforeAll: originalVitestMethods.beforeAll,
+        afterAll: originalVitestMethods.afterAll,
+    }, "vitest");
+    return {
+        ...wrappedMethods,
+        logFeedback: index_js_2.logFeedback,
+        logOutputs: index_js_2.logOutputs,
+        wrapEvaluator: evaluatedBy_js_1.wrapEvaluator,
+    };
+};
+exports.wrapVitest = wrapVitest;