langsmith 0.2.14-rc.6 → 0.2.15-beta.0

package/dist/client.cjs

@@ -308,6 +308,12 @@ class Client {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "manualFlushMode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         const defaultConfig = Client.getDefaultClientConfig();
         this.tracingSampleRate = getTracingSamplingRate();
         this.apiUrl = trimQuotes(config.apiUrl ?? defaultConfig.apiUrl) ?? "";
@@ -341,6 +347,7 @@ class Client {
             config.blockOnRootRunFinalization ?? this.blockOnRootRunFinalization;
         this.batchSizeBytesLimit = config.batchSizeBytesLimit;
         this.fetchOptions = config.fetchOptions || {};
+        this.manualFlushMode = config.manualFlushMode ?? this.manualFlushMode;
     }
     static getDefaultClientConfig() {
         const apiKey = (0, env_js_1.getLangSmithEnvironmentVariable)("API_KEY");
@@ -538,14 +545,17 @@ class Client {
         return (serverInfo.instance_flags?.dataset_examples_multipart_enabled ?? false);
     }
     drainAutoBatchQueue(batchSizeLimit) {
+        const promises = [];
         while (this.autoBatchQueue.items.length > 0) {
             const [batch, done] = this.autoBatchQueue.pop(batchSizeLimit);
             if (!batch.length) {
                 done();
                 break;
             }
-            void this._processBatch(batch, done).catch(console.error);
+            const batchPromise = this._processBatch(batch, done).catch(console.error);
+            promises.push(batchPromise);
         }
+        return Promise.all(promises);
     }
     async _processBatch(batch, done) {
         if (!batch.length) {
@@ -580,14 +590,18 @@ class Client {
             item.item = mergeRuntimeEnvIntoRunCreate(item.item);
         }
         const itemPromise = this.autoBatchQueue.push(item);
+        if (this.manualFlushMode) {
+            // Rely on manual flushing in serverless environments
+            return itemPromise;
+        }
         const sizeLimitBytes = await this._getBatchSizeLimitBytes();
         if (this.autoBatchQueue.sizeBytes > sizeLimitBytes) {
-            this.drainAutoBatchQueue(sizeLimitBytes);
+            void this.drainAutoBatchQueue(sizeLimitBytes);
         }
         if (this.autoBatchQueue.items.length > 0) {
             this.autoBatchTimeout = setTimeout(() => {
                 this.autoBatchTimeout = undefined;
-                this.drainAutoBatchQueue(sizeLimitBytes);
+                void this.drainAutoBatchQueue(sizeLimitBytes);
             }, this.autoBatchAggregationDelayMs);
         }
         return itemPromise;
@@ -629,6 +643,13 @@ class Client {
         }
         return await this.settings;
     }
+    /**
+     * Flushes current queued traces.
+     */
+    async flush() {
+        const sizeLimitBytes = await this._getBatchSizeLimitBytes();
+        await this.drainAutoBatchQueue(sizeLimitBytes);
+    }
     async createRun(run) {
         if (!this._filterForSampling([run]).length) {
             return;
@@ -921,7 +942,8 @@ class Client {
             data.dotted_order !== undefined) {
             if (run.end_time !== undefined &&
                 data.parent_run_id === undefined &&
-                this.blockOnRootRunFinalization) {
+                this.blockOnRootRunFinalization &&
+                !this.manualFlushMode) {
                 // Trigger batches as soon as a root trace ends and wait to ensure trace finishes
                 // in serverless environments.
                 await this.processRunOperation({ action: "update", item: data }).catch(console.error);
@@ -3052,6 +3074,10 @@ class Client {
      * @returns A promise that resolves once all currently pending traces have sent.
      */
     awaitPendingTraceBatches() {
+        if (this.manualFlushMode) {
+            console.warn("[WARNING]: When tracing in manual flush mode, you must call `await client.flush()` manually to submit trace batches.");
+            return Promise.resolve();
+        }
         return Promise.all([
             ...this.autoBatchQueue.items.map(({ itemPromise }) => itemPromise),
             this.batchIngestCaller.queue.onIdle(),

package/dist/client.d.ts

@@ -15,6 +15,11 @@ export interface ClientConfig {
     blockOnRootRunFinalization?: boolean;
     traceBatchConcurrency?: number;
     fetchOptions?: RequestInit;
+    /**
+     * Whether to require manual .flush() calls before sending traces.
+     * Useful if encountering network rate limits at trace high volumes.
+     */
+    manualFlushMode?: boolean;
 }
 /**
  * Represents the parameters for listing runs (spans) from the Langsmith server.
@@ -207,6 +212,7 @@ export declare class Client implements LangSmithTracingClientInterface {
     private traceBatchConcurrency;
     private _serverInfo;
     private _getServerInfoPromise?;
+    private manualFlushMode;
     constructor(config?: ClientConfig);
     static getDefaultClientConfig(): {
         apiUrl: string;
@@ -233,6 +239,10 @@ export declare class Client implements LangSmithTracingClientInterface {
     protected _getServerInfo(): Promise<any>;
     protected _ensureServerInfo(): Promise<Record<string, any>>;
     protected _getSettings(): Promise<LangSmithSettings>;
+    /**
+     * Flushes current queued traces.
+     */
+    flush(): Promise<void>;
     createRun(run: CreateRunParams): Promise<void>;
     /**
      * Batch ingest/upsert multiple runs in the Langsmith system.
@@ -804,7 +814,7 @@ export declare class Client implements LangSmithTracingClientInterface {
      *
      * @returns A promise that resolves once all currently pending traces have sent.
      */
-    awaitPendingTraceBatches(): Promise<[...void[], void]>;
+    awaitPendingTraceBatches(): Promise<void> | Promise<[...void[], void]>;
 }
 export interface LangSmithTracingClientInterface {
     createRun: (run: CreateRunParams) => Promise<void>;

package/dist/client.js

@@ -280,6 +280,12 @@ export class Client {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "manualFlushMode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         const defaultConfig = Client.getDefaultClientConfig();
         this.tracingSampleRate = getTracingSamplingRate();
         this.apiUrl = trimQuotes(config.apiUrl ?? defaultConfig.apiUrl) ?? "";
@@ -313,6 +319,7 @@ export class Client {
             config.blockOnRootRunFinalization ?? this.blockOnRootRunFinalization;
         this.batchSizeBytesLimit = config.batchSizeBytesLimit;
         this.fetchOptions = config.fetchOptions || {};
+        this.manualFlushMode = config.manualFlushMode ?? this.manualFlushMode;
     }
     static getDefaultClientConfig() {
         const apiKey = getLangSmithEnvironmentVariable("API_KEY");
@@ -510,14 +517,17 @@ export class Client {
         return (serverInfo.instance_flags?.dataset_examples_multipart_enabled ?? false);
     }
     drainAutoBatchQueue(batchSizeLimit) {
+        const promises = [];
         while (this.autoBatchQueue.items.length > 0) {
             const [batch, done] = this.autoBatchQueue.pop(batchSizeLimit);
             if (!batch.length) {
                 done();
                 break;
             }
-            void this._processBatch(batch, done).catch(console.error);
+            const batchPromise = this._processBatch(batch, done).catch(console.error);
+            promises.push(batchPromise);
         }
+        return Promise.all(promises);
     }
     async _processBatch(batch, done) {
         if (!batch.length) {
@@ -552,14 +562,18 @@ export class Client {
             item.item = mergeRuntimeEnvIntoRunCreate(item.item);
         }
         const itemPromise = this.autoBatchQueue.push(item);
+        if (this.manualFlushMode) {
+            // Rely on manual flushing in serverless environments
+            return itemPromise;
+        }
         const sizeLimitBytes = await this._getBatchSizeLimitBytes();
         if (this.autoBatchQueue.sizeBytes > sizeLimitBytes) {
-            this.drainAutoBatchQueue(sizeLimitBytes);
+            void this.drainAutoBatchQueue(sizeLimitBytes);
         }
         if (this.autoBatchQueue.items.length > 0) {
             this.autoBatchTimeout = setTimeout(() => {
                 this.autoBatchTimeout = undefined;
-                this.drainAutoBatchQueue(sizeLimitBytes);
+                void this.drainAutoBatchQueue(sizeLimitBytes);
             }, this.autoBatchAggregationDelayMs);
         }
         return itemPromise;
@@ -601,6 +615,13 @@ export class Client {
         }
         return await this.settings;
     }
+    /**
+     * Flushes current queued traces.
+     */
+    async flush() {
+        const sizeLimitBytes = await this._getBatchSizeLimitBytes();
+        await this.drainAutoBatchQueue(sizeLimitBytes);
+    }
     async createRun(run) {
         if (!this._filterForSampling([run]).length) {
             return;
@@ -893,7 +914,8 @@ export class Client {
             data.dotted_order !== undefined) {
             if (run.end_time !== undefined &&
                 data.parent_run_id === undefined &&
-                this.blockOnRootRunFinalization) {
+                this.blockOnRootRunFinalization &&
+                !this.manualFlushMode) {
                 // Trigger batches as soon as a root trace ends and wait to ensure trace finishes
                 // in serverless environments.
                 await this.processRunOperation({ action: "update", item: data }).catch(console.error);
@@ -3024,6 +3046,10 @@ export class Client {
      * @returns A promise that resolves once all currently pending traces have sent.
      */
     awaitPendingTraceBatches() {
+        if (this.manualFlushMode) {
+            console.warn("[WARNING]: When tracing in manual flush mode, you must call `await client.flush()` manually to submit trace batches.");
+            return Promise.resolve();
+        }
         return Promise.all([
             ...this.autoBatchQueue.items.map(({ itemPromise }) => itemPromise),
             this.batchIngestCaller.queue.onIdle(),

package/dist/index.cjs

@@ -8,4 +8,4 @@ Object.defineProperty(exports, "RunTree", { enumerable: true, get: function () {
 var fetch_js_1 = require("./singletons/fetch.cjs");
 Object.defineProperty(exports, "overrideFetchImplementation", { enumerable: true, get: function () { return fetch_js_1.overrideFetchImplementation; } });
 // Update using yarn bump-version
-exports.__version__ = "0.2.14-rc.6";
+exports.__version__ = "0.2.15-beta.0";

package/dist/index.d.ts

@@ -2,4 +2,4 @@ export { Client, type ClientConfig, type LangSmithTracingClientInterface, } from
 export type { Dataset, Example, TracerSession, Run, Feedback, RetrieverOutput, } from "./schemas.js";
 export { RunTree, type RunTreeConfig } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
-export declare const __version__ = "0.2.14-rc.6";
+export declare const __version__ = "0.2.15-beta.0";

package/dist/index.js

@@ -2,4 +2,4 @@ export { Client, } from "./client.js";
 export { RunTree } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 // Update using yarn bump-version
-export const __version__ = "0.2.14-rc.6";
+export const __version__ = "0.2.15-beta.0";

package/dist/run_trees.d.ts

@@ -80,7 +80,7 @@ export declare class RunTree implements BaseRun {
     attachments?: Attachments;
     constructor(originalConfig: RunTreeConfig | RunTree);
     private static getDefaultConfig;
-    static getSharedClient(): Client;
+    private static getSharedClient;
     createChild(config: RunTreeConfig): RunTree;
     end(outputs?: KVMap, error?: string, endTime?: number, metadata?: KVMap): Promise<void>;
     private _convertToCreate;

package/dist/singletons/traceable.cjs

@@ -38,7 +38,7 @@ const getCurrentRunTree = () => {
         throw new Error([
             "Could not get the current run tree.",
             "",
-            "Please make sure you are calling this method within a traceable function and that tracing is enabled.",
+            "Please make sure you are calling this method within a traceable function or the tracing is enabled.",
         ].join("\n"));
     }
     return runTree;

package/dist/singletons/traceable.js

@@ -35,7 +35,7 @@ export const getCurrentRunTree = () => {
         throw new Error([
             "Could not get the current run tree.",
             "",
-            "Please make sure you are calling this method within a traceable function and that tracing is enabled.",
+            "Please make sure you are calling this method within a traceable function or the tracing is enabled.",
         ].join("\n"));
     }
     return runTree;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.2.14-rc.6",
+  "version": "0.2.15-beta.0",
   "description": "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [
@@ -33,10 +33,6 @@
     "langchain.js",
     "langchain.d.ts",
     "langchain.d.cts",
-    "jest.cjs",
-    "jest.js",
-    "jest.d.ts",
-    "jest.d.cts",
     "vercel.cjs",
     "vercel.js",
     "vercel.d.ts",
@@ -232,15 +228,6 @@
       "import": "./langchain.js",
       "require": "./langchain.cjs"
     },
-    "./jest": {
-      "types": {
-        "import": "./jest.d.ts",
-        "require": "./jest.d.cts",
-        "default": "./jest.d.ts"
-      },
-      "import": "./jest.js",
-      "require": "./jest.cjs"
-    },
     "./vercel": {
       "types": {
         "import": "./vercel.d.ts",

package/dist/jest/globals.cjs

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trackingEnabled = exports.jestAsyncLocalStorageInstance = void 0;
-const node_async_hooks_1 = require("node:async_hooks");
-const env_js_1 = require("../utils/env.cjs");
-exports.jestAsyncLocalStorageInstance = new node_async_hooks_1.AsyncLocalStorage();
-function trackingEnabled() {
-    return (0, env_js_1.getEnvironmentVariable)("LANGSMITH_TEST_TRACKING") === "true";
-}
-exports.trackingEnabled = trackingEnabled;

package/dist/jest/globals.d.ts

@@ -1,18 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import { AsyncLocalStorage } from "node:async_hooks";
-import { Dataset, TracerSession, Example } from "../schemas.js";
-import { Client } from "../client.js";
-export declare const jestAsyncLocalStorageInstance: AsyncLocalStorage<{
-    dataset?: Dataset | undefined;
-    examples?: (Example & {
-        inputHash: string;
-        outputHash: string;
-    })[] | undefined;
-    createdAt: string;
-    project?: TracerSession | undefined;
-    currentExample?: Partial<Example> | undefined;
-    client: Client;
-    suiteUuid: string;
-    suiteName: string;
-}>;
-export declare function trackingEnabled(): boolean;

package/dist/jest/globals.js

@@ -1,6 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import { getEnvironmentVariable } from "../utils/env.js";
-export const jestAsyncLocalStorageInstance = new AsyncLocalStorage();
-export function trackingEnabled() {
-    return getEnvironmentVariable("LANGSMITH_TEST_TRACKING") === "true";
-}

package/dist/jest/index.cjs

@@ -1,254 +0,0 @@
-"use strict";
-/* eslint-disable import/no-extraneous-dependencies */
-/* eslint-disable @typescript-eslint/no-namespace */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.expect = exports.describe = exports.it = exports.test = void 0;
-const globals_1 = require("@jest/globals");
-const crypto_1 = __importDefault(require("crypto"));
-const uuid_1 = require("uuid");
-const traceable_js_1 = require("../traceable.cjs");
-const run_trees_js_1 = require("../run_trees.cjs");
-const _random_name_js_1 = require("../evaluation/_random_name.cjs");
-const matchers_js_1 = require("./matchers.cjs");
-const globals_js_1 = require("./globals.cjs");
-const chain_js_1 = require("./vendor/chain.cjs");
-globals_1.expect.extend({
-    toBeRelativeCloseTo: matchers_js_1.toBeRelativeCloseTo,
-    toBeAbsoluteCloseTo: matchers_js_1.toBeAbsoluteCloseTo,
-    toBeSemanticCloseTo: matchers_js_1.toBeSemanticCloseTo,
-});
-const objectHash = (obj, depth = 0) => {
-    // Prevent infinite recursion
-    if (depth > 50) {
-        return "[Max Depth Exceeded]";
-    }
-    if (Array.isArray(obj)) {
-        return obj.map((item) => objectHash(item, depth + 1));
-    }
-    if (obj && typeof obj === "object") {
-        return Object.keys(obj)
-            .sort()
-            .reduce((result, key) => {
-            result[key] = objectHash(obj[key], depth + 1);
-            return result;
-        }, {});
-    }
-    return crypto_1.default.createHash("sha256").update(JSON.stringify(obj)).digest("hex");
-};
-async function _createProject(client, datasetId) {
-    // Create the project, updating the experimentName until we find a unique one.
-    let project;
-    let experimentName = (0, _random_name_js_1.randomName)();
-    for (let i = 0; i < 10; i++) {
-        try {
-            project = await client.createProject({
-                projectName: experimentName,
-                referenceDatasetId: datasetId,
-                // description: this._description,
-            });
-            return project;
-        }
-        catch (e) {
-            // Naming collision
-            if (e?.name === "LangSmithConflictError") {
-                const ent = (0, uuid_1.v4)().slice(0, 6);
-                experimentName = `${experimentName}-${ent}`;
-            }
-            else {
-                throw e;
-            }
-        }
-    }
-    throw new Error("Could not generate a unique experiment name within 10 attempts." +
-        " Please try again.");
-}
-const setupPromises = new Map();
-async function runDatasetSetup(testClient, datasetName) {
-    let storageValue;
-    if (!(0, globals_js_1.trackingEnabled)()) {
-        storageValue = {
-            createdAt: new Date().toISOString(),
-        };
-    }
-    else {
-        let dataset;
-        try {
-            dataset = await testClient.readDataset({
-                datasetName,
-            });
-        }
-        catch (e) {
-            if (e.message.includes("not found")) {
-                dataset = await testClient.createDataset(datasetName, {
-                    description: `Dataset for unit tests created on ${new Date().toISOString()}`,
-                });
-            }
-            else {
-                throw e;
-            }
-        }
-        const examplesList = testClient.listExamples({
-            datasetName,
-        });
-        const examples = [];
-        for await (const example of examplesList) {
-            const inputHash = objectHash(example.inputs);
-            const outputHash = objectHash(example.outputs ?? {});
-            examples.push({ ...example, inputHash, outputHash });
-        }
-        const project = await _createProject(testClient, dataset.id);
-        storageValue = {
-            dataset,
-            examples,
-            project,
-            client: testClient,
-        };
-    }
-    return storageValue;
-}
-function wrapDescribeMethod(method) {
-    return function (datasetName, fn, config) {
-        return method(datasetName, () => {
-            const suiteUuid = (0, uuid_1.v4)();
-            /**
-             * We cannot rely on setting AsyncLocalStorage in beforeAll or beforeEach,
-             * due to https://github.com/jestjs/jest/issues/13653 and needing to use
-             * the janky .enterWith.
-             *
-             * We also cannot do async setup in describe due to Jest restrictions.
-             * However, .run works and since the below function does not contain synchronously,
-             * it works.
-             */
-            void globals_js_1.jestAsyncLocalStorageInstance.run({
-                suiteUuid,
-                suiteName: datasetName,
-                client: config?.client ?? run_trees_js_1.RunTree.getSharedClient(),
-                createdAt: new Date().toISOString(),
-            }, fn);
-        });
-    };
-}
-const lsDescribe = Object.assign(wrapDescribeMethod(globals_1.describe), {
-    only: wrapDescribeMethod(globals_1.describe.only),
-    skip: wrapDescribeMethod(globals_1.describe.skip),
-});
-exports.describe = lsDescribe;
-function wrapTestMethod(method) {
-    return function (params, config) {
-        // Due to https://github.com/jestjs/jest/issues/13653,
-        // we must access the local store value here before
-        // entering an async context
-        const context = globals_js_1.jestAsyncLocalStorageInstance.getStore();
-        // This typing is wrong, but necessary to avoid lint errors
-        // eslint-disable-next-line @typescript-eslint/no-misused-promises
-        return async function (...args) {
-            return method(args[0], async () => {
-                if (context === undefined) {
-                    throw new Error(`Could not retrieve test context.\nPlease make sure you have tracing enabled and you are wrapping all of your test cases in an "ls.describe()" function.`);
-                }
-                // Because of https://github.com/jestjs/jest/issues/13653, we have to do asynchronous setup
-                // within the test itself
-                if (!setupPromises.get(context.suiteUuid)) {
-                    setupPromises.set(context.suiteUuid, runDatasetSetup(context.client, context.suiteName));
-                }
-                const { examples, dataset, createdAt, project, client } = await setupPromises.get(context.suiteUuid);
-                const testInput = typeof params === "string" ? {} : params.inputs;
-                const testOutput = typeof params === "string" ? {} : params.outputs;
-                const inputHash = objectHash(testInput);
-                const outputHash = objectHash(testOutput ?? {});
-                if ((0, globals_js_1.trackingEnabled)()) {
-                    const missingFields = [];
-                    if (examples === undefined) {
-                        missingFields.push("examples");
-                    }
-                    if (dataset === undefined) {
-                        missingFields.push("dataset");
-                    }
-                    if (project === undefined) {
-                        missingFields.push("project");
-                    }
-                    if (client === undefined) {
-                        missingFields.push("client");
-                    }
-                    if (missingFields.length > 0) {
-                        throw new Error(`Failed to initialize test tracking: Could not identify ${missingFields
-                            .map((field) => `"${field}"`)
-                            .join(", ")} while syncing to LangSmith. Please contact us for help.`);
-                    }
-                    const testClient = config?.client ?? client;
-                    let example = (examples ?? []).find((example) => {
-                        return (example.inputHash === inputHash &&
-                            example.outputHash === outputHash);
-                    });
-                    if (example === undefined) {
-                        const newExample = await testClient.createExample(testInput, testOutput, {
-                            datasetId: dataset?.id,
-                            createdAt: new Date(createdAt ?? new Date()),
-                        });
-                        example = { ...newExample, inputHash, outputHash };
-                    }
-                    // .enterWith is OK here
-                    globals_js_1.jestAsyncLocalStorageInstance.enterWith({
-                        ...context,
-                        currentExample: example,
-                        client: testClient,
-                    });
-                    const traceableOptions = {
-                        reference_example_id: example.id,
-                        project_name: project.name,
-                        metadata: {
-                            ...config?.metadata,
-                            example_version: example.modified_at
-                                ? new Date(example.modified_at).toISOString()
-                                : new Date(example.created_at).toISOString(),
-                        },
-                        client: testClient,
-                        tracingEnabled: true,
-                        name: "Unit test",
-                    };
-                    // Pass inputs into traceable so tracing works correctly but
-                    // provide both to the user-defined test function
-                    const tracedFunction = (0, traceable_js_1.traceable)(async (_) => {
-                        return args[1]({
-                            inputs: testInput,
-                            outputs: testOutput,
-                        });
-                    }, { ...traceableOptions, ...config });
-                    await tracedFunction(testInput);
-                    await testClient.awaitPendingTraceBatches();
-                }
-                else {
-                    // .enterWith is OK here
-                    globals_js_1.jestAsyncLocalStorageInstance.enterWith({
-                        ...context,
-                        currentExample: { inputs: testInput, outputs: testOutput },
-                    });
-                    await args[1]({
-                        inputs: testInput,
-                        outputs: testOutput,
-                    });
-                }
-            }, ...args.slice(2));
-        };
-    };
-}
-function eachMethod(table) {
-    return function (name, fn, timeout) {
-        for (let i = 0; i < table.length; i += 1) {
-            const example = table[i];
-            wrapTestMethod(globals_1.test)(example)(`${name} ${i}`, fn, timeout);
-        }
-    };
-}
-const lsTest = Object.assign(wrapTestMethod(globals_1.test), {
-    only: wrapTestMethod(globals_1.test.only),
-    skip: wrapTestMethod(globals_1.test.skip),
-    each: eachMethod,
-});
-exports.test = lsTest;
-exports.it = lsTest;
-const wrappedExpect = (0, chain_js_1.wrapExpect)(globals_1.expect);
-exports.expect = wrappedExpect;

package/dist/jest/index.d.ts

@@ -1,55 +0,0 @@
-import { RunTreeConfig } from "../run_trees.js";
-import { KVMap } from "../schemas.js";
-import type { SimpleEvaluator } from "./vendor/gradedBy.js";
-declare global {
-    namespace jest {
-        interface AsymmetricMatchers {
-            toBeRelativeCloseTo(expected: string, options?: any): void;
-            toBeAbsoluteCloseTo(expected: string, options?: any): void;
-            toBeSemanticCloseTo(expected: string, options?: any): Promise<void>;
-        }
-        interface Matchers<R> {
-            toBeRelativeCloseTo(expected: string, options?: any): R;
-            toBeAbsoluteCloseTo(expected: string, options?: any): R;
-            toBeSemanticCloseTo(expected: string, options?: any): Promise<R>;
-            gradedBy(evaluator: SimpleEvaluator): jest.Matchers<Promise<R>> & {
-                not: jest.Matchers<Promise<R>>;
-                resolves: jest.Matchers<Promise<R>>;
-                rejects: jest.Matchers<Promise<R>>;
-            };
-        }
-    }
-}
-export type LangSmithJestDescribeWrapper = (name: string, fn: () => void | Promise<void>, config?: Partial<RunTreeConfig>) => void;
-declare const lsDescribe: LangSmithJestDescribeWrapper & {
-    only: LangSmithJestDescribeWrapper;
-    skip: LangSmithJestDescribeWrapper;
-};
-export type LangSmithJestTestWrapper<I, O> = (name: string, fn: (params: {
-    inputs: I;
-    outputs: O;
-}) => unknown | Promise<unknown>, timeout?: number) => void;
-declare function eachMethod<I extends KVMap, O extends KVMap>(table: {
-    inputs: I;
-    outputs: O;
-}[]): (name: string, fn: (params: {
-    inputs: I;
-    outputs: O;
-}) => unknown | Promise<unknown>, timeout?: number) => void;
-declare const lsTest: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(params: {
-    inputs: I;
-    outputs: O;
-} | string, config?: Partial<RunTreeConfig>) => LangSmithJestTestWrapper<I, O>) & {
-    only: <I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(params: {
-        inputs: I;
-        outputs: O;
-    } | string, config?: Partial<RunTreeConfig>) => LangSmithJestTestWrapper<I, O>;
-    skip: <I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(params: {
-        inputs: I;
-        outputs: O;
-    } | string, config?: Partial<RunTreeConfig>) => LangSmithJestTestWrapper<I, O>;
-    each: typeof eachMethod;
-};
-declare const wrappedExpect: any;
-export { lsTest as test, lsTest as it, lsDescribe as describe, wrappedExpect as expect, };
-export { type SimpleEvaluator };