@nocobase/plugin-ai 1.9.33 → 1.9.34

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/utils/jestlike/index.cjs

@@ -17,13 +17,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
@@ -31,7 +41,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapEvaluator = exports.isInTestContext = exports.generateWrapperFromJestlikeMethods = exports._objectHash = exports.logOutputs = exports.logFeedback = void 0;
+exports.wrapEvaluator = void 0;
+exports.logFeedback = logFeedback;
+exports.logOutputs = logOutputs;
+exports._objectHash = _objectHash;
+exports.generateWrapperFromJestlikeMethods = generateWrapperFromJestlikeMethods;
+exports.isInTestContext = isInTestContext;
 const crypto_1 = __importDefault(require("crypto"));
 const uuid_1 = require("uuid");
 const os = __importStar(require("node:os"));
@@ -64,11 +79,10 @@ function logFeedback(feedback, config) {
         exampleId: context.currentExample.id,
         feedback: feedback,
         context,
-        runTree: (0, globals_js_1.trackingEnabled)(context) ? (0, traceable_js_1.getCurrentRunTree)() : undefined,
+        runTree: context.testRootRunTree,
         client: context.client,
     });
 }
-exports.logFeedback = logFeedback;
 function logOutputs(output) {
     const context = globals_js_1.testWrapperAsyncLocalStorageInstance.getStore();
     if (context === undefined) {
@@ -83,7 +97,6 @@ function logOutputs(output) {
     }
     context.setLoggedOutput(output);
 }
-exports.logOutputs = logOutputs;
 function _objectHash(obj, depth = 0) {
     // Prevent infinite recursion
     if (depth > 50) {
@@ -106,7 +119,6 @@ function _objectHash(obj, depth = 0) {
         .update(JSON.stringify(obj ?? null))
         .digest("hex"));
 }
-exports._objectHash = _objectHash;
 function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
     const { expect, test, describe, beforeAll, afterAll } = methods;
     async function _createProject(client, datasetId, projectConfig) {
@@ -137,7 +149,10 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
             " Please try again.");
     }
     const datasetSetupInfo = new Map();
-    function getExampleId(datasetId, inputs, outputs) {
+    function getExampleId(datasetId, inputs, outputs, providedId) {
+        if (providedId) {
+            return providedId;
+        }
         const identifier = JSON.stringify({
             datasetId,
             inputsHash: _objectHash(inputs),
@@ -146,17 +161,29 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
         return (0, uuid_1.v5)(identifier, constants_js_1.UUID5_NAMESPACE);
     }
     async function syncExample(params) {
-        const { client, exampleId, inputs, outputs, metadata, createdAt, datasetId, } = params;
+        const { client, exampleId, inputs, outputs, metadata, split, createdAt, datasetId, } = params;
         let example;
         try {
             example = await client.readExample(exampleId);
+            const normalizedSplit = split
+                ? typeof split === "string"
+                    ? [split]
+                    : split
+                : undefined;
+            const { dataset_split, ...restMetadata } = example.metadata ?? {};
             if (_objectHash(example.inputs) !== _objectHash(inputs) ||
                 _objectHash(example.outputs ?? {}) !== _objectHash(outputs ?? {}) ||
-                example.dataset_id !== datasetId) {
+                example.dataset_id !== datasetId ||
+                (normalizedSplit !== undefined &&
+                    _objectHash(dataset_split ?? []) !==
+                        _objectHash(normalizedSplit ?? [])) ||
+                (metadata !== undefined &&
+                    _objectHash(restMetadata ?? {}) !== _objectHash(metadata ?? {}))) {
                 await client.updateExample(exampleId, {
                     inputs,
                     outputs,
                     metadata,
+                    split,
                     dataset_id: datasetId,
                 });
             }
@@ -167,6 +194,7 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                     exampleId,
                     datasetId,
                     createdAt: new Date(createdAt ?? new Date()),
+                    split,
                     metadata,
                 });
             }
@@ -217,10 +245,27 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
         }
         return storageValue;
     }
-    function wrapDescribeMethod(method) {
+    function wrapDescribeMethod(method, methodName) {
+        if ((0, env_js_1.isJsDom)()) {
+            console.error(`[LANGSMITH]: You seem to be using a jsdom environment. This is not supported and you may experience unexpected behavior. Please set the "environment" or "testEnvironment" field in your test config file to "node".`);
+        }
         return function (testSuiteName, fn, experimentConfig) {
+            if (typeof method !== "function") {
+                throw new Error(`"${methodName}" is not supported by your test runner.`);
+            }
+            if (globals_js_1.testWrapperAsyncLocalStorageInstance.getStore() !== undefined) {
+                throw new Error([
+                    `You seem to be nesting an ls.describe block named "${testSuiteName}" inside another ls.describe block.`,
+                    "This is not supported because each ls.describe block corresponds to a LangSmith dataset.",
+                    "To logically group tests, nest the native Jest or Vitest describe methods instead.",
+                ].join("\n"));
+            }
             const client = experimentConfig?.client ?? globals_js_1.DEFAULT_TEST_CLIENT;
             const suiteName = experimentConfig?.testSuiteName ?? testSuiteName;
+            let setupPromiseResolver;
+            const setupPromise = new Promise((resolve) => {
+                setupPromiseResolver = resolve;
+            });
             return method(suiteName, () => {
                 const startTime = new Date();
                 const suiteUuid = (0, uuid_1.v4)();
@@ -254,10 +299,12 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                         metadata: suiteMetadata,
                     },
                     enableTestTracking: experimentConfig?.enableTestTracking,
+                    setupPromise,
                 };
                 beforeAll(async () => {
                     const storageValue = await runDatasetSetup(context);
                     datasetSetupInfo.set(suiteUuid, storageValue);
+                    setupPromiseResolver();
                 });
                 afterAll(async () => {
                     await Promise.all([
@@ -277,11 +324,22 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                     let commit;
                     let dirty;
                     try {
-                        branch = (0, child_process_1.execSync)("git rev-parse --abbrev-ref HEAD")
+                        branch = (0, child_process_1.execSync)("git rev-parse --abbrev-ref HEAD", {
+                            stdio: ["ignore", "pipe", "ignore"],
+                        })
+                            .toString()
+                            .trim();
+                        commit = (0, child_process_1.execSync)("git rev-parse HEAD", {
+                            stdio: ["ignore", "pipe", "ignore"],
+                        })
                             .toString()
                             .trim();
-                        commit = (0, child_process_1.execSync)("git rev-parse HEAD").toString().trim();
-                        dirty = (0, child_process_1.execSync)("git status --porcelain").toString().trim() !== "";
+                        dirty =
+                            (0, child_process_1.execSync)("git status --porcelain", {
+                                stdio: ["ignore", "pipe", "ignore"],
+                            })
+                                .toString()
+                                .trim() !== "";
                     }
                     catch {
                         return;
@@ -338,9 +396,10 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
             });
         };
     }
-    const lsDescribe = Object.assign(wrapDescribeMethod(describe), {
-        only: wrapDescribeMethod(describe.only),
-        skip: wrapDescribeMethod(describe.skip),
+    const lsDescribe = Object.assign(wrapDescribeMethod(describe, "describe"), {
+        only: wrapDescribeMethod(describe.only, "describe.only"),
+        skip: wrapDescribeMethod(describe.skip, "describe.skip"),
+        concurrent: wrapDescribeMethod(describe.concurrent, "describe.concurrent"),
     });
     function wrapTestMethod(method) {
         return function (name, lsParams, testFn, timeout) {
@@ -352,14 +411,23 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                 lsParams.config?.enableTestTracking !== undefined) {
                 context.enableTestTracking = lsParams.config.enableTestTracking;
             }
-            const { config, inputs, referenceOutputs, ...rest } = lsParams;
-            const totalRuns = config?.iterations ?? 1;
+            const { id, config, inputs, split, metadata, ...rest } = lsParams;
+            let referenceOutputs = rest.referenceOutputs;
+            if (!referenceOutputs && "outputs" in rest) {
+                referenceOutputs = rest.outputs;
+            }
+            const totalRuns = config?.repetitions ?? config?.iterations ?? 1;
             for (let i = 0; i < totalRuns; i += 1) {
                 const testUuid = (0, uuid_1.v4)().replace(/-/g, "").slice(0, 13);
                 // Jest will not group tests under the same "describe" group if you await the test and
                 // total runs is greater than 1.
                 const resultsPath = path.join(os.tmpdir(), "langsmith_test_results", `${testUuid}.json`);
-                void method(`${name}${totalRuns > 1 ? `, run ${i}` : ""}${constants_js_1.TEST_ID_DELIMITER}${testUuid}`, async () => {
+                void method(`${name}${totalRuns > 1 ? `, run ${i}` : ""}${constants_js_1.TEST_ID_DELIMITER}${testUuid}`, async (...args) => {
+                    // Jest will magically introspect args and pass a "done" callback if
+                    // we use a non-spread parameter. To obtain and pass Vitest test context
+                    // through into the test function, we must therefore refer to Vitest
+                    // args using this signature
+                    const jestlikeArgs = args[0];
                     if (context === undefined) {
                         throw new Error([
                             `Could not retrieve test context.`,
@@ -367,6 +435,11 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                             `See this page for more information: https://docs.smith.langchain.com/evaluation/how_to_guides/vitest_jest`,
                         ].join("\n"));
                     }
+                    // Jest .concurrent is super buggy and doesn't wait for beforeAll to complete
+                    // before running test functions, so we need to wait for the setup promise
+                    // to resolve before we can continue.
+                    // Seee https://github.com/jestjs/jest/issues/4281
+                    await context.setupPromise;
                     if (!datasetSetupInfo.get(context.suiteUuid)) {
                         throw new Error("Dataset failed to initialize. Please check your LangSmith environment variables.");
                     }
@@ -384,52 +457,69 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                     };
                     let exampleId;
                     const runTestFn = async () => {
-                        const testContext = globals_js_1.testWrapperAsyncLocalStorageInstance.getStore();
+                        let testContext = globals_js_1.testWrapperAsyncLocalStorageInstance.getStore();
                         if (testContext === undefined) {
                             throw new Error("Could not identify test context. Please contact us for help.");
                         }
-                        try {
-                            const res = await testFn({
-                                ...rest,
-                                inputs: testInput,
-                                referenceOutputs: testOutput,
-                            });
-                            (0, globals_js_1._logTestFeedback)({
-                                exampleId,
-                                feedback: { key: "pass", score: true },
-                                context: testContext,
-                                runTree: (0, globals_js_1.trackingEnabled)(testContext)
-                                    ? (0, traceable_js_1.getCurrentRunTree)()
-                                    : undefined,
-                                client: testContext.client,
-                            });
-                            if (res != null) {
-                                if (loggedOutput !== undefined) {
-                                    console.warn(`[WARN]: Returned value from test function will override output set by previous "logOutputs()" call.`);
+                        return globals_js_1.testWrapperAsyncLocalStorageInstance.run({
+                            ...testContext,
+                            testRootRunTree: (0, globals_js_1.trackingEnabled)(testContext)
+                                ? (0, traceable_js_1.getCurrentRunTree)()
+                                : undefined,
+                        }, async () => {
+                            testContext = globals_js_1.testWrapperAsyncLocalStorageInstance.getStore();
+                            if (testContext === undefined) {
+                                throw new Error("Could not identify test context after setting test root run tree. Please contact us for help.");
+                            }
+                            try {
+                                const res = await testFn(Object.assign(typeof jestlikeArgs === "object" && jestlikeArgs != null
+                                    ? jestlikeArgs
+                                    : {}, {
+                                    ...rest,
+                                    inputs: testInput,
+                                    referenceOutputs: testOutput,
+                                    testMetadata: {
+                                        exampleId,
+                                        experimentId: project?.id,
+                                        datasetId: dataset?.id,
+                                        testTrackingEnabled: (0, globals_js_1.trackingEnabled)(testContext),
+                                        repetition: i,
+                                        split,
+                                    },
+                                }));
+                                (0, globals_js_1._logTestFeedback)({
+                                    exampleId,
+                                    feedback: { key: "pass", score: true },
+                                    context: testContext,
+                                    runTree: testContext.testRootRunTree,
+                                    client: testContext.client,
+                                });
+                                if (res != null) {
+                                    if (loggedOutput !== undefined) {
+                                        console.warn(`[WARN]: Returned value from test function will override output set by previous "logOutputs()" call.`);
+                                    }
+                                    loggedOutput =
+                                        typeof res === "object"
+                                            ? res
+                                            : { result: res };
                                 }
-                                loggedOutput =
-                                    typeof res === "object"
-                                        ? res
-                                        : { result: res };
+                                return loggedOutput;
                             }
-                            return loggedOutput;
-                        }
-                        catch (e) {
-                            (0, globals_js_1._logTestFeedback)({
-                                exampleId,
-                                feedback: { key: "pass", score: false },
-                                context: testContext,
-                                runTree: (0, globals_js_1.trackingEnabled)(testContext)
-                                    ? (0, traceable_js_1.getCurrentRunTree)()
-                                    : undefined,
-                                client: testContext.client,
-                            });
-                            const rawError = e;
-                            const strippedErrorMessage = e.message.replace(constants_js_1.STRIP_ANSI_REGEX, "");
-                            const langsmithFriendlyError = new Error(strippedErrorMessage);
-                            langsmithFriendlyError.rawJestError = rawError;
-                            throw langsmithFriendlyError;
-                        }
+                            catch (e) {
+                                (0, globals_js_1._logTestFeedback)({
+                                    exampleId,
+                                    feedback: { key: "pass", score: false },
+                                    context: testContext,
+                                    runTree: testContext.testRootRunTree,
+                                    client: testContext.client,
+                                });
+                                const rawError = e;
+                                const strippedErrorMessage = e.message.replace(constants_js_1.STRIP_ANSI_REGEX, "");
+                                const langsmithFriendlyError = new Error(strippedErrorMessage);
+                                langsmithFriendlyError.rawJestError = rawError;
+                                throw langsmithFriendlyError;
+                            }
+                        });
                     };
                     try {
                         if ((0, globals_js_1.trackingEnabled)(context)) {
@@ -448,7 +538,7 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                                     .map((field) => `"${field}"`)
                                     .join(", ")} while syncing to LangSmith. Please contact us for help.`);
                             }
-                            exampleId = getExampleId(dataset.id, inputs, referenceOutputs);
+                            exampleId = getExampleId(dataset.id, inputs, referenceOutputs, id);
                             // TODO: Create or update the example in the background
                             // Currently run end time has to be after example modified time
                             // for examples to render properly, so we must modify the example
@@ -460,7 +550,8 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                                     datasetId: dataset.id,
                                     inputs,
                                     outputs: referenceOutputs ?? {},
-                                    metadata: {},
+                                    metadata,
+                                    split,
                                     createdAt,
                                 }));
                             }
@@ -560,6 +651,16 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
         }
         return eachMethod;
     }
+    // Roughly mirrors: https://jestjs.io/docs/api#methods
+    const concurrentMethod = Object.assign(wrapTestMethod(test.concurrent), {
+        each: createEachMethod(test.concurrent),
+        only: Object.assign(wrapTestMethod(test.concurrent.only), {
+            each: createEachMethod(test.concurrent.only),
+        }),
+        skip: Object.assign(wrapTestMethod(test.concurrent.skip), {
+            each: createEachMethod(test.concurrent.skip),
+        }),
+    });
     const lsTest = Object.assign(wrapTestMethod(test), {
         only: Object.assign(wrapTestMethod(test.only), {
             each: createEachMethod(test.only),
@@ -567,6 +668,7 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
         skip: Object.assign(wrapTestMethod(test.skip), {
             each: createEachMethod(test.skip),
         }),
+        concurrent: concurrentMethod,
         each: createEachMethod(test),
     });
     const wrappedExpect = (0, chain_js_1.wrapExpect)(expect);
@@ -580,12 +682,10 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
         toBeSemanticCloseTo: matchers_js_1.toBeSemanticCloseTo,
     };
 }
-exports.generateWrapperFromJestlikeMethods = generateWrapperFromJestlikeMethods;
 function isInTestContext() {
     const context = globals_js_1.testWrapperAsyncLocalStorageInstance.getStore();
     return context !== undefined;
 }
-exports.isInTestContext = isInTestContext;
 var evaluatedBy_js_1 = require("./vendor/evaluatedBy.cjs");
 Object.defineProperty(exports, "wrapEvaluator", { enumerable: true, get: function () { return evaluatedBy_js_1.wrapEvaluator; } });
 __exportStar(require("./types.cjs"), exports);

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/utils/jestlike/index.d.ts

@@ -1,89 +1,101 @@
-/// <reference types="jest" />
 import { KVMap } from "../../schemas.js";
 import { toBeRelativeCloseTo, toBeAbsoluteCloseTo, toBeSemanticCloseTo } from "./matchers.js";
 import { SimpleEvaluationResult } from "./types.js";
-import type { LangSmithJestlikeWrapperConfig, LangSmithJestlikeWrapperParams, LangSmithJestlikeDescribeWrapper } from "./types.js";
+import type { LangSmithJestlikeWrapperConfig, LangSmithJestlikeWrapperParams, LangSmithJestlikeDescribeWrapper, LangSmithJestlikeTestFunction } from "./types.js";
 export declare function logFeedback(feedback: SimpleEvaluationResult, config?: {
     sourceRunId?: string;
 }): void;
 export declare function logOutputs(output: Record<string, unknown>): void;
-export declare function _objectHash(obj: KVMap, depth?: number): string;
+export declare function _objectHash(obj: KVMap | unknown[], depth?: number): string;
 export declare function generateWrapperFromJestlikeMethods(methods: Record<string, any>, testRunnerName: string): {
-    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_1 extends KVMap, O_1 extends KVMap>(table: ({
-                inputs: I_1;
-                referenceOutputs?: O_1 | undefined;
-            } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
-                inputs: I_1;
-                referenceOutputs?: O_1 | undefined;
-            } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void;
+    test: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: LangSmithJestlikeWrapperParams<I, O>, testFn: LangSmithJestlikeTestFunction<I, O>, 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: LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+            each: <I extends KVMap, O extends KVMap>(table: ({
+                id?: string;
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: LangSmithJestlikeTestFunction<I, O>, 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_1 extends KVMap, O_1 extends KVMap>(table: ({
-                inputs: I_1;
-                referenceOutputs?: O_1 | undefined;
-            } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
-                inputs: I_1;
-                referenceOutputs?: O_1 | undefined;
-            } & 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: LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+            each: <I extends KVMap, O extends KVMap>(table: ({
+                id?: string;
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void;
         };
-        each: <I_1 extends KVMap, O_1 extends KVMap>(table: ({
-            inputs: I_1;
-            referenceOutputs?: O_1 | undefined;
-        } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
-            inputs: I_1;
-            referenceOutputs?: O_1 | undefined;
-        } & 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: {
+        concurrent: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: LangSmithJestlikeWrapperParams<I, O>, testFn: LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+            each: <I extends KVMap, O extends KVMap>(table: ({
+                id?: string;
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: LangSmithJestlikeTestFunction<I, O>, 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: LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+                each: <I extends KVMap, O extends KVMap>(table: ({
+                    id?: string;
+                    inputs: I;
+                    referenceOutputs?: O;
+                } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: LangSmithJestlikeTestFunction<I, O>, 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: LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+                each: <I extends KVMap, O extends KVMap>(table: ({
+                    id?: string;
+                    inputs: I;
+                    referenceOutputs?: O;
+                } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void;
+            };
+        };
+        each: <I extends KVMap, O extends KVMap>(table: ({
+            id?: string;
             inputs: I;
             referenceOutputs?: O;
-        } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void) & {
-            each: <I_1 extends KVMap, O_1 extends KVMap>(table: ({
-                inputs: I_1;
-                referenceOutputs?: O_1 | undefined;
-            } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
-                inputs: I_1;
-                referenceOutputs?: O_1 | undefined;
-            } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void;
+        } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: LangSmithJestlikeTestFunction<I, O>, 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: LangSmithJestlikeTestFunction<I, O>, 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: LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+            each: <I extends KVMap, O extends KVMap>(table: ({
+                id?: string;
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: LangSmithJestlikeTestFunction<I, O>, 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: LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+            each: <I extends KVMap, O extends KVMap>(table: ({
+                id?: string;
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: LangSmithJestlikeTestFunction<I, O>, 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: {
+        concurrent: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: LangSmithJestlikeWrapperParams<I, O>, testFn: LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+            each: <I extends KVMap, O extends KVMap>(table: ({
+                id?: string;
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: LangSmithJestlikeTestFunction<I, O>, 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: LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+                each: <I extends KVMap, O extends KVMap>(table: ({
+                    id?: string;
+                    inputs: I;
+                    referenceOutputs?: O;
+                } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: LangSmithJestlikeTestFunction<I, O>, 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: LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+                each: <I extends KVMap, O extends KVMap>(table: ({
+                    id?: string;
+                    inputs: I;
+                    referenceOutputs?: O;
+                } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void;
+            };
+        };
+        each: <I extends KVMap, O extends KVMap>(table: ({
+            id?: string;
             inputs: I;
             referenceOutputs?: O;
-        } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void) & {
-            each: <I_1 extends KVMap, O_1 extends KVMap>(table: ({
-                inputs: I_1;
-                referenceOutputs?: O_1 | undefined;
-            } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
-                inputs: I_1;
-                referenceOutputs?: O_1 | undefined;
-            } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void;
-        };
-        each: <I_1 extends KVMap, O_1 extends KVMap>(table: ({
-            inputs: I_1;
-            referenceOutputs?: O_1 | undefined;
-        } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: (params: {
-            inputs: I_1;
-            referenceOutputs?: O_1 | undefined;
-        } & Record<string, any>) => unknown | Promise<unknown>, timeout?: number) => void;
+        } & Record<string, any>)[], config?: LangSmithJestlikeWrapperConfig) => (name: string, fn: LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void;
     };
     describe: LangSmithJestlikeDescribeWrapper & {
         only: LangSmithJestlikeDescribeWrapper;
         skip: LangSmithJestlikeDescribeWrapper;
+        concurrent: LangSmithJestlikeDescribeWrapper;
     };
     expect: jest.Expect;
     toBeRelativeCloseTo: typeof toBeRelativeCloseTo;