@nocobase/plugin-ai 1.9.32 → 1.9.34

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/client.js

@@ -1,17 +1,19 @@
 import * as uuid from "uuid";
+import { LangSmithToOTELTranslator, } from "./experimental/otel/translator.js";
+import { getDefaultOTLPTracerComponents, getOTELTrace, getOTELContext, } from "./singletons/otel.js";
 import { AsyncCaller } from "./utils/async_caller.js";
 import { convertLangChainMessageToExample, isLangChainMessage, } from "./utils/messages.js";
-import { getEnvironmentVariable, getLangChainEnvVarsMetadata, getLangSmithEnvironmentVariable, getRuntimeEnvironment, } from "./utils/env.js";
+import { getEnvironmentVariable, getLangSmithEnvVarsMetadata, getLangSmithEnvironmentVariable, getRuntimeEnvironment, getOtelEnabled, getEnv, } from "./utils/env.js";
 import { __version__ } from "./index.js";
 import { assertUuid } from "./utils/_uuid.js";
 import { warnOnce } from "./utils/warn.js";
 import { parsePromptIdentifier } from "./utils/prompts.js";
 import { raiseForStatus } from "./utils/error.js";
-import { _getFetchImplementation } from "./singletons/fetch.js";
+import { _globalFetchImplementationIsNodeFetch, _getFetchImplementation, } from "./singletons/fetch.js";
 import { serialize as serializePayloadForTracing } from "./utils/fast-safe-stringify/index.js";
-export function mergeRuntimeEnvIntoRunCreate(run) {
+export function mergeRuntimeEnvIntoRun(run, cachedEnvVars) {
     const runtimeEnv = getRuntimeEnvironment();
-    const envVars = getLangChainEnvVarsMetadata();
+    const envVars = cachedEnvVars ?? getLangSmithEnvVarsMetadata();
     const extra = run.extra ?? {};
     const metadata = extra.metadata;
     run.extra = {
@@ -22,16 +24,20 @@ export function mergeRuntimeEnvIntoRunCreate(run) {
         },
         metadata: {
             ...envVars,
-            ...(envVars.revision_id || run.revision_id
-                ? { revision_id: run.revision_id ?? envVars.revision_id }
+            ...(envVars.revision_id || ("revision_id" in run && run.revision_id)
+                ? {
+                    revision_id: ("revision_id" in run ? run.revision_id : undefined) ??
+                        envVars.revision_id,
+                }
                 : {}),
             ...metadata,
         },
     };
     return run;
 }
-const getTracingSamplingRate = () => {
-    const samplingRateStr = getLangSmithEnvironmentVariable("TRACING_SAMPLING_RATE");
+const getTracingSamplingRate = (configRate) => {
+    const samplingRateStr = configRate?.toString() ??
+        getLangSmithEnvironmentVariable("TRACING_SAMPLING_RATE");
     if (samplingRateStr === undefined) {
         return undefined;
     }
@@ -65,7 +71,7 @@ function trimQuotes(str) {
 }
 const handle429 = async (response) => {
     if (response?.status === 429) {
-        const retryAfter = parseInt(response.headers.get("retry-after") ?? "30", 10) * 1000;
+        const retryAfter = parseInt(response.headers.get("retry-after") ?? "10", 10) * 1000;
         if (retryAfter > 0) {
             await new Promise((resolve) => setTimeout(resolve, retryAfter));
             // Return directly after calling this check
@@ -75,6 +81,13 @@ const handle429 = async (response) => {
     // Fall back to existing status checks
     return false;
 };
+function _formatFeedbackScore(score) {
+    if (typeof score === "number") {
+        // Truncate at 4 decimal places
+        return Number(score.toFixed(4));
+    }
+    return score;
+}
 export class AutoBatchQueue {
     constructor() {
         Object.defineProperty(this, "items", {
@@ -100,10 +113,13 @@ export class AutoBatchQueue {
             // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/Promise
             itemPromiseResolve = resolve;
         });
-        const size = serializePayloadForTracing(item.item).length;
+        const size = serializePayloadForTracing(item.item, `Serializing run with id: ${item.item.id}`).length;
         this.items.push({
             action: item.action,
             payload: item.item,
+            otelContext: item.otelContext,
+            apiKey: item.apiKey,
+            apiUrl: item.apiUrl,
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             itemPromiseResolve: itemPromiseResolve,
             itemPromise,
@@ -112,7 +128,7 @@ export class AutoBatchQueue {
         this.sizeBytes += size;
         return itemPromise;
     }
-    pop(upToSizeBytes) {
+    pop({ upToSizeBytes, upToSize, }) {
         if (upToSizeBytes < 1) {
             throw new Error("Number of bytes to pop off may not be less than 1.");
         }
@@ -120,7 +136,8 @@ export class AutoBatchQueue {
         let poppedSizeBytes = 0;
         // Pop items until we reach or exceed the size limit
         while (poppedSizeBytes + (this.peek()?.size ?? 0) < upToSizeBytes &&
-            this.items.length > 0) {
+            this.items.length > 0 &&
+            popped.length < upToSize) {
             const item = this.items.shift();
             if (item) {
                 popped.push(item);
@@ -137,15 +154,26 @@ export class AutoBatchQueue {
             this.sizeBytes -= item.size;
         }
         return [
-            popped.map((it) => ({ action: it.action, item: it.payload })),
+            popped.map((it) => ({
+                action: it.action,
+                item: it.payload,
+                otelContext: it.otelContext,
+                apiKey: it.apiKey,
+                apiUrl: it.apiUrl,
+            })),
             () => popped.forEach((it) => it.itemPromiseResolve()),
         ];
     }
 }
-// 20 MB
-export const DEFAULT_BATCH_SIZE_LIMIT_BYTES = 20_971_520;
-const SERVER_INFO_REQUEST_TIMEOUT = 2500;
+export const DEFAULT_UNCOMPRESSED_BATCH_SIZE_LIMIT_BYTES = 24 * 1024 * 1024;
+const SERVER_INFO_REQUEST_TIMEOUT_MS = 10000;
+/** Maximum number of operations to batch in a single request. */
+const DEFAULT_BATCH_SIZE_LIMIT = 100;
+const DEFAULT_API_URL = "https://api.smith.langchain.com";
 export class Client {
+    get _fetch() {
+        return this.fetchImplementation || _getFetchImplementation(this.debug);
+    }
     constructor(config = {}) {
         Object.defineProperty(this, "apiKey", {
             enumerable: true,
@@ -165,6 +193,12 @@ export class Client {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "workspaceId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "caller", {
             enumerable: true,
             configurable: true,
@@ -243,6 +277,12 @@ export class Client {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "batchSizeLimit", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "fetchOptions", {
             enumerable: true,
             configurable: true,
@@ -286,8 +326,38 @@ export class Client {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "langSmithToOTELTranslator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fetchImplementation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cachedLSEnvVarsForMetadata", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "multipartStreamingDisabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "debug", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: getEnvironmentVariable("LANGSMITH_DEBUG") === "true"
+        });
         const defaultConfig = Client.getDefaultClientConfig();
-        this.tracingSampleRate = getTracingSamplingRate();
+        this.tracingSampleRate = getTracingSamplingRate(config.tracingSamplingRate);
         this.apiUrl = trimQuotes(config.apiUrl ?? defaultConfig.apiUrl) ?? "";
         if (this.apiUrl.endsWith("/")) {
             this.apiUrl = this.apiUrl.slice(0, -1);
@@ -297,18 +367,26 @@ export class Client {
         if (this.webUrl?.endsWith("/")) {
             this.webUrl = this.webUrl.slice(0, -1);
         }
+        this.workspaceId = trimQuotes(config.workspaceId ?? getLangSmithEnvironmentVariable("WORKSPACE_ID"));
         this.timeout_ms = config.timeout_ms ?? 90_000;
-        this.caller = new AsyncCaller(config.callerOptions ?? {});
+        this.caller = new AsyncCaller({
+            ...(config.callerOptions ?? {}),
+            maxRetries: 4,
+            debug: config.debug ?? this.debug,
+        });
         this.traceBatchConcurrency =
             config.traceBatchConcurrency ?? this.traceBatchConcurrency;
         if (this.traceBatchConcurrency < 1) {
             throw new Error("Trace batch concurrency must be positive.");
         }
+        this.debug = config.debug ?? this.debug;
+        this.fetchImplementation = config.fetchImplementation;
         this.batchIngestCaller = new AsyncCaller({
             maxRetries: 2,
             maxConcurrency: this.traceBatchConcurrency,
             ...(config.callerOptions ?? {}),
             onFailedResponseHook: handle429,
+            debug: config.debug ?? this.debug,
         });
         this.hideInputs =
             config.hideInputs ?? config.anonymizer ?? defaultConfig.hideInputs;
@@ -318,13 +396,18 @@ export class Client {
         this.blockOnRootRunFinalization =
             config.blockOnRootRunFinalization ?? this.blockOnRootRunFinalization;
         this.batchSizeBytesLimit = config.batchSizeBytesLimit;
+        this.batchSizeLimit = config.batchSizeLimit;
         this.fetchOptions = config.fetchOptions || {};
         this.manualFlushMode = config.manualFlushMode ?? this.manualFlushMode;
+        if (getOtelEnabled()) {
+            this.langSmithToOTELTranslator = new LangSmithToOTELTranslator();
+        }
+        // Cache metadata env vars once during construction to avoid repeatedly scanning process.env
+        this.cachedLSEnvVarsForMetadata = getLangSmithEnvVarsMetadata();
     }
     static getDefaultClientConfig() {
         const apiKey = getLangSmithEnvironmentVariable("API_KEY");
-        const apiUrl = getLangSmithEnvironmentVariable("ENDPOINT") ??
-            "https://api.smith.langchain.com";
+        const apiUrl = getLangSmithEnvironmentVariable("ENDPOINT") ?? DEFAULT_API_URL;
         const hideInputs = getLangSmithEnvironmentVariable("HIDE_INPUTS") === "true";
         const hideOutputs = getLangSmithEnvironmentVariable("HIDE_OUTPUTS") === "true";
         return {
@@ -376,9 +459,17 @@ export class Client {
         if (this.apiKey) {
             headers["x-api-key"] = `${this.apiKey}`;
         }
+        if (this.workspaceId) {
+            headers["x-tenant-id"] = this.workspaceId;
+        }
         return headers;
     }
-    processInputs(inputs) {
+    _getPlatformEndpointPath(path) {
+        // Check if apiUrl already ends with /v1 or /v1/ to avoid double /v1/v1/ paths
+        const needsV1Prefix = this.apiUrl.slice(-3) !== "/v1" && this.apiUrl.slice(-4) !== "/v1/";
+        return needsV1Prefix ? `/v1/platform/${path}` : `/platform/${path}`;
+    }
+    async processInputs(inputs) {
         if (this.hideInputs === false) {
             return inputs;
         }
@@ -390,7 +481,7 @@ export class Client {
         }
         return inputs;
     }
-    processOutputs(outputs) {
+    async processOutputs(outputs) {
         if (this.hideOutputs === false) {
             return outputs;
         }
@@ -402,26 +493,29 @@ export class Client {
         }
         return outputs;
     }
-    prepareRunCreateOrUpdateInputs(run) {
+    async prepareRunCreateOrUpdateInputs(run) {
         const runParams = { ...run };
         if (runParams.inputs !== undefined) {
-            runParams.inputs = this.processInputs(runParams.inputs);
+            runParams.inputs = await this.processInputs(runParams.inputs);
         }
         if (runParams.outputs !== undefined) {
-            runParams.outputs = this.processOutputs(runParams.outputs);
+            runParams.outputs = await this.processOutputs(runParams.outputs);
         }
         return runParams;
     }
     async _getResponse(path, queryParams) {
         const paramsString = queryParams?.toString() ?? "";
         const url = `${this.apiUrl}${path}?${paramsString}`;
-        const response = await this.caller.call(_getFetchImplementation(), url, {
-            method: "GET",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(url, {
+                method: "GET",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, `fetch ${path}`);
+            return res;
         });
-        await raiseForStatus(response, `Failed to fetch ${path}`);
         return response;
     }
     async _get(path, queryParams) {
@@ -435,13 +529,16 @@ export class Client {
             queryParams.set("offset", String(offset));
             queryParams.set("limit", String(limit));
             const url = `${this.apiUrl}${path}?${queryParams}`;
-            const response = await this.caller.call(_getFetchImplementation(), url, {
-                method: "GET",
-                headers: this.headers,
-                signal: AbortSignal.timeout(this.timeout_ms),
-                ...this.fetchOptions,
+            const response = await this.caller.call(async () => {
+                const res = await this._fetch(url, {
+                    method: "GET",
+                    headers: this.headers,
+                    signal: AbortSignal.timeout(this.timeout_ms),
+                    ...this.fetchOptions,
+                });
+                await raiseForStatus(res, `fetch ${path}`);
+                return res;
             });
-            await raiseForStatus(response, `Failed to fetch ${path}`);
             const items = transform
                 ? transform(await response.json())
                 : await response.json();
@@ -458,12 +555,17 @@ export class Client {
     async *_getCursorPaginatedList(path, body = null, requestMethod = "POST", dataKey = "runs") {
         const bodyParams = body ? { ...body } : {};
         while (true) {
-            const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}${path}`, {
-                method: requestMethod,
-                headers: { ...this.headers, "Content-Type": "application/json" },
-                signal: AbortSignal.timeout(this.timeout_ms),
-                ...this.fetchOptions,
-                body: JSON.stringify(bodyParams),
+            const body = JSON.stringify(bodyParams);
+            const response = await this.caller.call(async () => {
+                const res = await this._fetch(`${this.apiUrl}${path}`, {
+                    method: requestMethod,
+                    headers: { ...this.headers, "Content-Type": "application/json" },
+                    signal: AbortSignal.timeout(this.timeout_ms),
+                    ...this.fetchOptions,
+                    body,
+                });
+                await raiseForStatus(res, `fetch ${path}`);
+                return res;
             });
             const responseBody = await response.json();
             if (!responseBody) {
@@ -483,6 +585,13 @@ export class Client {
             bodyParams.cursor = cursors.next;
         }
     }
+    // Allows mocking for tests
+    _shouldSample() {
+        if (this.tracingSampleRate === undefined) {
+            return true;
+        }
+        return Math.random() < this.tracingSampleRate;
+    }
     _filterForSampling(runs, patch = false) {
         if (this.tracingSampleRate === undefined) {
             return runs;
@@ -490,25 +599,36 @@ export class Client {
         if (patch) {
             const sampled = [];
             for (const run of runs) {
-                if (!this.filteredPostUuids.has(run.id)) {
+                if (!this.filteredPostUuids.has(run.trace_id)) {
                     sampled.push(run);
                 }
-                else {
-                    this.filteredPostUuids.delete(run.id);
+                else if (run.id === run.trace_id) {
+                    this.filteredPostUuids.delete(run.trace_id);
                 }
             }
             return sampled;
         }
         else {
+            // For new runs, sample at trace level to maintain consistency
             const sampled = [];
             for (const run of runs) {
-                if ((run.id !== run.trace_id &&
-                    !this.filteredPostUuids.has(run.trace_id)) ||
-                    Math.random() < this.tracingSampleRate) {
-                    sampled.push(run);
+                const traceId = run.trace_id ?? run.id;
+                // If we've already made a decision about this trace, follow it
+                if (this.filteredPostUuids.has(traceId)) {
+                    continue;
+                }
+                // For new traces, apply sampling
+                if (run.id === traceId) {
+                    if (this._shouldSample()) {
+                        sampled.push(run);
+                    }
+                    else {
+                        this.filteredPostUuids.add(traceId);
+                    }
                 }
                 else {
-                    this.filteredPostUuids.add(run.id);
+                    // Child runs follow their trace's sampling decision
+                    sampled.push(run);
                 }
             }
             return sampled;
@@ -518,83 +638,163 @@ export class Client {
         const serverInfo = await this._ensureServerInfo();
         return (this.batchSizeBytesLimit ??
             serverInfo.batch_ingest_config?.size_limit_bytes ??
-            DEFAULT_BATCH_SIZE_LIMIT_BYTES);
+            DEFAULT_UNCOMPRESSED_BATCH_SIZE_LIMIT_BYTES);
+    }
+    /**
+     * Get the maximum number of operations to batch in a single request.
+     */
+    async _getBatchSizeLimit() {
+        const serverInfo = await this._ensureServerInfo();
+        return (this.batchSizeLimit ??
+            serverInfo.batch_ingest_config?.size_limit ??
+            DEFAULT_BATCH_SIZE_LIMIT);
     }
-    async _getMultiPartSupport() {
+    async _getDatasetExamplesMultiPartSupport() {
         const serverInfo = await this._ensureServerInfo();
         return (serverInfo.instance_flags?.dataset_examples_multipart_enabled ?? false);
     }
-    drainAutoBatchQueue(batchSizeLimit) {
+    drainAutoBatchQueue({ batchSizeLimitBytes, batchSizeLimit, }) {
         const promises = [];
         while (this.autoBatchQueue.items.length > 0) {
-            const [batch, done] = this.autoBatchQueue.pop(batchSizeLimit);
+            const [batch, done] = this.autoBatchQueue.pop({
+                upToSizeBytes: batchSizeLimitBytes,
+                upToSize: batchSizeLimit,
+            });
             if (!batch.length) {
                 done();
                 break;
             }
-            const batchPromise = this._processBatch(batch, done).catch(console.error);
-            promises.push(batchPromise);
+            const batchesByDestination = batch.reduce((acc, item) => {
+                const apiUrl = item.apiUrl ?? this.apiUrl;
+                const apiKey = item.apiKey ?? this.apiKey;
+                const isDefault = item.apiKey === this.apiKey && item.apiUrl === this.apiUrl;
+                const batchKey = isDefault ? "default" : `${apiUrl}|${apiKey}`;
+                if (!acc[batchKey]) {
+                    acc[batchKey] = [];
+                }
+                acc[batchKey].push(item);
+                return acc;
+            }, {});
+            const batchPromises = [];
+            for (const [batchKey, batch] of Object.entries(batchesByDestination)) {
+                const batchPromise = this._processBatch(batch, {
+                    apiUrl: batchKey === "default" ? undefined : batchKey.split("|")[0],
+                    apiKey: batchKey === "default" ? undefined : batchKey.split("|")[1],
+                });
+                batchPromises.push(batchPromise);
+            }
+            // Wait for all batches to complete, then call the overall done callback
+            const allBatchesPromise = Promise.all(batchPromises).finally(done);
+            promises.push(allBatchesPromise);
         }
         return Promise.all(promises);
     }
-    async _processBatch(batch, done) {
+    async _processBatch(batch, options) {
         if (!batch.length) {
-            done();
             return;
         }
         try {
-            const ingestParams = {
-                runCreates: batch
-                    .filter((item) => item.action === "create")
-                    .map((item) => item.item),
-                runUpdates: batch
-                    .filter((item) => item.action === "update")
-                    .map((item) => item.item),
-            };
-            const serverInfo = await this._ensureServerInfo();
-            if (serverInfo?.batch_ingest_config?.use_multipart_endpoint) {
-                await this.multipartIngestRuns(ingestParams);
+            if (this.langSmithToOTELTranslator !== undefined) {
+                this._sendBatchToOTELTranslator(batch);
             }
             else {
-                await this.batchIngestRuns(ingestParams);
+                const ingestParams = {
+                    runCreates: batch
+                        .filter((item) => item.action === "create")
+                        .map((item) => item.item),
+                    runUpdates: batch
+                        .filter((item) => item.action === "update")
+                        .map((item) => item.item),
+                };
+                const serverInfo = await this._ensureServerInfo();
+                if (serverInfo?.batch_ingest_config?.use_multipart_endpoint) {
+                    const useGzip = serverInfo?.instance_flags?.gzip_body_enabled;
+                    await this.multipartIngestRuns(ingestParams, { ...options, useGzip });
+                }
+                else {
+                    await this.batchIngestRuns(ingestParams, options);
+                }
             }
         }
-        finally {
-            done();
+        catch (e) {
+            console.error("Error exporting batch:", e);
+        }
+    }
+    _sendBatchToOTELTranslator(batch) {
+        if (this.langSmithToOTELTranslator !== undefined) {
+            const otelContextMap = new Map();
+            const operations = [];
+            for (const item of batch) {
+                if (item.item.id && item.otelContext) {
+                    otelContextMap.set(item.item.id, item.otelContext);
+                    if (item.action === "create") {
+                        operations.push({
+                            operation: "post",
+                            id: item.item.id,
+                            trace_id: item.item.trace_id ?? item.item.id,
+                            run: item.item,
+                        });
+                    }
+                    else {
+                        operations.push({
+                            operation: "patch",
+                            id: item.item.id,
+                            trace_id: item.item.trace_id ?? item.item.id,
+                            run: item.item,
+                        });
+                    }
+                }
+            }
+            this.langSmithToOTELTranslator.exportBatch(operations, otelContextMap);
         }
     }
     async processRunOperation(item) {
         clearTimeout(this.autoBatchTimeout);
         this.autoBatchTimeout = undefined;
-        if (item.action === "create") {
-            item.item = mergeRuntimeEnvIntoRunCreate(item.item);
-        }
+        item.item = mergeRuntimeEnvIntoRun(item.item, this.cachedLSEnvVarsForMetadata);
         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) {
-            void this.drainAutoBatchQueue(sizeLimitBytes);
+        const sizeLimit = await this._getBatchSizeLimit();
+        if (this.autoBatchQueue.sizeBytes > sizeLimitBytes ||
+            this.autoBatchQueue.items.length > sizeLimit) {
+            void this.drainAutoBatchQueue({
+                batchSizeLimitBytes: sizeLimitBytes,
+                batchSizeLimit: sizeLimit,
+            });
         }
         if (this.autoBatchQueue.items.length > 0) {
             this.autoBatchTimeout = setTimeout(() => {
                 this.autoBatchTimeout = undefined;
-                void this.drainAutoBatchQueue(sizeLimitBytes);
+                void this.drainAutoBatchQueue({
+                    batchSizeLimitBytes: sizeLimitBytes,
+                    batchSizeLimit: sizeLimit,
+                });
             }, this.autoBatchAggregationDelayMs);
         }
         return itemPromise;
     }
     async _getServerInfo() {
-        const response = await _getFetchImplementation()(`${this.apiUrl}/info`, {
-            method: "GET",
-            headers: { Accept: "application/json" },
-            signal: AbortSignal.timeout(SERVER_INFO_REQUEST_TIMEOUT),
-            ...this.fetchOptions,
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/info`, {
+                method: "GET",
+                headers: { Accept: "application/json" },
+                signal: AbortSignal.timeout(SERVER_INFO_REQUEST_TIMEOUT_MS),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "get server info");
+            return res;
         });
-        await raiseForStatus(response, "get server info");
-        return response.json();
+        const json = await response.json();
+        if (this.debug) {
+            console.log("\n=== LangSmith Server Configuration ===\n" +
+                JSON.stringify(json, null, 2) +
+                "\n");
+        }
+        return json;
     }
     async _ensureServerInfo() {
         if (this._getServerInfoPromise === undefined) {
@@ -604,7 +804,7 @@ export class Client {
                         this._serverInfo = await this._getServerInfo();
                     }
                     catch (e) {
-                        console.warn(`[WARNING]: LangSmith failed to fetch info on supported operations. Falling back to batch operations and default limits.`);
+                        console.warn(`[LANGSMITH]: Failed to fetch info on supported operations. Falling back to batch operations and default limits. Info: ${e.status ?? "Unspecified status code"} ${e.message}`);
                     }
                 }
                 return this._serverInfo ?? {};
@@ -628,16 +828,34 @@ export class Client {
      */
     async flush() {
         const sizeLimitBytes = await this._getBatchSizeLimitBytes();
-        await this.drainAutoBatchQueue(sizeLimitBytes);
+        const sizeLimit = await this._getBatchSizeLimit();
+        await this.drainAutoBatchQueue({
+            batchSizeLimitBytes: sizeLimitBytes,
+            batchSizeLimit: sizeLimit,
+        });
     }
-    async createRun(run) {
+    _cloneCurrentOTELContext() {
+        const otel_trace = getOTELTrace();
+        const otel_context = getOTELContext();
+        if (this.langSmithToOTELTranslator !== undefined) {
+            const currentSpan = otel_trace.getActiveSpan();
+            if (currentSpan) {
+                return otel_trace.setSpan(otel_context.active(), currentSpan);
+            }
+        }
+        return undefined;
+    }
+    async createRun(run, options) {
         if (!this._filterForSampling([run]).length) {
             return;
         }
-        const headers = { ...this.headers, "Content-Type": "application/json" };
+        const headers = {
+            ...this.headers,
+            "Content-Type": "application/json",
+        };
         const session_name = run.project_name;
         delete run.project_name;
-        const runCreate = this.prepareRunCreateOrUpdateInputs({
+        const runCreate = await this.prepareRunCreateOrUpdateInputs({
             session_name,
             ...run,
             start_time: run.start_time ?? Date.now(),
@@ -645,32 +863,46 @@ export class Client {
         if (this.autoBatchTracing &&
             runCreate.trace_id !== undefined &&
             runCreate.dotted_order !== undefined) {
+            const otelContext = this._cloneCurrentOTELContext();
             void this.processRunOperation({
                 action: "create",
                 item: runCreate,
+                otelContext,
+                apiKey: options?.apiKey,
+                apiUrl: options?.apiUrl,
             }).catch(console.error);
             return;
         }
-        const mergedRunCreateParam = mergeRuntimeEnvIntoRunCreate(runCreate);
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/runs`, {
-            method: "POST",
-            headers,
-            body: serializePayloadForTracing(mergedRunCreateParam),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const mergedRunCreateParam = mergeRuntimeEnvIntoRun(runCreate, this.cachedLSEnvVarsForMetadata);
+        if (options?.apiKey !== undefined) {
+            headers["x-api-key"] = options.apiKey;
+        }
+        if (options?.workspaceId !== undefined) {
+            headers["x-tenant-id"] = options.workspaceId;
+        }
+        const body = serializePayloadForTracing(mergedRunCreateParam, `Creating run with id: ${mergedRunCreateParam.id}`);
+        await this.caller.call(async () => {
+            const res = await this._fetch(`${options?.apiUrl ?? this.apiUrl}/runs`, {
+                method: "POST",
+                headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "create run", true);
+            return res;
         });
-        await raiseForStatus(response, "create run", true);
     }
     /**
      * Batch ingest/upsert multiple runs in the Langsmith system.
      * @param runs
      */
-    async batchIngestRuns({ runCreates, runUpdates, }) {
+    async batchIngestRuns({ runCreates, runUpdates, }, options) {
         if (runCreates === undefined && runUpdates === undefined) {
             return;
         }
-        let preparedCreateParams = runCreates?.map((create) => this.prepareRunCreateOrUpdateInputs(create)) ?? [];
-        let preparedUpdateParams = runUpdates?.map((update) => this.prepareRunCreateOrUpdateInputs(update)) ?? [];
+        let preparedCreateParams = await Promise.all(runCreates?.map((create) => this.prepareRunCreateOrUpdateInputs(create)) ?? []);
+        let preparedUpdateParams = await Promise.all(runUpdates?.map((update) => this.prepareRunCreateOrUpdateInputs(update)) ?? []);
         if (preparedCreateParams.length > 0 && preparedUpdateParams.length > 0) {
             const createById = preparedCreateParams.reduce((params, run) => {
                 if (!run.id) {
@@ -695,8 +927,8 @@ export class Client {
             preparedUpdateParams = standaloneUpdates;
         }
         const rawBatch = {
-            post: this._filterForSampling(preparedCreateParams),
-            patch: this._filterForSampling(preparedUpdateParams, true),
+            post: preparedCreateParams,
+            patch: preparedUpdateParams,
         };
         if (!rawBatch.post.length && !rawBatch.patch.length) {
             return;
@@ -710,34 +942,45 @@ export class Client {
             const batchItems = rawBatch[key].reverse();
             let batchItem = batchItems.pop();
             while (batchItem !== undefined) {
+                // Type is wrong but this is a deprecated code path anyway
                 batchChunks[key].push(batchItem);
                 batchItem = batchItems.pop();
             }
         }
         if (batchChunks.post.length > 0 || batchChunks.patch.length > 0) {
-            await this._postBatchIngestRuns(serializePayloadForTracing(batchChunks));
+            const runIds = batchChunks.post
+                .map((item) => item.id)
+                .concat(batchChunks.patch.map((item) => item.id))
+                .join(",");
+            await this._postBatchIngestRuns(serializePayloadForTracing(batchChunks, `Ingesting runs with ids: ${runIds}`), options);
         }
     }
-    async _postBatchIngestRuns(body) {
+    async _postBatchIngestRuns(body, options) {
         const headers = {
             ...this.headers,
             "Content-Type": "application/json",
             Accept: "application/json",
         };
-        const response = await this.batchIngestCaller.call(_getFetchImplementation(), `${this.apiUrl}/runs/batch`, {
-            method: "POST",
-            headers,
-            body: body,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        if (options?.apiKey !== undefined) {
+            headers["x-api-key"] = options.apiKey;
+        }
+        await this.batchIngestCaller.call(async () => {
+            const res = await this._fetch(`${options?.apiUrl ?? this.apiUrl}/runs/batch`, {
+                method: "POST",
+                headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "batch create run", true);
+            return res;
         });
-        await raiseForStatus(response, "batch create run", true);
     }
     /**
      * Batch ingest/upsert multiple runs in the Langsmith system.
      * @param runs
      */
-    async multipartIngestRuns({ runCreates, runUpdates, }) {
+    async multipartIngestRuns({ runCreates, runUpdates, }, options) {
         if (runCreates === undefined && runUpdates === undefined) {
             return;
         }
@@ -745,7 +988,7 @@ export class Client {
         const allAttachments = {};
         let preparedCreateParams = [];
         for (const create of runCreates ?? []) {
-            const preparedCreate = this.prepareRunCreateOrUpdateInputs(create);
+            const preparedCreate = await this.prepareRunCreateOrUpdateInputs(create);
             if (preparedCreate.id !== undefined &&
                 preparedCreate.attachments !== undefined) {
                 allAttachments[preparedCreate.id] = preparedCreate.attachments;
@@ -755,7 +998,7 @@ export class Client {
         }
         let preparedUpdateParams = [];
         for (const update of runUpdates ?? []) {
-            preparedUpdateParams.push(this.prepareRunCreateOrUpdateInputs(update));
+            preparedUpdateParams.push(await this.prepareRunCreateOrUpdateInputs(update));
         }
         // require trace_id and dotted_order
         const invalidRunCreate = preparedCreateParams.find((runCreate) => {
@@ -807,10 +1050,10 @@ export class Client {
         ]) {
             for (const originalPayload of payloads) {
                 // collect fields to be sent as separate parts
-                const { inputs, outputs, events, attachments, ...payload } = originalPayload;
-                const fields = { inputs, outputs, events };
+                const { inputs, outputs, events, extra, error, serialized, attachments, ...payload } = originalPayload;
+                const fields = { inputs, outputs, events, extra, error, serialized };
                 // encode the main run payload
-                const stringifiedPayload = serializePayloadForTracing(payload);
+                const stringifiedPayload = serializePayloadForTracing(payload, `Serializing for multipart ingestion of run with id: ${payload.id}`);
                 accumulatedParts.push({
                     name: `${method}.${payload.id}`,
                     payload: new Blob([stringifiedPayload], {
@@ -822,7 +1065,7 @@ export class Client {
                     if (value === undefined) {
                         continue;
                     }
-                    const stringifiedValue = serializePayloadForTracing(value);
+                    const stringifiedValue = serializePayloadForTracing(value, `Serializing ${key} for multipart ingestion of run with id: ${payload.id}`);
                     accumulatedParts.push({
                         name: `${method}.${payload.id}.${key}`,
                         payload: new Blob([stringifiedValue], {
@@ -864,53 +1107,144 @@ export class Client {
                 accumulatedContext.push(`trace=${payload.trace_id},id=${payload.id}`);
             }
         }
-        await this._sendMultipartRequest(accumulatedParts, accumulatedContext.join("; "));
-    }
-    async _sendMultipartRequest(parts, context) {
-        try {
-            // Create multipart form data manually using Blobs
-            const boundary = "----LangSmithFormBoundary" + Math.random().toString(36).slice(2);
-            const chunks = [];
-            for (const part of parts) {
-                // Add field boundary
-                chunks.push(new Blob([`--${boundary}\r\n`]));
-                chunks.push(new Blob([
-                    `Content-Disposition: form-data; name="${part.name}"\r\n`,
-                    `Content-Type: ${part.payload.type}\r\n\r\n`,
-                ]));
-                chunks.push(part.payload);
-                chunks.push(new Blob(["\r\n"]));
-            }
-            // Add final boundary
-            chunks.push(new Blob([`--${boundary}--\r\n`]));
-            // Combine all chunks into a single Blob
-            const body = new Blob(chunks);
-            // Convert Blob to ArrayBuffer for compatibility
-            const arrayBuffer = await body.arrayBuffer();
-            const res = await this.batchIngestCaller.call(_getFetchImplementation(), `${this.apiUrl}/runs/multipart`, {
-                method: "POST",
-                headers: {
+        await this._sendMultipartRequest(accumulatedParts, accumulatedContext.join("; "), options);
+    }
+    async _createNodeFetchBody(parts, boundary) {
+        // Create multipart form data manually using Blobs
+        const chunks = [];
+        for (const part of parts) {
+            // Add field boundary
+            chunks.push(new Blob([`--${boundary}\r\n`]));
+            chunks.push(new Blob([
+                `Content-Disposition: form-data; name="${part.name}"\r\n`,
+                `Content-Type: ${part.payload.type}\r\n\r\n`,
+            ]));
+            chunks.push(part.payload);
+            chunks.push(new Blob(["\r\n"]));
+        }
+        // Add final boundary
+        chunks.push(new Blob([`--${boundary}--\r\n`]));
+        // Combine all chunks into a single Blob
+        const body = new Blob(chunks);
+        // Convert Blob to ArrayBuffer for compatibility
+        const arrayBuffer = await body.arrayBuffer();
+        return arrayBuffer;
+    }
+    async _createMultipartStream(parts, boundary) {
+        const encoder = new TextEncoder();
+        // Create a ReadableStream for streaming the multipart data
+        // Only do special handling if we're using node-fetch
+        const stream = new ReadableStream({
+            async start(controller) {
+                // Helper function to write a chunk to the stream
+                const writeChunk = async (chunk) => {
+                    if (typeof chunk === "string") {
+                        controller.enqueue(encoder.encode(chunk));
+                    }
+                    else {
+                        controller.enqueue(chunk);
+                    }
+                };
+                // Write each part to the stream
+                for (const part of parts) {
+                    // Write boundary and headers
+                    await writeChunk(`--${boundary}\r\n`);
+                    await writeChunk(`Content-Disposition: form-data; name="${part.name}"\r\n`);
+                    await writeChunk(`Content-Type: ${part.payload.type}\r\n\r\n`);
+                    // Write the payload
+                    const payloadStream = part.payload.stream();
+                    const reader = payloadStream.getReader();
+                    try {
+                        let result;
+                        while (!(result = await reader.read()).done) {
+                            controller.enqueue(result.value);
+                        }
+                    }
+                    finally {
+                        reader.releaseLock();
+                    }
+                    await writeChunk("\r\n");
+                }
+                // Write final boundary
+                await writeChunk(`--${boundary}--\r\n`);
+                controller.close();
+            },
+        });
+        return stream;
+    }
+    async _sendMultipartRequest(parts, context, options) {
+        // Create multipart form data boundary
+        const boundary = "----LangSmithFormBoundary" + Math.random().toString(36).slice(2);
+        const isNodeFetch = _globalFetchImplementationIsNodeFetch();
+        const buildBuffered = () => this._createNodeFetchBody(parts, boundary);
+        const buildStream = () => this._createMultipartStream(parts, boundary);
+        const sendWithRetry = async (bodyFactory) => {
+            return this.batchIngestCaller.call(async () => {
+                const body = await bodyFactory();
+                const headers = {
                     ...this.headers,
                     "Content-Type": `multipart/form-data; boundary=${boundary}`,
-                },
-                body: arrayBuffer,
-                signal: AbortSignal.timeout(this.timeout_ms),
-                ...this.fetchOptions,
+                };
+                if (options?.apiKey !== undefined) {
+                    headers["x-api-key"] = options.apiKey;
+                }
+                let transformedBody = body;
+                if (options?.useGzip &&
+                    typeof body === "object" &&
+                    "pipeThrough" in body) {
+                    transformedBody = body.pipeThrough(new CompressionStream("gzip"));
+                    headers["Content-Encoding"] = "gzip";
+                }
+                const response = await this._fetch(`${options?.apiUrl ?? this.apiUrl}/runs/multipart`, {
+                    method: "POST",
+                    headers,
+                    body: transformedBody,
+                    duplex: "half",
+                    signal: AbortSignal.timeout(this.timeout_ms),
+                    ...this.fetchOptions,
+                });
+                await raiseForStatus(response, `Failed to send multipart request`, true);
+                return response;
             });
-            await raiseForStatus(res, "ingest multipart runs", true);
+        };
+        try {
+            let res;
+            let streamedAttempt = false;
+            // attempt stream only if not disabled and not using node-fetch or Bun
+            if (!isNodeFetch &&
+                !this.multipartStreamingDisabled &&
+                getEnv() !== "bun") {
+                streamedAttempt = true;
+                res = await sendWithRetry(buildStream);
+            }
+            else {
+                res = await sendWithRetry(buildBuffered);
+            }
+            // if stream fails, fallback to buffered body
+            if ((!this.multipartStreamingDisabled || streamedAttempt) &&
+                res.status === 422 &&
+                (options?.apiUrl ?? this.apiUrl) !== DEFAULT_API_URL) {
+                console.warn(`Streaming multipart upload to ${options?.apiUrl ?? this.apiUrl}/runs/multipart failed. ` +
+                    `This usually means the host does not support chunked uploads. ` +
+                    `Retrying with a buffered upload for operation "${context}".`);
+                // Disable streaming for future requests
+                this.multipartStreamingDisabled = true;
+                // retry with fully-buffered body
+                res = await sendWithRetry(buildBuffered);
+            }
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (e) {
             console.warn(`${e.message.trim()}\n\nContext: ${context}`);
         }
     }
-    async updateRun(runId, run) {
+    async updateRun(runId, run, options) {
         assertUuid(runId);
         if (run.inputs) {
-            run.inputs = this.processInputs(run.inputs);
+            run.inputs = await this.processInputs(run.inputs);
         }
         if (run.outputs) {
-            run.outputs = this.processOutputs(run.outputs);
+            run.outputs = await this.processOutputs(run.outputs);
         }
         // TODO: Untangle types
         const data = { ...run, id: runId };
@@ -920,34 +1254,60 @@ export class Client {
         if (this.autoBatchTracing &&
             data.trace_id !== undefined &&
             data.dotted_order !== undefined) {
+            const otelContext = this._cloneCurrentOTELContext();
             if (run.end_time !== undefined &&
                 data.parent_run_id === undefined &&
                 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);
+                await this.processRunOperation({
+                    action: "update",
+                    item: data,
+                    otelContext,
+                    apiKey: options?.apiKey,
+                    apiUrl: options?.apiUrl,
+                }).catch(console.error);
                 return;
             }
             else {
-                void this.processRunOperation({ action: "update", item: data }).catch(console.error);
+                void this.processRunOperation({
+                    action: "update",
+                    item: data,
+                    otelContext,
+                    apiKey: options?.apiKey,
+                    apiUrl: options?.apiUrl,
+                }).catch(console.error);
             }
             return;
         }
-        const headers = { ...this.headers, "Content-Type": "application/json" };
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/runs/${runId}`, {
-            method: "PATCH",
-            headers,
-            body: serializePayloadForTracing(run),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const headers = {
+            ...this.headers,
+            "Content-Type": "application/json",
+        };
+        if (options?.apiKey !== undefined) {
+            headers["x-api-key"] = options.apiKey;
+        }
+        if (options?.workspaceId !== undefined) {
+            headers["x-tenant-id"] = options.workspaceId;
+        }
+        const body = serializePayloadForTracing(run, `Serializing payload to update run with id: ${runId}`);
+        await this.caller.call(async () => {
+            const res = await this._fetch(`${options?.apiUrl ?? this.apiUrl}/runs/${runId}`, {
+                method: "PATCH",
+                headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "update run", true);
+            return res;
         });
-        await raiseForStatus(response, "update run", true);
     }
     async readRun(runId, { loadChildRuns } = { loadChildRuns: false }) {
         assertUuid(runId);
         let run = await this._get(`/runs/${runId}`);
-        if (loadChildRuns && run.child_run_ids) {
+        if (loadChildRuns) {
             run = await this._loadChildRuns(run);
         }
         return run;
@@ -986,7 +1346,11 @@ export class Client {
         }
     }
     async _loadChildRuns(run) {
-        const childRuns = await toArray(this.listRuns({ id: run.child_run_ids }));
+        const childRuns = await toArray(this.listRuns({
+            isRoot: false,
+            projectId: run.session_id,
+            traceId: run.trace_id,
+        }));
         const treemap = {};
         const runs = {};
         // TODO: make dotted order required when the migration finishes
@@ -996,11 +1360,14 @@ export class Client {
                 childRun.parent_run_id === undefined) {
                 throw new Error(`Child run ${childRun.id} has no parent`);
             }
-            if (!(childRun.parent_run_id in treemap)) {
-                treemap[childRun.parent_run_id] = [];
+            if (childRun.dotted_order?.startsWith(run.dotted_order ?? "") &&
+                childRun.id !== run.id) {
+                if (!(childRun.parent_run_id in treemap)) {
+                    treemap[childRun.parent_run_id] = [];
+                }
+                treemap[childRun.parent_run_id].push(childRun);
+                runs[childRun.id] = childRun;
             }
-            treemap[childRun.parent_run_id].push(childRun);
-            runs[childRun.id] = childRun;
         }
         run.child_runs = treemap[run.id] || [];
         for (const runId in treemap) {
@@ -1093,7 +1460,7 @@ export class Client {
      * });
      */
     async *listRuns(props) {
-        const { projectId, projectName, parentRunId, traceId, referenceExampleId, startTime, executionOrder, isRoot, runType, error, id, query, filter, traceFilter, treeFilter, limit, select, } = props;
+        const { projectId, projectName, parentRunId, traceId, referenceExampleId, startTime, executionOrder, isRoot, runType, error, id, query, filter, traceFilter, treeFilter, limit, select, order, } = props;
         let projectIds = [];
         if (projectId) {
             projectIds = Array.isArray(projectId) ? projectId : [projectId];
@@ -1107,7 +1474,6 @@ export class Client {
         }
         const default_select = [
             "app_path",
-            "child_run_ids",
             "completion_cost",
             "completion_tokens",
             "dotted_order",
@@ -1152,7 +1518,11 @@ export class Client {
             trace: traceId,
             select: select ? select : default_select,
             is_root: isRoot,
+            order,
         };
+        if (body.select.includes("child_run_ids")) {
+            warnOnce("Deprecated: 'child_run_ids' in the listRuns select parameter is deprecated and will be removed in a future version.");
+        }
         let runsYielded = 0;
         for await (const runs of this._getCursorPaginatedList("/runs/query", body)) {
             if (limit) {
@@ -1172,6 +1542,53 @@ export class Client {
             }
         }
     }
+    async *listGroupRuns(props) {
+        const { projectId, projectName, groupBy, filter, startTime, endTime, limit, offset, } = props;
+        const sessionId = projectId || (await this.readProject({ projectName })).id;
+        const baseBody = {
+            session_id: sessionId,
+            group_by: groupBy,
+            filter,
+            start_time: startTime ? startTime.toISOString() : null,
+            end_time: endTime ? endTime.toISOString() : null,
+            limit: Number(limit) || 100,
+        };
+        let currentOffset = Number(offset) || 0;
+        const path = "/runs/group";
+        const url = `${this.apiUrl}${path}`;
+        while (true) {
+            const currentBody = {
+                ...baseBody,
+                offset: currentOffset,
+            };
+            // Remove undefined values from the payload
+            const filteredPayload = Object.fromEntries(Object.entries(currentBody).filter(([_, value]) => value !== undefined));
+            const body = JSON.stringify(filteredPayload);
+            const response = await this.caller.call(async () => {
+                const res = await this._fetch(url, {
+                    method: "POST",
+                    headers: { ...this.headers, "Content-Type": "application/json" },
+                    signal: AbortSignal.timeout(this.timeout_ms),
+                    ...this.fetchOptions,
+                    body,
+                });
+                await raiseForStatus(res, `Failed to fetch ${path}`);
+                return res;
+            });
+            const items = await response.json();
+            const { groups, total } = items;
+            if (groups.length === 0) {
+                break;
+            }
+            for (const thread of groups) {
+                yield thread;
+            }
+            currentOffset += groups.length;
+            if (currentOffset >= total) {
+                break;
+            }
+        }
+    }
     async getRunStats({ id, trace, parentRun, runType, projectNames, projectIds, referenceExampleIds, startTime, endTime, error, query, filter, traceFilter, treeFilter, isRoot, dataSourceType, }) {
         let projectIds_ = projectIds || [];
         if (projectNames) {
@@ -1199,12 +1616,17 @@ export class Client {
         };
         // Remove undefined values from the payload
         const filteredPayload = Object.fromEntries(Object.entries(payload).filter(([_, value]) => value !== undefined));
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/runs/stats`, {
-            method: "POST",
-            headers: this.headers,
-            body: JSON.stringify(filteredPayload),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const body = JSON.stringify(filteredPayload);
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/runs/stats`, {
+                method: "POST",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "get run stats");
+            return res;
         });
         const result = await response.json();
         return result;
@@ -1215,12 +1637,17 @@ export class Client {
             share_token: shareId || uuid.v4(),
         };
         assertUuid(runId);
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/runs/${runId}/share`, {
-            method: "PUT",
-            headers: this.headers,
-            body: JSON.stringify(data),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const body = JSON.stringify(data);
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/runs/${runId}/share`, {
+                method: "PUT",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "share run");
+            return res;
         });
         const result = await response.json();
         if (result === null || !("share_token" in result)) {
@@ -1230,21 +1657,28 @@ export class Client {
     }
     async unshareRun(runId) {
         assertUuid(runId);
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/runs/${runId}/share`, {
-            method: "DELETE",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/runs/${runId}/share`, {
+                method: "DELETE",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "unshare run", true);
+            return res;
         });
-        await raiseForStatus(response, "unshare run", true);
     }
     async readRunSharedLink(runId) {
         assertUuid(runId);
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/runs/${runId}/share`, {
-            method: "GET",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/runs/${runId}/share`, {
+                method: "GET",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "read run shared link");
+            return res;
         });
         const result = await response.json();
         if (result === null || !("share_token" in result)) {
@@ -1262,11 +1696,15 @@ export class Client {
             }
         }
         assertUuid(shareToken);
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/public/${shareToken}/runs${queryParams}`, {
-            method: "GET",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/public/${shareToken}/runs${queryParams}`, {
+                method: "GET",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "list shared runs");
+            return res;
         });
         const runs = await response.json();
         return runs;
@@ -1280,11 +1718,15 @@ export class Client {
             datasetId = dataset.id;
         }
         assertUuid(datasetId);
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/datasets/${datasetId}/share`, {
-            method: "GET",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/datasets/${datasetId}/share`, {
+                method: "GET",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "read dataset shared schema");
+            return res;
         });
         const shareSchema = await response.json();
         shareSchema.url = `${this.getHostUrl()}/public/${shareSchema.share_token}/d`;
@@ -1302,12 +1744,17 @@ export class Client {
             dataset_id: datasetId,
         };
         assertUuid(datasetId);
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/datasets/${datasetId}/share`, {
-            method: "PUT",
-            headers: this.headers,
-            body: JSON.stringify(data),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const body = JSON.stringify(data);
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/datasets/${datasetId}/share`, {
+                method: "PUT",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "share dataset");
+            return res;
         });
         const shareSchema = await response.json();
         shareSchema.url = `${this.getHostUrl()}/public/${shareSchema.share_token}/d`;
@@ -1315,21 +1762,28 @@ export class Client {
     }
     async unshareDataset(datasetId) {
         assertUuid(datasetId);
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/datasets/${datasetId}/share`, {
-            method: "DELETE",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/datasets/${datasetId}/share`, {
+                method: "DELETE",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "unshare dataset", true);
+            return res;
         });
-        await raiseForStatus(response, "unshare dataset", true);
     }
     async readSharedDataset(shareToken) {
         assertUuid(shareToken);
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/public/${shareToken}/datasets`, {
-            method: "GET",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/public/${shareToken}/datasets`, {
+                method: "GET",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "read shared dataset");
+            return res;
         });
         const dataset = await response.json();
         return dataset;
@@ -1356,16 +1810,22 @@ export class Client {
                 urlParams.append(key, value);
             }
         });
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/public/${shareToken}/examples?${urlParams.toString()}`, {
-            method: "GET",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/public/${shareToken}/examples?${urlParams.toString()}`, {
+                method: "GET",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "list shared examples");
+            return res;
         });
         const result = await response.json();
         if (!response.ok) {
             if ("detail" in result) {
-                throw new Error(`Failed to list shared examples.\nStatus: ${response.status}\nMessage: ${result.detail.join("\n")}`);
+                throw new Error(`Failed to list shared examples.\nStatus: ${response.status}\nMessage: ${Array.isArray(result.detail)
+                    ? result.detail.join("\n")
+                    : "Unspecified error"}`);
             }
             throw new Error(`Failed to list shared examples: ${response.status} ${response.statusText}`);
         }
@@ -1389,14 +1849,18 @@ export class Client {
         if (referenceDatasetId !== null) {
             body["reference_dataset_id"] = referenceDatasetId;
         }
-        const response = await this.caller.call(_getFetchImplementation(), endpoint, {
-            method: "POST",
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            body: JSON.stringify(body),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const serializedBody = JSON.stringify(body);
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(endpoint, {
+                method: "POST",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body: serializedBody,
+            });
+            await raiseForStatus(res, "create project");
+            return res;
         });
-        await raiseForStatus(response, "create project");
         const result = await response.json();
         return result;
     }
@@ -1406,20 +1870,23 @@ export class Client {
         if (metadata) {
             extra = { ...(extra || {}), metadata };
         }
-        const body = {
+        const body = JSON.stringify({
             name,
             extra,
             description,
             end_time: endTime ? new Date(endTime).toISOString() : null,
-        };
-        const response = await this.caller.call(_getFetchImplementation(), endpoint, {
-            method: "PATCH",
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            body: JSON.stringify(body),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
-        });
-        await raiseForStatus(response, "update project");
+        });
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(endpoint, {
+                method: "PATCH",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "update project");
+            return res;
+        });
         const result = await response.json();
         return result;
     }
@@ -1440,11 +1907,15 @@ export class Client {
         else {
             throw new Error("Must provide projectName or projectId");
         }
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}${path}?${params}`, {
-            method: "GET",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}${path}?${params}`, {
+                method: "GET",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "has project");
+            return res;
         });
         // consume the response body to release the connection
         // https://undici.nodejs.org/#/?id=garbage-collection
@@ -1523,7 +1994,7 @@ export class Client {
         }
         throw new Error("No projects found to resolve tenant.");
     }
-    async *listProjects({ projectIds, name, nameContains, referenceDatasetId, referenceDatasetName, referenceFree, metadata, } = {}) {
+    async *listProjects({ projectIds, name, nameContains, referenceDatasetId, referenceDatasetName, includeStats, datasetVersion, referenceFree, metadata, } = {}) {
         const params = new URLSearchParams();
         if (projectIds !== undefined) {
             for (const projectId of projectIds) {
@@ -1545,6 +2016,12 @@ export class Client {
             });
             params.append("reference_dataset", dataset.id);
         }
+        if (includeStats !== undefined) {
+            params.append("include_stats", includeStats.toString());
+        }
+        if (datasetVersion !== undefined) {
+            params.append("dataset_version", datasetVersion);
+        }
         if (referenceFree !== undefined) {
             params.append("reference_free", referenceFree.toString());
         }
@@ -1570,13 +2047,16 @@ export class Client {
             projectId_ = projectId;
         }
         assertUuid(projectId_);
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/sessions/${projectId_}`, {
-            method: "DELETE",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/sessions/${projectId_}`, {
+                method: "DELETE",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, `delete session ${projectId_} (${projectName})`, true);
+            return res;
         });
-        await raiseForStatus(response, `delete session ${projectId_} (${projectName})`, true);
     }
     async uploadCsv({ csvFile, fileName, inputKeys, outputKeys, description, dataType, name, }) {
         const url = `${this.apiUrl}/datasets/upload`;
@@ -1597,14 +2077,17 @@ export class Client {
         if (name) {
             formData.append("name", name);
         }
-        const response = await this.caller.call(_getFetchImplementation(), url, {
-            method: "POST",
-            headers: this.headers,
-            body: formData,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(url, {
+                method: "POST",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body: formData,
+            });
+            await raiseForStatus(res, "upload CSV");
+            return res;
         });
-        await raiseForStatus(response, "upload CSV");
         const result = await response.json();
         return result;
     }
@@ -1623,14 +2106,18 @@ export class Client {
         if (outputsSchema) {
             body.outputs_schema_definition = outputsSchema;
         }
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/datasets`, {
-            method: "POST",
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            body: JSON.stringify(body),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const serializedBody = JSON.stringify(body);
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/datasets`, {
+                method: "POST",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body: serializedBody,
+            });
+            await raiseForStatus(res, "create dataset");
+            return res;
         });
-        await raiseForStatus(response, "create dataset");
         const result = await response.json();
         return result;
     }
@@ -1638,14 +2125,14 @@ export class Client {
         let path = "/datasets";
         // limit to 1 result
         const params = new URLSearchParams({ limit: "1" });
-        if (datasetId !== undefined && datasetName !== undefined) {
+        if (datasetId && datasetName) {
             throw new Error("Must provide either datasetName or datasetId, not both");
         }
-        else if (datasetId !== undefined) {
+        else if (datasetId) {
             assertUuid(datasetId);
             path += `/${datasetId}`;
         }
-        else if (datasetName !== undefined) {
+        else if (datasetName) {
             params.append("name", datasetName);
         }
         else {
@@ -1755,14 +2242,18 @@ export class Client {
         }
         const _datasetId = datasetId ?? (await this.readDataset({ datasetName })).id;
         assertUuid(_datasetId);
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/datasets/${_datasetId}`, {
-            method: "PATCH",
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            body: JSON.stringify(update),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
-        });
-        await raiseForStatus(response, "update dataset");
+        const body = JSON.stringify(update);
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/datasets/${_datasetId}`, {
+                method: "PATCH",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "update dataset");
+            return res;
+        });
         return (await response.json());
     }
     /**
@@ -1787,17 +2278,21 @@ export class Client {
         }
         const _datasetId = datasetId ?? (await this.readDataset({ datasetName })).id;
         assertUuid(_datasetId);
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/datasets/${_datasetId}/tags`, {
-            method: "PUT",
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            body: JSON.stringify({
-                as_of: typeof asOf === "string" ? asOf : asOf.toISOString(),
-                tag,
-            }),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const body = JSON.stringify({
+            as_of: typeof asOf === "string" ? asOf : asOf.toISOString(),
+            tag,
+        });
+        await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/datasets/${_datasetId}/tags`, {
+                method: "PUT",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "update dataset tags", true);
+            return res;
         });
-        await raiseForStatus(response, "update dataset tags");
     }
     async deleteDataset({ datasetId, datasetName, }) {
         let path = "/datasets";
@@ -1816,14 +2311,16 @@ export class Client {
         else {
             throw new Error("Must provide datasetName or datasetId");
         }
-        const response = await this.caller.call(_getFetchImplementation(), this.apiUrl + path, {
-            method: "DELETE",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        await this.caller.call(async () => {
+            const res = await this._fetch(this.apiUrl + path, {
+                method: "DELETE",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, `delete ${path}`, true);
+            return res;
         });
-        await raiseForStatus(response, `delete ${path}`);
-        await response.json();
     }
     async indexDataset({ datasetId, datasetName, tag, }) {
         let datasetId_ = datasetId;
@@ -1841,14 +2338,18 @@ export class Client {
         const data = {
             tag: tag,
         };
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/datasets/${datasetId_}/index`, {
-            method: "POST",
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            body: JSON.stringify(data),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
-        });
-        await raiseForStatus(response, "index dataset");
+        const body = JSON.stringify(data);
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/datasets/${datasetId_}/index`, {
+                method: "POST",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "index dataset");
+            return res;
+        });
         await response.json();
     }
     /**
@@ -1890,14 +2391,18 @@ export class Client {
             data["filter"] = filter;
         }
         assertUuid(datasetId);
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/datasets/${datasetId}/search`, {
-            method: "POST",
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            body: JSON.stringify(data),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
-        });
-        await raiseForStatus(response, "fetch similar examples");
+        const body = JSON.stringify(data);
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/datasets/${datasetId}/search`, {
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                method: "POST",
+                body,
+            });
+            await raiseForStatus(res, "fetch similar examples");
+            return res;
+        });
         const result = await response.json();
         return result["examples"];
     }
@@ -2109,14 +2614,16 @@ export class Client {
     async deleteExample(exampleId) {
         assertUuid(exampleId);
         const path = `/examples/${exampleId}`;
-        const response = await this.caller.call(_getFetchImplementation(), this.apiUrl + path, {
-            method: "DELETE",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        await this.caller.call(async () => {
+            const res = await this._fetch(this.apiUrl + path, {
+                method: "DELETE",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, `delete ${path}`, true);
+            return res;
         });
-        await raiseForStatus(response, `delete ${path}`);
-        await response.json();
     }
     async updateExample(exampleIdOrUpdate, update) {
         let exampleId;
@@ -2188,13 +2695,16 @@ export class Client {
         if (tag !== undefined) {
             params.append("tag", tag);
         }
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/datasets/${resolvedDatasetId}/version?${params.toString()}`, {
-            method: "GET",
-            headers: { ...this.headers },
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/datasets/${resolvedDatasetId}/version?${params.toString()}`, {
+                method: "GET",
+                headers: { ...this.headers },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "read dataset version");
+            return res;
         });
-        await raiseForStatus(response, "read dataset version");
         return await response.json();
     }
     async listDatasetSplits({ datasetId, datasetName, asOf, }) {
@@ -2249,14 +2759,18 @@ export class Client {
             }),
             remove,
         };
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/datasets/${datasetId_}/splits`, {
-            method: "PUT",
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            body: JSON.stringify(data),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const body = JSON.stringify(data);
+        await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/datasets/${datasetId_}/splits`, {
+                method: "PUT",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "update dataset splits", true);
+            return res;
         });
-        await raiseForStatus(response, "update dataset splits", true);
     }
     /**
      * @deprecated This method is deprecated and will be removed in future LangSmith versions, use `evaluate` from `langsmith/evaluation` instead.
@@ -2305,7 +2819,7 @@ export class Client {
             id: feedbackId ?? uuid.v4(),
             run_id: runId,
             key,
-            score,
+            score: _formatFeedbackScore(score),
             value,
             correction,
             comment,
@@ -2314,21 +2828,25 @@ export class Client {
             feedbackConfig,
             session_id: projectId,
         };
+        const body = JSON.stringify(feedback);
         const url = `${this.apiUrl}/feedback`;
-        const response = await this.caller.call(_getFetchImplementation(), url, {
-            method: "POST",
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            body: JSON.stringify(feedback),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
-        });
-        await raiseForStatus(response, "create feedback", true);
+        await this.caller.call(async () => {
+            const res = await this._fetch(url, {
+                method: "POST",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "create feedback", true);
+            return res;
+        });
         return feedback;
     }
     async updateFeedback(feedbackId, { score, value, correction, comment, }) {
         const feedbackUpdate = {};
         if (score !== undefined && score !== null) {
-            feedbackUpdate["score"] = score;
+            feedbackUpdate["score"] = _formatFeedbackScore(score);
         }
         if (value !== undefined && value !== null) {
             feedbackUpdate["value"] = value;
@@ -2340,14 +2858,18 @@ export class Client {
             feedbackUpdate["comment"] = comment;
         }
         assertUuid(feedbackId);
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/feedback/${feedbackId}`, {
-            method: "PATCH",
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            body: JSON.stringify(feedbackUpdate),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const body = JSON.stringify(feedbackUpdate);
+        await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/feedback/${feedbackId}`, {
+                method: "PATCH",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "update feedback", true);
+            return res;
         });
-        await raiseForStatus(response, "update feedback", true);
     }
     async readFeedback(feedbackId) {
         assertUuid(feedbackId);
@@ -2358,19 +2880,24 @@ export class Client {
     async deleteFeedback(feedbackId) {
         assertUuid(feedbackId);
         const path = `/feedback/${feedbackId}`;
-        const response = await this.caller.call(_getFetchImplementation(), this.apiUrl + path, {
-            method: "DELETE",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        await this.caller.call(async () => {
+            const res = await this._fetch(this.apiUrl + path, {
+                method: "DELETE",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, `delete ${path}`, true);
+            return res;
         });
-        await raiseForStatus(response, `delete ${path}`);
-        await response.json();
     }
     async *listFeedback({ runIds, feedbackKeys, feedbackSourceTypes, } = {}) {
         const queryParams = new URLSearchParams();
         if (runIds) {
-            queryParams.append("run", runIds.join(","));
+            for (const runId of runIds) {
+                assertUuid(runId);
+                queryParams.append("run", runId);
+            }
         }
         if (feedbackKeys) {
             for (const key of feedbackKeys) {
@@ -2420,15 +2947,19 @@ export class Client {
                 hours: 3,
             };
         }
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/feedback/tokens`, {
-            method: "POST",
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            body: JSON.stringify(body),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const serializedBody = JSON.stringify(body);
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/feedback/tokens`, {
+                method: "POST",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body: serializedBody,
+            });
+            await raiseForStatus(res, "create presigned feedback token");
+            return res;
         });
-        const result = await response.json();
-        return result;
+        return await response.json();
     }
     async createComparativeExperiment({ name, experimentIds, referenceDatasetId, createdAt, description, metadata, id, }) {
         if (experimentIds.length === 0) {
@@ -2453,14 +2984,19 @@ export class Client {
         };
         if (metadata)
             body.extra["metadata"] = metadata;
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/datasets/comparative`, {
-            method: "POST",
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            body: JSON.stringify(body),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const serializedBody = JSON.stringify(body);
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/datasets/comparative`, {
+                method: "POST",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body: serializedBody,
+            });
+            await raiseForStatus(res, "create comparative experiment");
+            return res;
         });
-        return await response.json();
+        return response.json();
     }
     /**
      * Retrieves a list of presigned feedback tokens for a given run ID.
@@ -2562,37 +3098,44 @@ export class Client {
      * @returns The created AnnotationQueue object
      */
     async createAnnotationQueue(options) {
-        const { name, description, queueId } = options;
+        const { name, description, queueId, rubricInstructions } = options;
         const body = {
             name,
             description,
             id: queueId || uuid.v4(),
+            rubric_instructions: rubricInstructions,
         };
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/annotation-queues`, {
-            method: "POST",
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            body: JSON.stringify(Object.fromEntries(Object.entries(body).filter(([_, v]) => v !== undefined))),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const serializedBody = JSON.stringify(Object.fromEntries(Object.entries(body).filter(([_, v]) => v !== undefined)));
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/annotation-queues`, {
+                method: "POST",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body: serializedBody,
+            });
+            await raiseForStatus(res, "create annotation queue");
+            return res;
         });
-        await raiseForStatus(response, "create annotation queue");
-        const data = await response.json();
-        return data;
+        return response.json();
     }
     /**
      * Read an annotation queue with the specified queue ID.
      * @param queueId - The ID of the annotation queue to read
-     * @returns The AnnotationQueue object
+     * @returns The AnnotationQueueWithDetails object
      */
     async readAnnotationQueue(queueId) {
-        // TODO: Replace when actual endpoint is added
-        const queueIteratorResult = await this.listAnnotationQueues({
-            queueIds: [queueId],
-        }).next();
-        if (queueIteratorResult.done) {
-            throw new Error(`Annotation queue with ID ${queueId} not found`);
-        }
-        return queueIteratorResult.value;
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}`, {
+                method: "GET",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "read annotation queue");
+            return res;
+        });
+        return response.json();
     }
     /**
      * Update an annotation queue with the specified queue ID.
@@ -2602,28 +3145,39 @@ export class Client {
      * @param options.description - The new description for the annotation queue
      */
     async updateAnnotationQueue(queueId, options) {
-        const { name, description } = options;
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}`, {
-            method: "PATCH",
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            body: JSON.stringify({ name, description }),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const { name, description, rubricInstructions } = options;
+        const body = JSON.stringify({
+            name,
+            description,
+            rubric_instructions: rubricInstructions,
+        });
+        await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}`, {
+                method: "PATCH",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "update annotation queue", true);
+            return res;
         });
-        await raiseForStatus(response, "update annotation queue");
     }
     /**
      * Delete an annotation queue with the specified queue ID.
      * @param queueId - The ID of the annotation queue to delete
      */
     async deleteAnnotationQueue(queueId) {
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}`, {
-            method: "DELETE",
-            headers: { ...this.headers, Accept: "application/json" },
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}`, {
+                method: "DELETE",
+                headers: { ...this.headers, Accept: "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "delete annotation queue", true);
+            return res;
         });
-        await raiseForStatus(response, "delete annotation queue");
     }
     /**
      * Add runs to an annotation queue with the specified queue ID.
@@ -2631,14 +3185,18 @@ export class Client {
      * @param runIds - The IDs of the runs to be added to the annotation queue
      */
     async addRunsToAnnotationQueue(queueId, runIds) {
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}/runs`, {
-            method: "POST",
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            body: JSON.stringify(runIds.map((id, i) => assertUuid(id, `runIds[${i}]`).toString())),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const body = JSON.stringify(runIds.map((id, i) => assertUuid(id, `runIds[${i}]`).toString()));
+        await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}/runs`, {
+                method: "POST",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "add runs to annotation queue", true);
+            return res;
         });
-        await raiseForStatus(response, "add runs to annotation queue");
     }
     /**
      * Get a run from an annotation queue at the specified index.
@@ -2649,14 +3207,17 @@ export class Client {
      */
     async getRunFromAnnotationQueue(queueId, index) {
         const baseUrl = `/annotation-queues/${assertUuid(queueId, "queueId")}/run`;
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}${baseUrl}/${index}`, {
-            method: "GET",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}${baseUrl}/${index}`, {
+                method: "GET",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "get run from annotation queue");
+            return res;
         });
-        await raiseForStatus(response, "get run from annotation queue");
-        return await response.json();
+        return response.json();
     }
     /**
      * Delete a run from an an annotation queue.
@@ -2664,27 +3225,33 @@ export class Client {
      * @param queueRunId - The ID of the run to delete from the annotation queue
      */
     async deleteRunFromAnnotationQueue(queueId, queueRunId) {
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}/runs/${assertUuid(queueRunId, "queueRunId")}`, {
-            method: "DELETE",
-            headers: { ...this.headers, Accept: "application/json" },
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}/runs/${assertUuid(queueRunId, "queueRunId")}`, {
+                method: "DELETE",
+                headers: { ...this.headers, Accept: "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "delete run from annotation queue", true);
+            return res;
         });
-        await raiseForStatus(response, "delete run from annotation queue");
     }
     /**
      * Get the size of an annotation queue.
      * @param queueId - The ID of the annotation queue
      */
     async getSizeFromAnnotationQueue(queueId) {
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}/size`, {
-            method: "GET",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/annotation-queues/${assertUuid(queueId, "queueId")}/size`, {
+                method: "GET",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "get size from annotation queue");
+            return res;
         });
-        await raiseForStatus(response, "get size from annotation queue");
-        return await response.json();
+        return response.json();
     }
     async _currentTenantIsOwner(owner) {
         const settings = await this._getSettings();
@@ -2697,22 +3264,17 @@ export class Client {
       Requested tenant: ${owner}`);
     }
     async _getLatestCommitHash(promptOwnerAndName) {
-        const res = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/commits/${promptOwnerAndName}/?limit=${1}&offset=${0}`, {
-            method: "GET",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
-        });
-        const json = await res.json();
-        if (!res.ok) {
-            const detail = typeof json.detail === "string"
-                ? json.detail
-                : JSON.stringify(json.detail);
-            const error = new Error(`Error ${res.status}: ${res.statusText}\n${detail}`);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            error.statusCode = res.status;
-            throw error;
-        }
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/commits/${promptOwnerAndName}/?limit=${1}&offset=${0}`, {
+                method: "GET",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "get latest commit hash");
+            return res;
+        });
+        const json = await response.json();
         if (json.commits.length === 0) {
             return undefined;
         }
@@ -2720,15 +3282,19 @@ export class Client {
     }
     async _likeOrUnlikePrompt(promptIdentifier, like) {
         const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/likes/${owner}/${promptName}`, {
-            method: "POST",
-            body: JSON.stringify({ like: like }),
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
-        });
-        await raiseForStatus(response, `${like ? "like" : "unlike"} prompt`);
-        return await response.json();
+        const body = JSON.stringify({ like: like });
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/likes/${owner}/${promptName}`, {
+                method: "POST",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, `${like ? "like" : "unlike"} prompt`);
+            return res;
+        });
+        return response.json();
     }
     async _getPromptUrl(promptIdentifier) {
         const [owner, promptName, commitHash] = parsePromptIdentifier(promptIdentifier);
@@ -2782,18 +3348,21 @@ export class Client {
     }
     async getPrompt(promptIdentifier) {
         const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/repos/${owner}/${promptName}`, {
-            method: "GET",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/repos/${owner}/${promptName}`, {
+                method: "GET",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            if (res?.status === 404) {
+                return null;
+            }
+            await raiseForStatus(res, "get prompt");
+            return res;
         });
-        if (response.status === 404) {
-            return null;
-        }
-        await raiseForStatus(response, "get prompt");
-        const result = await response.json();
-        if (result.repo) {
+        const result = await response?.json();
+        if (result?.repo) {
             return result.repo;
         }
         else {
@@ -2804,7 +3373,7 @@ export class Client {
         const settings = await this._getSettings();
         if (options?.isPublic && !settings.tenant_handle) {
             throw new Error(`Cannot create a public prompt without first\n
-        creating a LangChain Hub handle. 
+        creating a LangChain Hub handle.
         You can add a handle by creating a public prompt at:\n
         https://smith.langchain.com/prompts`);
         }
@@ -2819,14 +3388,18 @@ export class Client {
             ...(options?.tags && { tags: options.tags }),
             is_public: !!options?.isPublic,
         };
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/repos/`, {
-            method: "POST",
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            body: JSON.stringify(data),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
-        });
-        await raiseForStatus(response, "create prompt");
+        const body = JSON.stringify(data);
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/repos/`, {
+                method: "POST",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "create prompt");
+            return res;
+        });
         const { repo } = await response.json();
         return repo;
     }
@@ -2842,14 +3415,18 @@ export class Client {
             manifest: JSON.parse(JSON.stringify(object)),
             parent_commit: resolvedParentCommitHash,
         };
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/commits/${owner}/${promptName}`, {
-            method: "POST",
-            headers: { ...this.headers, "Content-Type": "application/json" },
-            body: JSON.stringify(payload),
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
-        });
-        await raiseForStatus(response, "create commit");
+        const body = JSON.stringify(payload);
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/commits/${owner}/${promptName}`, {
+                method: "POST",
+                headers: { ...this.headers, "Content-Type": "application/json" },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "create commit");
+            return res;
+        });
         const result = await response.json();
         return this._getPromptUrl(`${owner}/${promptName}${result.commit_hash ? `:${result.commit_hash}` : ""}`);
     }
@@ -2862,8 +3439,8 @@ export class Client {
         return this._updateExamplesMultipart(datasetId, updates);
     }
     async _updateExamplesMultipart(datasetId, updates = []) {
-        if (!(await this._getMultiPartSupport())) {
-            throw new Error("Your LangSmith version does not allow using the multipart examples endpoint, please update to the latest version.");
+        if (!(await this._getDatasetExamplesMultiPartSupport())) {
+            throw new Error("Your LangSmith deployment does not allow using the multipart examples endpoint, please upgrade your deployment to the latest version.");
         }
         const formData = new FormData();
         for (const example of updates) {
@@ -2874,14 +3451,14 @@ export class Client {
                 ...(example.split && { split: example.split }),
             };
             // Add main example data
-            const stringifiedExample = serializePayloadForTracing(exampleBody);
+            const stringifiedExample = serializePayloadForTracing(exampleBody, `Serializing body for example with id: ${exampleId}`);
             const exampleBlob = new Blob([stringifiedExample], {
                 type: "application/json",
             });
             formData.append(exampleId, exampleBlob);
             // Add inputs if present
             if (example.inputs) {
-                const stringifiedInputs = serializePayloadForTracing(example.inputs);
+                const stringifiedInputs = serializePayloadForTracing(example.inputs, `Serializing inputs for example with id: ${exampleId}`);
                 const inputsBlob = new Blob([stringifiedInputs], {
                     type: "application/json",
                 });
@@ -2889,7 +3466,7 @@ export class Client {
             }
             // Add outputs if present
             if (example.outputs) {
-                const stringifiedOutputs = serializePayloadForTracing(example.outputs);
+                const stringifiedOutputs = serializePayloadForTracing(example.outputs, `Serializing outputs whle updating example with id: ${exampleId}`);
                 const outputsBlob = new Blob([stringifiedOutputs], {
                     type: "application/json",
                 });
@@ -2914,7 +3491,7 @@ export class Client {
                 }
             }
             if (example.attachments_operations) {
-                const stringifiedAttachmentsOperations = serializePayloadForTracing(example.attachments_operations);
+                const stringifiedAttachmentsOperations = serializePayloadForTracing(example.attachments_operations, `Serializing attachments while updating example with id: ${exampleId}`);
                 const attachmentsOperationsBlob = new Blob([stringifiedAttachmentsOperations], {
                     type: "application/json",
                 });
@@ -2922,13 +3499,18 @@ export class Client {
             }
         }
         const datasetIdToUse = datasetId ?? updates[0]?.dataset_id;
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/v1/platform/datasets/${datasetIdToUse}/examples`, {
-            method: "PATCH",
-            headers: this.headers,
-            body: formData,
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}${this._getPlatformEndpointPath(`datasets/${datasetIdToUse}/examples`)}`, {
+                method: "PATCH",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body: formData,
+            });
+            await raiseForStatus(res, "update examples");
+            return res;
         });
-        const result = await response.json();
-        return result;
+        return response.json();
     }
     /**
      * Upload examples with attachments using multipart form data.
@@ -2940,8 +3522,8 @@ export class Client {
         return this._uploadExamplesMultipart(datasetId, uploads);
     }
     async _uploadExamplesMultipart(datasetId, uploads = []) {
-        if (!(await this._getMultiPartSupport())) {
-            throw new Error("Your LangSmith version does not allow using the multipart examples endpoint, please update to the latest version.");
+        if (!(await this._getDatasetExamplesMultiPartSupport())) {
+            throw new Error("Your LangSmith deployment does not allow using the multipart examples endpoint, please upgrade your deployment to the latest version.");
         }
         const formData = new FormData();
         for (const example of uploads) {
@@ -2960,14 +3542,14 @@ export class Client {
                 }),
             };
             // Add main example data
-            const stringifiedExample = serializePayloadForTracing(exampleBody);
+            const stringifiedExample = serializePayloadForTracing(exampleBody, `Serializing body for uploaded example with id: ${exampleId}`);
             const exampleBlob = new Blob([stringifiedExample], {
                 type: "application/json",
             });
             formData.append(exampleId, exampleBlob);
             // Add inputs if present
             if (example.inputs) {
-                const stringifiedInputs = serializePayloadForTracing(example.inputs);
+                const stringifiedInputs = serializePayloadForTracing(example.inputs, `Serializing inputs for uploaded example with id: ${exampleId}`);
                 const inputsBlob = new Blob([stringifiedInputs], {
                     type: "application/json",
                 });
@@ -2975,7 +3557,7 @@ export class Client {
             }
             // Add outputs if present
             if (example.outputs) {
-                const stringifiedOutputs = serializePayloadForTracing(example.outputs);
+                const stringifiedOutputs = serializePayloadForTracing(example.outputs, `Serializing outputs for uploaded example with id: ${exampleId}`);
                 const outputsBlob = new Blob([stringifiedOutputs], {
                     type: "application/json",
                 });
@@ -3000,13 +3582,18 @@ export class Client {
                 }
             }
         }
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/v1/platform/datasets/${datasetId}/examples`, {
-            method: "POST",
-            headers: this.headers,
-            body: formData,
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}${this._getPlatformEndpointPath(`datasets/${datasetId}/examples`)}`, {
+                method: "POST",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body: formData,
+            });
+            await raiseForStatus(res, "upload examples");
+            return res;
         });
-        const result = await response.json();
-        return result;
+        return response.json();
     }
     async updatePrompt(promptIdentifier, options) {
         if (!(await this.promptExists(promptIdentifier))) {
@@ -3031,17 +3618,21 @@ export class Client {
         if (Object.keys(payload).length === 0) {
             throw new Error("No valid update options provided");
         }
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/repos/${owner}/${promptName}`, {
-            method: "PATCH",
-            body: JSON.stringify(payload),
-            headers: {
-                ...this.headers,
-                "Content-Type": "application/json",
-            },
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const body = JSON.stringify(payload);
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/repos/${owner}/${promptName}`, {
+                method: "PATCH",
+                headers: {
+                    ...this.headers,
+                    "Content-Type": "application/json",
+                },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body,
+            });
+            await raiseForStatus(res, "update prompt");
+            return res;
         });
-        await raiseForStatus(response, "update prompt");
         return response.json();
     }
     async deletePrompt(promptIdentifier) {
@@ -3052,23 +3643,30 @@ export class Client {
         if (!(await this._currentTenantIsOwner(owner))) {
             throw await this._ownerConflictError("delete a prompt", owner);
         }
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/repos/${owner}/${promptName}`, {
-            method: "DELETE",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/repos/${owner}/${promptName}`, {
+                method: "DELETE",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "delete prompt");
+            return res;
         });
-        return await response.json();
+        return response.json();
     }
     async pullPromptCommit(promptIdentifier, options) {
         const [owner, promptName, commitHash] = parsePromptIdentifier(promptIdentifier);
-        const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/commits/${owner}/${promptName}/${commitHash}${options?.includeModel ? "?include_model=true" : ""}`, {
-            method: "GET",
-            headers: this.headers,
-            signal: AbortSignal.timeout(this.timeout_ms),
-            ...this.fetchOptions,
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/commits/${owner}/${promptName}/${commitHash}${options?.includeModel ? "?include_model=true" : ""}`, {
+                method: "GET",
+                headers: this.headers,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "pull prompt commit");
+            return res;
         });
-        await raiseForStatus(response, "pull prompt commit");
         const result = await response.json();
         return {
             owner,
@@ -3221,15 +3819,18 @@ export class Client {
      *
      * @returns A promise that resolves once all currently pending traces have sent.
      */
-    awaitPendingTraceBatches() {
+    async 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([
+        await Promise.all([
             ...this.autoBatchQueue.items.map(({ itemPromise }) => itemPromise),
             this.batchIngestCaller.queue.onIdle(),
         ]);
+        if (this.langSmithToOTELTranslator !== undefined) {
+            await getDefaultOTLPTracerComponents()?.DEFAULT_LANGSMITH_SPAN_PROCESSOR?.forceFlush();
+        }
     }
 }
 function isExampleCreate(input) {