langsmith 0.0.66 → 0.0.68

package/dist/client.cjs

@@ -29,6 +29,40 @@ const async_caller_js_1 = require("./utils/async_caller.cjs");
 const messages_js_1 = require("./utils/messages.cjs");
 const env_js_1 = require("./utils/env.cjs");
 const index_js_1 = require("./index.cjs");
+async function mergeRuntimeEnvIntoRunCreates(runs) {
+    const runtimeEnv = await (0, env_js_1.getRuntimeEnvironment)();
+    const envVars = (0, env_js_1.getLangChainEnvVarsMetadata)();
+    return runs.map((run) => {
+        const extra = run.extra ?? {};
+        const metadata = extra.metadata;
+        run.extra = {
+            ...extra,
+            runtime: {
+                ...runtimeEnv,
+                ...extra?.runtime,
+            },
+            metadata: {
+                ...envVars,
+                ...(envVars.revision_id || run.revision_id
+                    ? { revision_id: run.revision_id ?? envVars.revision_id }
+                    : {}),
+                ...metadata,
+            },
+        };
+        return run;
+    });
+}
+const getTracingSamplingRate = () => {
+    const samplingRateStr = (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_TRACING_SAMPLING_RATE");
+    if (samplingRateStr === undefined) {
+        return undefined;
+    }
+    const samplingRate = parseFloat(samplingRateStr);
+    if (samplingRate < 0 || samplingRate > 1) {
+        throw new Error(`LANGCHAIN_TRACING_SAMPLING_RATE must be between 0 and 1 if set. Got: ${samplingRate}`);
+    }
+    return samplingRate;
+};
 // utility functions
 const isLocalhost = (url) => {
     const strippedUrl = url.replace("http://", "").replace("https://", "");
@@ -114,7 +148,56 @@ class Client {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "tracingSampleRate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sampledPostUuids", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "autoBatchTracing", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "pendingAutoBatchedRuns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "pendingAutoBatchedRunLimit", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 100
+        });
+        Object.defineProperty(this, "autoBatchTimeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "autoBatchInitialDelayMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 250
+        });
+        Object.defineProperty(this, "autoBatchAggregationDelayMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 50
+        });
         const defaultConfig = Client.getDefaultClientConfig();
+        this.tracingSampleRate = getTracingSamplingRate();
         this.apiUrl = trimQuotes(config.apiUrl ?? defaultConfig.apiUrl) ?? "";
         this.apiKey = trimQuotes(config.apiKey ?? defaultConfig.apiKey);
         this.webUrl = trimQuotes(config.webUrl ?? defaultConfig.webUrl);
@@ -123,6 +206,9 @@ class Client {
         this.caller = new async_caller_js_1.AsyncCaller(config.callerOptions ?? {});
         this.hideInputs = config.hideInputs ?? defaultConfig.hideInputs;
         this.hideOutputs = config.hideOutputs ?? defaultConfig.hideOutputs;
+        this.autoBatchTracing = config.autoBatchTracing ?? this.autoBatchTracing;
+        this.pendingAutoBatchedRunLimit =
+            config.pendingAutoBatchedRunLimit ?? this.pendingAutoBatchedRunLimit;
     }
     static getDefaultClientConfig() {
         const apiKey = (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_API_KEY");
@@ -187,6 +273,16 @@ class Client {
         }
         return outputs;
     }
+    prepareRunCreateOrUpdateInputs(run) {
+        const runParams = { ...run };
+        if (runParams.inputs !== undefined) {
+            runParams.inputs = this.processInputs(runParams.inputs);
+        }
+        if (runParams.outputs !== undefined) {
+            runParams.outputs = this.processOutputs(runParams.outputs);
+        }
+        return runParams;
+    }
     async _getResponse(path, queryParams) {
         const paramsString = queryParams?.toString() ?? "";
         const url = `${this.apiUrl}${path}?${paramsString}`;
@@ -257,45 +353,157 @@ class Client {
             bodyParams.cursor = cursors.next;
         }
     }
+    _filterForSampling(runs, patch = false) {
+        if (this.tracingSampleRate === undefined) {
+            return runs;
+        }
+        if (patch) {
+            const sampled = [];
+            for (const run of runs) {
+                if (this.sampledPostUuids.has(run.id)) {
+                    sampled.push(run);
+                    this.sampledPostUuids.delete(run.id);
+                }
+            }
+            return sampled;
+        }
+        else {
+            const sampled = [];
+            for (const run of runs) {
+                if (Math.random() < this.tracingSampleRate) {
+                    sampled.push(run);
+                    this.sampledPostUuids.add(run.id);
+                }
+            }
+            return sampled;
+        }
+    }
+    async triggerAutoBatchSend(runs) {
+        let batch = runs;
+        if (batch === undefined) {
+            batch = this.pendingAutoBatchedRuns.slice(0, this.pendingAutoBatchedRunLimit);
+            this.pendingAutoBatchedRuns = this.pendingAutoBatchedRuns.slice(this.pendingAutoBatchedRunLimit);
+        }
+        await this.batchIngestRuns({
+            runCreates: batch
+                .filter((item) => item.action === "create")
+                .map((item) => item.item),
+            runUpdates: batch
+                .filter((item) => item.action === "update")
+                .map((item) => item.item),
+        });
+    }
+    appendRunCreateToAutoBatchQueue(item) {
+        const oldTimeout = this.autoBatchTimeout;
+        clearTimeout(this.autoBatchTimeout);
+        this.autoBatchTimeout = undefined;
+        this.pendingAutoBatchedRuns.push(item);
+        while (this.pendingAutoBatchedRuns.length >= this.pendingAutoBatchedRunLimit) {
+            const batch = this.pendingAutoBatchedRuns.slice(0, this.pendingAutoBatchedRunLimit);
+            this.pendingAutoBatchedRuns = this.pendingAutoBatchedRuns.slice(this.pendingAutoBatchedRunLimit);
+            void this.triggerAutoBatchSend(batch);
+        }
+        if (this.pendingAutoBatchedRuns.length > 0) {
+            if (!oldTimeout) {
+                this.autoBatchTimeout = setTimeout(() => {
+                    this.autoBatchTimeout = undefined;
+                    void this.triggerAutoBatchSend();
+                }, this.autoBatchInitialDelayMs);
+            }
+            else {
+                this.autoBatchTimeout = setTimeout(() => {
+                    this.autoBatchTimeout = undefined;
+                    void this.triggerAutoBatchSend();
+                }, this.autoBatchAggregationDelayMs);
+            }
+        }
+    }
     async createRun(run) {
+        if (!this._filterForSampling([run]).length) {
+            return;
+        }
         const headers = { ...this.headers, "Content-Type": "application/json" };
-        const extra = run.extra ?? {};
-        const metadata = extra.metadata;
-        const runtimeEnv = await (0, env_js_1.getRuntimeEnvironment)();
-        const envVars = (0, env_js_1.getLangChainEnvVarsMetadata)();
         const session_name = run.project_name;
         delete run.project_name;
-        const runCreate = {
+        const runCreate = this.prepareRunCreateOrUpdateInputs({
             session_name,
             ...run,
-            extra: {
-                ...run.extra,
-                runtime: {
-                    ...runtimeEnv,
-                    ...extra.runtime,
-                },
-                metadata: {
-                    ...envVars,
-                    ...(envVars.revision_id || run.revision_id
-                        ? { revision_id: run.revision_id ?? envVars.revision_id }
-                        : {}),
-                    ...metadata,
-                },
-            },
-        };
-        runCreate.inputs = this.processInputs(runCreate.inputs);
-        if (runCreate.outputs) {
-            runCreate.outputs = this.processOutputs(runCreate.outputs);
+            start_time: run.start_time ?? Date.now(),
+        });
+        if (this.autoBatchTracing &&
+            runCreate.trace_id !== undefined &&
+            runCreate.dotted_order !== undefined) {
+            this.appendRunCreateToAutoBatchQueue({
+                action: "create",
+                item: runCreate,
+            });
+            return;
         }
-        runCreate.start_time = run.start_time ?? Date.now();
+        const mergedRunCreateParams = await mergeRuntimeEnvIntoRunCreates([
+            runCreate,
+        ]);
         const response = await this.caller.call(fetch, `${this.apiUrl}/runs`, {
             method: "POST",
             headers,
-            body: JSON.stringify(runCreate),
+            body: JSON.stringify(mergedRunCreateParams[0]),
             signal: AbortSignal.timeout(this.timeout_ms),
         });
         await raiseForStatus(response, "create run");
     }
+    /**
+     * Batch ingest/upsert multiple runs in the Langsmith system.
+     * @param runs
+     */
+    async batchIngestRuns({ runCreates, runUpdates, }) {
+        if (runCreates === undefined && runUpdates === undefined) {
+            return;
+        }
+        let preparedCreateParams = runCreates?.map((create) => this.prepareRunCreateOrUpdateInputs(create)) ?? [];
+        let preparedUpdateParams = runUpdates?.map((update) => this.prepareRunCreateOrUpdateInputs(update)) ?? [];
+        if (preparedCreateParams.length > 0 && preparedUpdateParams.length > 0) {
+            const createById = preparedCreateParams.reduce((params, run) => {
+                if (!run.id) {
+                    return params;
+                }
+                params[run.id] = run;
+                return params;
+            }, {});
+            const standaloneUpdates = [];
+            for (const updateParam of preparedUpdateParams) {
+                if (updateParam.id !== undefined && createById[updateParam.id]) {
+                    createById[updateParam.id] = {
+                        ...createById[updateParam.id],
+                        ...updateParam,
+                    };
+                }
+                else {
+                    standaloneUpdates.push(updateParam);
+                }
+            }
+            preparedCreateParams = Object.values(createById);
+            preparedUpdateParams = standaloneUpdates;
+        }
+        const body = {
+            post: this._filterForSampling(preparedCreateParams),
+            patch: this._filterForSampling(preparedUpdateParams, true),
+        };
+        if (!body.post.length && !body.patch.length) {
+            return;
+        }
+        preparedCreateParams = await mergeRuntimeEnvIntoRunCreates(preparedCreateParams);
+        const headers = {
+            ...this.headers,
+            "Content-Type": "application/json",
+            Accept: "application/json",
+        };
+        const response = await this.caller.call(fetch, `${this.apiUrl}/runs/batch`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(this.timeout_ms),
+        });
+        await raiseForStatus(response, "batch create run");
+    }
     async updateRun(runId, run) {
         assertUuid(runId);
         if (run.inputs) {
@@ -304,6 +512,17 @@ class Client {
         if (run.outputs) {
             run.outputs = this.processOutputs(run.outputs);
         }
+        // TODO: Untangle types
+        const data = { ...run, id: runId };
+        if (!this._filterForSampling([data], true).length) {
+            return;
+        }
+        if (this.autoBatchTracing &&
+            data.trace_id !== undefined &&
+            data.dotted_order !== undefined) {
+            this.appendRunCreateToAutoBatchQueue({ action: "update", item: data });
+            return;
+        }
         const headers = { ...this.headers, "Content-Type": "application/json" };
         const response = await this.caller.call(fetch, `${this.apiUrl}/runs/${runId}`, {
             method: "PATCH",
@@ -572,7 +791,7 @@ class Client {
         }
         return result;
     }
-    async readProject({ projectId, projectName, }) {
+    async readProject({ projectId, projectName, includeStats, }) {
         let path = "/sessions";
         const params = new URLSearchParams();
         if (projectId !== undefined && projectName !== undefined) {
@@ -588,6 +807,9 @@ class Client {
         else {
             throw new Error("Must provide projectName or projectId");
         }
+        if (includeStats !== undefined) {
+            params.append("include_stats", includeStats.toString());
+        }
         const response = await this._get(path, params);
         let result;
         if (Array.isArray(response)) {

package/dist/client.d.ts

@@ -9,6 +9,8 @@ interface ClientConfig {
     webUrl?: string;
     hideInputs?: boolean;
     hideOutputs?: boolean;
+    autoBatchTracing?: boolean;
+    pendingAutoBatchedRunLimit?: number;
 }
 interface ListRunsParams {
     projectId?: string;
@@ -49,8 +51,10 @@ interface CreateRunParams {
     parent_run_id?: string;
     project_name?: string;
     revision_id?: string;
+    trace_id?: string;
+    dotted_order?: string;
 }
-interface projectOptions {
+interface ProjectOptions {
     projectName?: string;
     projectId?: string;
 }
@@ -70,6 +74,14 @@ export declare class Client {
     private _tenantId;
     private hideInputs?;
     private hideOutputs?;
+    private tracingSampleRate?;
+    private sampledPostUuids;
+    private autoBatchTracing;
+    private pendingAutoBatchedRuns;
+    private pendingAutoBatchedRunLimit;
+    private autoBatchTimeout;
+    private autoBatchInitialDelayMs;
+    private autoBatchAggregationDelayMs;
     constructor(config?: ClientConfig);
     static getDefaultClientConfig(): {
         apiUrl: string;
@@ -83,11 +95,23 @@ export declare class Client {
     private get headers();
     private processInputs;
     private processOutputs;
+    private prepareRunCreateOrUpdateInputs;
     private _getResponse;
     private _get;
     private _getPaginated;
     private _getCursorPaginatedList;
+    private _filterForSampling;
+    private triggerAutoBatchSend;
+    private appendRunCreateToAutoBatchQueue;
     createRun(run: CreateRunParams): Promise<void>;
+    /**
+     * Batch ingest/upsert multiple runs in the Langsmith system.
+     * @param runs
+     */
+    batchIngestRuns({ runCreates, runUpdates, }: {
+        runCreates?: RunCreate[];
+        runUpdates?: RunUpdate[];
+    }): Promise<void>;
     updateRun(runId: string, run: RunUpdate): Promise<void>;
     readRun(runId: string, { loadChildRuns }?: {
         loadChildRuns: boolean;
@@ -95,7 +119,7 @@ export declare class Client {
     getRunUrl({ runId, run, projectOpts, }: {
         runId?: string;
         run?: Run;
-        projectOpts?: projectOptions;
+        projectOpts?: ProjectOptions;
     }): Promise<string>;
     private _loadChildRuns;
     listRuns({ projectId, projectName, parentRunId, referenceExampleId, startTime, executionOrder, runType, error, id, query, filter, limit, }: ListRunsParams): AsyncIterable<Run>;
@@ -126,9 +150,10 @@ export declare class Client {
         projectExtra?: Record<string, any> | null;
         endTime?: string | null;
     }): Promise<TracerSession>;
-    readProject({ projectId, projectName, }: {
+    readProject({ projectId, projectName, includeStats, }: {
         projectId?: string;
         projectName?: string;
+        includeStats?: boolean;
     }): Promise<TracerSessionResult>;
     private _getTenantId;
     listProjects({ projectIds, name, nameContains, referenceDatasetId, referenceDatasetName, referenceFree, }?: {

package/dist/client.js

@@ -3,6 +3,40 @@ import { AsyncCaller } from "./utils/async_caller.js";
 import { convertLangChainMessageToExample, isLangChainMessage, } from "./utils/messages.js";
 import { getEnvironmentVariable, getLangChainEnvVarsMetadata, getRuntimeEnvironment, } from "./utils/env.js";
 import { __version__ } from "./index.js";
+async function mergeRuntimeEnvIntoRunCreates(runs) {
+    const runtimeEnv = await getRuntimeEnvironment();
+    const envVars = getLangChainEnvVarsMetadata();
+    return runs.map((run) => {
+        const extra = run.extra ?? {};
+        const metadata = extra.metadata;
+        run.extra = {
+            ...extra,
+            runtime: {
+                ...runtimeEnv,
+                ...extra?.runtime,
+            },
+            metadata: {
+                ...envVars,
+                ...(envVars.revision_id || run.revision_id
+                    ? { revision_id: run.revision_id ?? envVars.revision_id }
+                    : {}),
+                ...metadata,
+            },
+        };
+        return run;
+    });
+}
+const getTracingSamplingRate = () => {
+    const samplingRateStr = getEnvironmentVariable("LANGCHAIN_TRACING_SAMPLING_RATE");
+    if (samplingRateStr === undefined) {
+        return undefined;
+    }
+    const samplingRate = parseFloat(samplingRateStr);
+    if (samplingRate < 0 || samplingRate > 1) {
+        throw new Error(`LANGCHAIN_TRACING_SAMPLING_RATE must be between 0 and 1 if set. Got: ${samplingRate}`);
+    }
+    return samplingRate;
+};
 // utility functions
 const isLocalhost = (url) => {
     const strippedUrl = url.replace("http://", "").replace("https://", "");
@@ -88,7 +122,56 @@ export class Client {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "tracingSampleRate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sampledPostUuids", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "autoBatchTracing", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "pendingAutoBatchedRuns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "pendingAutoBatchedRunLimit", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 100
+        });
+        Object.defineProperty(this, "autoBatchTimeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "autoBatchInitialDelayMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 250
+        });
+        Object.defineProperty(this, "autoBatchAggregationDelayMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 50
+        });
         const defaultConfig = Client.getDefaultClientConfig();
+        this.tracingSampleRate = getTracingSamplingRate();
         this.apiUrl = trimQuotes(config.apiUrl ?? defaultConfig.apiUrl) ?? "";
         this.apiKey = trimQuotes(config.apiKey ?? defaultConfig.apiKey);
         this.webUrl = trimQuotes(config.webUrl ?? defaultConfig.webUrl);
@@ -97,6 +180,9 @@ export class Client {
         this.caller = new AsyncCaller(config.callerOptions ?? {});
         this.hideInputs = config.hideInputs ?? defaultConfig.hideInputs;
         this.hideOutputs = config.hideOutputs ?? defaultConfig.hideOutputs;
+        this.autoBatchTracing = config.autoBatchTracing ?? this.autoBatchTracing;
+        this.pendingAutoBatchedRunLimit =
+            config.pendingAutoBatchedRunLimit ?? this.pendingAutoBatchedRunLimit;
     }
     static getDefaultClientConfig() {
         const apiKey = getEnvironmentVariable("LANGCHAIN_API_KEY");
@@ -161,6 +247,16 @@ export class Client {
         }
         return outputs;
     }
+    prepareRunCreateOrUpdateInputs(run) {
+        const runParams = { ...run };
+        if (runParams.inputs !== undefined) {
+            runParams.inputs = this.processInputs(runParams.inputs);
+        }
+        if (runParams.outputs !== undefined) {
+            runParams.outputs = this.processOutputs(runParams.outputs);
+        }
+        return runParams;
+    }
     async _getResponse(path, queryParams) {
         const paramsString = queryParams?.toString() ?? "";
         const url = `${this.apiUrl}${path}?${paramsString}`;
@@ -231,45 +327,157 @@ export class Client {
             bodyParams.cursor = cursors.next;
         }
     }
+    _filterForSampling(runs, patch = false) {
+        if (this.tracingSampleRate === undefined) {
+            return runs;
+        }
+        if (patch) {
+            const sampled = [];
+            for (const run of runs) {
+                if (this.sampledPostUuids.has(run.id)) {
+                    sampled.push(run);
+                    this.sampledPostUuids.delete(run.id);
+                }
+            }
+            return sampled;
+        }
+        else {
+            const sampled = [];
+            for (const run of runs) {
+                if (Math.random() < this.tracingSampleRate) {
+                    sampled.push(run);
+                    this.sampledPostUuids.add(run.id);
+                }
+            }
+            return sampled;
+        }
+    }
+    async triggerAutoBatchSend(runs) {
+        let batch = runs;
+        if (batch === undefined) {
+            batch = this.pendingAutoBatchedRuns.slice(0, this.pendingAutoBatchedRunLimit);
+            this.pendingAutoBatchedRuns = this.pendingAutoBatchedRuns.slice(this.pendingAutoBatchedRunLimit);
+        }
+        await this.batchIngestRuns({
+            runCreates: batch
+                .filter((item) => item.action === "create")
+                .map((item) => item.item),
+            runUpdates: batch
+                .filter((item) => item.action === "update")
+                .map((item) => item.item),
+        });
+    }
+    appendRunCreateToAutoBatchQueue(item) {
+        const oldTimeout = this.autoBatchTimeout;
+        clearTimeout(this.autoBatchTimeout);
+        this.autoBatchTimeout = undefined;
+        this.pendingAutoBatchedRuns.push(item);
+        while (this.pendingAutoBatchedRuns.length >= this.pendingAutoBatchedRunLimit) {
+            const batch = this.pendingAutoBatchedRuns.slice(0, this.pendingAutoBatchedRunLimit);
+            this.pendingAutoBatchedRuns = this.pendingAutoBatchedRuns.slice(this.pendingAutoBatchedRunLimit);
+            void this.triggerAutoBatchSend(batch);
+        }
+        if (this.pendingAutoBatchedRuns.length > 0) {
+            if (!oldTimeout) {
+                this.autoBatchTimeout = setTimeout(() => {
+                    this.autoBatchTimeout = undefined;
+                    void this.triggerAutoBatchSend();
+                }, this.autoBatchInitialDelayMs);
+            }
+            else {
+                this.autoBatchTimeout = setTimeout(() => {
+                    this.autoBatchTimeout = undefined;
+                    void this.triggerAutoBatchSend();
+                }, this.autoBatchAggregationDelayMs);
+            }
+        }
+    }
     async createRun(run) {
+        if (!this._filterForSampling([run]).length) {
+            return;
+        }
         const headers = { ...this.headers, "Content-Type": "application/json" };
-        const extra = run.extra ?? {};
-        const metadata = extra.metadata;
-        const runtimeEnv = await getRuntimeEnvironment();
-        const envVars = getLangChainEnvVarsMetadata();
         const session_name = run.project_name;
         delete run.project_name;
-        const runCreate = {
+        const runCreate = this.prepareRunCreateOrUpdateInputs({
             session_name,
             ...run,
-            extra: {
-                ...run.extra,
-                runtime: {
-                    ...runtimeEnv,
-                    ...extra.runtime,
-                },
-                metadata: {
-                    ...envVars,
-                    ...(envVars.revision_id || run.revision_id
-                        ? { revision_id: run.revision_id ?? envVars.revision_id }
-                        : {}),
-                    ...metadata,
-                },
-            },
-        };
-        runCreate.inputs = this.processInputs(runCreate.inputs);
-        if (runCreate.outputs) {
-            runCreate.outputs = this.processOutputs(runCreate.outputs);
+            start_time: run.start_time ?? Date.now(),
+        });
+        if (this.autoBatchTracing &&
+            runCreate.trace_id !== undefined &&
+            runCreate.dotted_order !== undefined) {
+            this.appendRunCreateToAutoBatchQueue({
+                action: "create",
+                item: runCreate,
+            });
+            return;
         }
-        runCreate.start_time = run.start_time ?? Date.now();
+        const mergedRunCreateParams = await mergeRuntimeEnvIntoRunCreates([
+            runCreate,
+        ]);
         const response = await this.caller.call(fetch, `${this.apiUrl}/runs`, {
             method: "POST",
             headers,
-            body: JSON.stringify(runCreate),
+            body: JSON.stringify(mergedRunCreateParams[0]),
             signal: AbortSignal.timeout(this.timeout_ms),
         });
         await raiseForStatus(response, "create run");
     }
+    /**
+     * Batch ingest/upsert multiple runs in the Langsmith system.
+     * @param runs
+     */
+    async batchIngestRuns({ runCreates, runUpdates, }) {
+        if (runCreates === undefined && runUpdates === undefined) {
+            return;
+        }
+        let preparedCreateParams = runCreates?.map((create) => this.prepareRunCreateOrUpdateInputs(create)) ?? [];
+        let preparedUpdateParams = runUpdates?.map((update) => this.prepareRunCreateOrUpdateInputs(update)) ?? [];
+        if (preparedCreateParams.length > 0 && preparedUpdateParams.length > 0) {
+            const createById = preparedCreateParams.reduce((params, run) => {
+                if (!run.id) {
+                    return params;
+                }
+                params[run.id] = run;
+                return params;
+            }, {});
+            const standaloneUpdates = [];
+            for (const updateParam of preparedUpdateParams) {
+                if (updateParam.id !== undefined && createById[updateParam.id]) {
+                    createById[updateParam.id] = {
+                        ...createById[updateParam.id],
+                        ...updateParam,
+                    };
+                }
+                else {
+                    standaloneUpdates.push(updateParam);
+                }
+            }
+            preparedCreateParams = Object.values(createById);
+            preparedUpdateParams = standaloneUpdates;
+        }
+        const body = {
+            post: this._filterForSampling(preparedCreateParams),
+            patch: this._filterForSampling(preparedUpdateParams, true),
+        };
+        if (!body.post.length && !body.patch.length) {
+            return;
+        }
+        preparedCreateParams = await mergeRuntimeEnvIntoRunCreates(preparedCreateParams);
+        const headers = {
+            ...this.headers,
+            "Content-Type": "application/json",
+            Accept: "application/json",
+        };
+        const response = await this.caller.call(fetch, `${this.apiUrl}/runs/batch`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(this.timeout_ms),
+        });
+        await raiseForStatus(response, "batch create run");
+    }
     async updateRun(runId, run) {
         assertUuid(runId);
         if (run.inputs) {
@@ -278,6 +486,17 @@ export class Client {
         if (run.outputs) {
             run.outputs = this.processOutputs(run.outputs);
         }
+        // TODO: Untangle types
+        const data = { ...run, id: runId };
+        if (!this._filterForSampling([data], true).length) {
+            return;
+        }
+        if (this.autoBatchTracing &&
+            data.trace_id !== undefined &&
+            data.dotted_order !== undefined) {
+            this.appendRunCreateToAutoBatchQueue({ action: "update", item: data });
+            return;
+        }
         const headers = { ...this.headers, "Content-Type": "application/json" };
         const response = await this.caller.call(fetch, `${this.apiUrl}/runs/${runId}`, {
             method: "PATCH",
@@ -546,7 +765,7 @@ export class Client {
         }
         return result;
     }
-    async readProject({ projectId, projectName, }) {
+    async readProject({ projectId, projectName, includeStats, }) {
         let path = "/sessions";
         const params = new URLSearchParams();
         if (projectId !== undefined && projectName !== undefined) {
@@ -562,6 +781,9 @@ export class Client {
         else {
             throw new Error("Must provide projectName or projectId");
         }
+        if (includeStats !== undefined) {
+            params.append("include_stats", includeStats.toString());
+        }
         const response = await this._get(path, params);
         let result;
         if (Array.isArray(response)) {

package/dist/index.cjs

@@ -6,4 +6,4 @@ Object.defineProperty(exports, "Client", { enumerable: true, get: function () {
 var run_trees_js_1 = require("./run_trees.cjs");
 Object.defineProperty(exports, "RunTree", { enumerable: true, get: function () { return run_trees_js_1.RunTree; } });
 // Update using yarn bump-version
-exports.__version__ = "0.0.66";
+exports.__version__ = "0.0.68";

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { Client } from "./client.js";
 export { Dataset, Example, TracerSession, Run, Feedback } from "./schemas.js";
 export { RunTree, RunTreeConfig } from "./run_trees.js";
-export declare const __version__ = "0.0.66";
+export declare const __version__ = "0.0.68";

package/dist/index.js

@@ -1,4 +1,4 @@
 export { Client } from "./client.js";
 export { RunTree } from "./run_trees.js";
 // Update using yarn bump-version
-export const __version__ = "0.0.66";
+export const __version__ = "0.0.68";

package/dist/schemas.d.ts

@@ -61,6 +61,21 @@ export interface BaseRun {
     parent_run_id?: string;
     /** Tags for further categorizing or annotating the run. */
     tags?: string[];
+    /** Unique ID assigned to every run within this nested trace. **/
+    trace_id?: string;
+    /**
+     * The dotted order for the run.
+     *
+     * This is a string composed of {time}{run-uuid}.* so that a trace can be
+     * sorted in the order it was executed.
+     *
+     * Example:
+     * - Parent: 20230914T223155647Z1b64098b-4ab7-43f6-afee-992304f198d8
+     * - Children:
+     *    - 20230914T223155647Z1b64098b-4ab7-43f6-afee-992304f198d8.20230914T223155649Z809ed3a2-0172-4f4d-8a02-a64e9b7a0f8a
+     *   - 20230915T223155647Z1b64098b-4ab7-43f6-afee-992304f198d8.20230914T223155650Zc8d9f4c5-6c5a-4b2d-9b1c-3d9d7a7c5c7c
+     */
+    dotted_order?: string;
 }
 /**
  * Describes properties of a run when loaded from the database.
@@ -93,27 +108,14 @@ export interface Run extends BaseRun {
     first_token_time?: number;
     /** IDs of parent runs, if multiple exist. */
     parent_run_ids?: string[];
-    /**Unique ID assigned to every run within this nested trace.**/
-    trace_id?: string;
-    /**
-     * The dotted order for the run.
-     *
-     * This is a string composed of {time}{run-uuid}.* so that a trace can be
-     * sorted in the order it was executed.
-     *
-     * Example:
-     * - Parent: 20230914T223155647Z1b64098b-4ab7-43f6-afee-992304f198d8
-     * - Children:
-     *    - 20230914T223155647Z1b64098b-4ab7-43f6-afee-992304f198d8.20230914T223155649Z809ed3a2-0172-4f4d-8a02-a64e9b7a0f8a
-     *   - 20230915T223155647Z1b64098b-4ab7-43f6-afee-992304f198d8.20230914T223155650Zc8d9f4c5-6c5a-4b2d-9b1c-3d9d7a7c5c7c
-     */
-    dotted_order?: string;
 }
 export interface RunCreate extends BaseRun {
+    revision_id?: string;
     child_runs?: this[];
     session_name?: string;
 }
 export interface RunUpdate {
+    id?: string;
     end_time?: number;
     extra?: KVMap;
     error?: string;
@@ -123,6 +125,21 @@ export interface RunUpdate {
     reference_example_id?: string;
     events?: KVMap[];
     session_id?: string;
+    /** Unique ID assigned to every run within this nested trace. **/
+    trace_id?: string;
+    /**
+     * The dotted order for the run.
+     *
+     * This is a string composed of {time}{run-uuid}.* so that a trace can be
+     * sorted in the order it was executed.
+     *
+     * Example:
+     * - Parent: 20230914T223155647Z1b64098b-4ab7-43f6-afee-992304f198d8
+     * - Children:
+     *    - 20230914T223155647Z1b64098b-4ab7-43f6-afee-992304f198d8.20230914T223155649Z809ed3a2-0172-4f4d-8a02-a64e9b7a0f8a
+     *   - 20230915T223155647Z1b64098b-4ab7-43f6-afee-992304f198d8.20230914T223155650Zc8d9f4c5-6c5a-4b2d-9b1c-3d9d7a7c5c7c
+     */
+    dotted_order?: string;
 }
 export interface ExampleCreate extends BaseExample {
     id?: string;

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "langsmith",
-  "version": "0.0.66",
+  "version": "0.0.68",
   "description": "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform.",
+  "packageManager": "yarn@1.22.19",
   "files": [
     "dist/",
     "client.cjs",