langsmith 0.5.19 → 0.6.0

package/dist/client.cjs

@@ -35,7 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = exports.AutoBatchQueue = exports.DEFAULT_MAX_SIZE_BYTES = exports.DEFAULT_UNCOMPRESSED_BATCH_SIZE_LIMIT_BYTES = void 0;
 exports.mergeRuntimeEnvIntoRun = mergeRuntimeEnvIntoRun;
-const uuid = __importStar(require("uuid"));
+const uuid = __importStar(require("./utils/uuid/src/index.cjs"));
 const translator_js_1 = require("./experimental/otel/translator.cjs");
 const otel_js_1 = require("./singletons/otel.cjs");
 const async_caller_js_1 = require("./utils/async_caller.cjs");
@@ -50,6 +50,13 @@ const index_js_2 = require("./utils/prompt_cache/index.cjs");
 const fsUtils = __importStar(require("./utils/fs.cjs"));
 const fetch_js_1 = require("./singletons/fetch.cjs");
 const index_js_3 = require("./utils/fast-safe-stringify/index.cjs");
+const serialize_worker_js_1 = require("./utils/serialize_worker.cjs");
+function assertPullPublicPromptAllowed(promptIdentifier, dangerouslyPullPublicPrompt) {
+    const [owner] = (0, prompts_js_1.parseHubIdentifier)(promptIdentifier);
+    if (owner !== "-" && !dangerouslyPullPublicPrompt) {
+        throw new Error("Pulling a public prompt by owner/name is disabled by default because prompts may contain untrusted serialized LangChain objects. If you trust this prompt, set `dangerouslyPullPublicPrompt: true` to acknowledge the risk.");
+    }
+}
 /**
  * Catches timestamps without a timezone suffix.
  */
@@ -189,7 +196,11 @@ class AutoBatchQueue {
             // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/Promise
             itemPromiseResolve = resolve;
         });
-        const size = (0, index_js_3.serialize)(item.item, `Serializing run with id: ${item.item.id}`).length;
+        // Use a cheap structural estimate for soft memory accounting (queue size
+        // limit and downstream async caller memory tracking). The exact
+        // serialization still happens later, off the hot path, when the batch is
+        // assembled for sending.
+        const size = (0, index_js_3.estimateSerializedSize)(item.item).size;
         // Check if adding this item would exceed the size limit
         // Allow the run if the queue is empty (to support large single traces)
         if (this.sizeBytes + size > this.maxSizeBytes && this.items.length > 0) {
@@ -253,9 +264,64 @@ class AutoBatchQueue {
 }
 exports.AutoBatchQueue = AutoBatchQueue;
 class Client {
+    get tracingMode() {
+        return this._tracingMode;
+    }
     get _fetch() {
         return this.fetchImplementation || (0, fetch_js_1._getFetchImplementation)(this.debug);
     }
+    /**
+     * Serialize a payload for tracing, optionally offloading the work to a
+     * Node worker thread when the runtime supports worker_threads.
+     *
+     * Falls back to synchronous serialization when:
+     *  - manualFlushMode is enabled (serverless: worker boot cost > benefit)
+     *  - worker_threads is unavailable (non-Node runtimes)
+     *  - the payload contains values that can't be structured-cloned across
+     *    threads (functions, non-cloneable class instances, streams, etc.)
+     *  - the worker throws for any other reason
+     *
+     * In all fallback cases the returned bytes are identical to the sync path.
+     */
+    _trackDrain(promise) {
+        this._pendingDrains.add(promise);
+        promise.finally(() => {
+            this._pendingDrains.delete(promise);
+        });
+    }
+    async _serializeBody(payload, errorContext) {
+        if (this.manualFlushMode) {
+            return (0, index_js_3.serialize)(payload, errorContext);
+        }
+        // Shape-aware gate: worker offload pays for itself only when the
+        // payload is dominated by one or more large strings (V8 can refcount
+        // those across isolates instead of copying). For structure-heavy
+        // payloads -- many keys, deep nesting, lots of small strings -- the
+        // structuredClone walk plus thread-hop cost exceeds the JSON.stringify
+        // cost we would pay inline, so we fall through to sync serialize.
+        if (!(0, serialize_worker_js_1.hasLargeString)(payload)) {
+            return (0, index_js_3.serialize)(payload, errorContext);
+        }
+        if (this._serializeWorker === undefined) {
+            this._serializeWorker = (0, serialize_worker_js_1.getSharedSerializeWorker)();
+        }
+        if (this._serializeWorker === null) {
+            return (0, index_js_3.serialize)(payload, errorContext);
+        }
+        try {
+            const bytes = await this._serializeWorker.serialize(payload);
+            if (bytes === null) {
+                // Worker subsystem unavailable; cache the null to skip re-entry.
+                this._serializeWorker = null;
+                return (0, index_js_3.serialize)(payload, errorContext);
+            }
+            return bytes;
+        }
+        catch {
+            // DataCloneError, worker crash, etc. Fall back silently.
+            return (0, index_js_3.serialize)(payload, errorContext);
+        }
+    }
     constructor(config = {}) {
         Object.defineProperty(this, "apiKey", {
             enumerable: true,
@@ -317,6 +383,12 @@ class Client {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "hideMetadata", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "omitTracedRuntimeInfo", {
             enumerable: true,
             configurable: true,
@@ -414,12 +486,35 @@ class Client {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "_serializeWorker", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Tracks in-flight drainAutoBatchQueue promises so awaitPendingTraceBatches
+         * can wait on them even if the flush involves async work (worker-thread
+         * serialize) that hasn't yet registered with batchIngestCaller.queue.
+         */
+        Object.defineProperty(this, "_pendingDrains", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
         Object.defineProperty(this, "langSmithToOTELTranslator", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "_tracingMode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "langsmith"
+        });
         Object.defineProperty(this, "fetchImplementation", {
             enumerable: true,
             configurable: true,
@@ -529,6 +624,7 @@ class Client {
             config.hideInputs ?? config.anonymizer ?? defaultConfig.hideInputs;
         this.hideOutputs =
             config.hideOutputs ?? config.anonymizer ?? defaultConfig.hideOutputs;
+        this.hideMetadata = config.hideMetadata ?? defaultConfig.hideMetadata;
         this.omitTracedRuntimeInfo = config.omitTracedRuntimeInfo ?? false;
         this.autoBatchTracing = config.autoBatchTracing ?? this.autoBatchTracing;
         this.autoBatchQueue = new AutoBatchQueue(maxMemory);
@@ -538,7 +634,8 @@ class Client {
         this.batchSizeLimit = config.batchSizeLimit;
         this.fetchOptions = config.fetchOptions || {};
         this.manualFlushMode = config.manualFlushMode ?? this.manualFlushMode;
-        if ((0, env_js_1.getOtelEnabled)()) {
+        this._tracingMode = (0, env_js_1.resolveTracingMode)(config.tracingMode);
+        if (this._tracingMode === "otel") {
             this.langSmithToOTELTranslator = new translator_js_1.LangSmithToOTELTranslator();
         }
         // Cache metadata env vars once during construction to avoid repeatedly scanning process.env
@@ -578,12 +675,14 @@ class Client {
         const apiUrl = (0, env_js_1.getLangSmithEnvironmentVariable)("ENDPOINT") ?? DEFAULT_API_URL;
         const hideInputs = (0, env_js_1.getLangSmithEnvironmentVariable)("HIDE_INPUTS") === "true";
         const hideOutputs = (0, env_js_1.getLangSmithEnvironmentVariable)("HIDE_OUTPUTS") === "true";
+        const hideMetadata = (0, env_js_1.getLangSmithEnvironmentVariable)("HIDE_METADATA") === "true";
         return {
             apiUrl: apiUrl,
             apiKey: apiKey,
             webUrl: undefined,
             hideInputs: hideInputs,
             hideOutputs: hideOutputs,
+            hideMetadata: hideMetadata,
         };
     }
     getHostUrl() {
@@ -615,6 +714,10 @@ class Client {
             this.webUrl = "https://aws.smith.langchain.com";
             return this.webUrl;
         }
+        else if (this.apiUrl.split(".", 1)[0].includes("apac")) {
+            this.webUrl = "https://apac.smith.langchain.com";
+            return this.webUrl;
+        }
         else if (this.apiUrl.split(".", 1)[0].includes("beta")) {
             this.webUrl = "https://beta.smith.langchain.com";
             return this.webUrl;
@@ -679,6 +782,18 @@ class Client {
         }
         return outputs;
     }
+    async processMetadata(metadata) {
+        if (this.hideMetadata === false) {
+            return metadata;
+        }
+        if (this.hideMetadata === true) {
+            return {};
+        }
+        if (typeof this.hideMetadata === "function") {
+            return this.hideMetadata(metadata);
+        }
+        return metadata;
+    }
     /**
      * Filter content from new_token events to prevent streaming LLM output
      * from being uploaded via events.
@@ -705,6 +820,12 @@ class Client {
         if (runParams.outputs !== undefined) {
             runParams.outputs = await this.processOutputs(runParams.outputs);
         }
+        if (runParams.extra != null && "metadata" in runParams.extra) {
+            runParams.extra = {
+                ...runParams.extra,
+                metadata: await this.processMetadata(runParams.extra.metadata),
+            };
+        }
         if (runParams.events !== undefined) {
             runParams.events = this._filterNewTokenEvents(runParams.events);
         }
@@ -1057,18 +1178,18 @@ class Client {
         const sizeLimit = await this._getBatchSizeLimit();
         if (this.autoBatchQueue.sizeBytes > sizeLimitBytes ||
             this.autoBatchQueue.items.length > sizeLimit) {
-            void this.drainAutoBatchQueue({
+            this._trackDrain(this.drainAutoBatchQueue({
                 batchSizeLimitBytes: sizeLimitBytes,
                 batchSizeLimit: sizeLimit,
-            });
+            }));
         }
         if (this.autoBatchQueue.items.length > 0) {
             this.autoBatchTimeout = setTimeout(() => {
                 this.autoBatchTimeout = undefined;
-                void this.drainAutoBatchQueue({
+                this._trackDrain(this.drainAutoBatchQueue({
                     batchSizeLimitBytes: sizeLimitBytes,
                     batchSizeLimit: sizeLimit,
-                });
+                }));
             }, this.autoBatchAggregationDelayMs);
         }
         return itemPromise;
@@ -1077,7 +1198,7 @@ class Client {
         const response = await this.caller.call(async () => {
             const res = await this._fetch(`${this.apiUrl}/info`, {
                 method: "GET",
-                headers: { Accept: "application/json" },
+                headers: { ...this._mergedHeaders, Accept: "application/json" },
                 signal: AbortSignal.timeout(SERVER_INFO_REQUEST_TIMEOUT_MS),
                 ...this.fetchOptions,
             });
@@ -1248,7 +1369,7 @@ class Client {
                 .map((item) => item.id)
                 .concat(batchChunks.patch.map((item) => item.id))
                 .join(",");
-            await this._postBatchIngestRuns((0, index_js_3.serialize)(batchChunks, `Ingesting runs with ids: ${runIds}`), options);
+            await this._postBatchIngestRuns(await this._serializeBody(batchChunks, `Ingesting runs with ids: ${runIds}`), options);
         }
     }
     async _postBatchIngestRuns(body, options) {
@@ -1349,7 +1470,7 @@ class Client {
                 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 = (0, index_js_3.serialize)(payload, `Serializing for multipart ingestion of run with id: ${payload.id}`);
+                const stringifiedPayload = await this._serializeBody(payload, `Serializing for multipart ingestion of run with id: ${payload.id}`);
                 accumulatedParts.push({
                     name: `${method}.${payload.id}`,
                     payload: new Blob([stringifiedPayload], {
@@ -1361,7 +1482,7 @@ class Client {
                     if (value === undefined) {
                         continue;
                     }
-                    const stringifiedValue = (0, index_js_3.serialize)(value, `Serializing ${key} for multipart ingestion of run with id: ${payload.id}`);
+                    const stringifiedValue = await this._serializeBody(value, `Serializing ${key} for multipart ingestion of run with id: ${payload.id}`);
                     accumulatedParts.push({
                         name: `${method}.${payload.id}.${key}`,
                         payload: new Blob([stringifiedValue], {
@@ -1552,6 +1673,12 @@ class Client {
         if (run.outputs) {
             run.outputs = await this.processOutputs(run.outputs);
         }
+        if (run.extra != null && "metadata" in run.extra) {
+            run.extra = {
+                ...run.extra,
+                metadata: await this.processMetadata(run.extra.metadata),
+            };
+        }
         if (run.events) {
             run.events = this._filterNewTokenEvents(run.events);
         }
@@ -2367,7 +2494,7 @@ class Client {
             // projectId querying
             return true;
         }
-        catch (e) {
+        catch (_e) {
             return false;
         }
     }
@@ -3788,7 +3915,7 @@ class Client {
         return json.commits[0].commit_hash;
     }
     async _likeOrUnlikePrompt(promptIdentifier, like) {
-        const [owner, promptName, _] = (0, prompts_js_1.parsePromptIdentifier)(promptIdentifier);
+        const [owner, promptName, _] = (0, prompts_js_1.parseHubIdentifier)(promptIdentifier);
         const body = JSON.stringify({ like: like });
         const response = await this.caller.call(async () => {
             const res = await this._fetch(`${this.apiUrl}/likes/${owner}/${promptName}`, {
@@ -3807,7 +3934,7 @@ class Client {
         return response.json();
     }
     async _getPromptUrl(promptIdentifier) {
-        const [owner, promptName, commitHash] = (0, prompts_js_1.parsePromptIdentifier)(promptIdentifier);
+        const [owner, promptName, commitHash] = (0, prompts_js_1.parseHubIdentifier)(promptIdentifier);
         if (!(await this._currentTenantIsOwner(owner))) {
             if (commitHash !== "latest") {
                 return `${this.getHostUrl()}/hub/${owner}/${promptName}/${commitHash.substring(0, 8)}`;
@@ -3899,7 +4026,7 @@ class Client {
      * ```
      */
     async *listCommits(promptIdentifier) {
-        const [owner, promptName, _] = (0, prompts_js_1.parsePromptIdentifier)(promptIdentifier);
+        const [owner, promptName, _] = (0, prompts_js_1.parseHubIdentifier)(promptIdentifier);
         for await (const commits of this._getPaginated(`/commits/${owner}/${promptName}/`, new URLSearchParams(), (res) => res.commits)) {
             yield* commits;
         }
@@ -3962,7 +4089,7 @@ class Client {
      * ```
      */
     async getPrompt(promptIdentifier) {
-        const [owner, promptName, _] = (0, prompts_js_1.parsePromptIdentifier)(promptIdentifier);
+        const [owner, promptName, _] = (0, prompts_js_1.parseHubIdentifier)(promptIdentifier);
         const response = await this.caller.call(async () => {
             const res = await this._fetch(`${this.apiUrl}/repos/${owner}/${promptName}`, {
                 method: "GET",
@@ -4019,7 +4146,7 @@ class Client {
         You can add a handle by creating a public prompt at:\n
         https://smith.langchain.com/prompts`);
         }
-        const [owner, promptName, _] = (0, prompts_js_1.parsePromptIdentifier)(promptIdentifier);
+        const [owner, promptName, _] = (0, prompts_js_1.parseHubIdentifier)(promptIdentifier);
         if (!(await this._currentTenantIsOwner(owner))) {
             throw await this._ownerConflictError("create a prompt", owner);
         }
@@ -4078,7 +4205,7 @@ class Client {
         if (!(await this.promptExists(promptIdentifier))) {
             throw new Error("Prompt does not exist, you must create it first.");
         }
-        const [owner, promptName, _] = (0, prompts_js_1.parsePromptIdentifier)(promptIdentifier);
+        const [owner, promptName, _] = (0, prompts_js_1.parseHubIdentifier)(promptIdentifier);
         const resolvedParentCommitHash = options?.parentCommitHash === "latest" || !options?.parentCommitHash
             ? await this._getLatestCommitHash(`${owner}/${promptName}`)
             : options?.parentCommitHash;
@@ -4276,7 +4403,7 @@ class Client {
         if (!(await this.promptExists(promptIdentifier))) {
             throw new Error("Prompt does not exist, you must create it first.");
         }
-        const [owner, promptName] = (0, prompts_js_1.parsePromptIdentifier)(promptIdentifier);
+        const [owner, promptName] = (0, prompts_js_1.parseHubIdentifier)(promptIdentifier);
         if (!(await this._currentTenantIsOwner(owner))) {
             throw await this._ownerConflictError("update a prompt", owner);
         }
@@ -4316,7 +4443,7 @@ class Client {
         if (!(await this.promptExists(promptIdentifier))) {
             throw new Error("Prompt does not exist, you must create it first.");
         }
-        const [owner, promptName, _] = (0, prompts_js_1.parsePromptIdentifier)(promptIdentifier);
+        const [owner, promptName, _] = (0, prompts_js_1.parseHubIdentifier)(promptIdentifier);
         if (!(await this._currentTenantIsOwner(owner))) {
             throw await this._ownerConflictError("delete a prompt", owner);
         }
@@ -4344,7 +4471,7 @@ class Client {
      * Fetch a prompt commit directly from the API (bypassing cache).
      */
     async _fetchPromptFromApi(promptIdentifier, options) {
-        const [owner, promptName, commitHash] = (0, prompts_js_1.parsePromptIdentifier)(promptIdentifier);
+        const [owner, promptName, commitHash] = (0, prompts_js_1.parseHubIdentifier)(promptIdentifier);
         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",
@@ -4362,9 +4489,28 @@ class Client {
             commit_hash: result.commit_hash,
             manifest: result.manifest,
             examples: result.examples,
+            hub_model_config: result.model_config,
+            hub_model_provider: result.model_provider,
         };
     }
+    /**
+     * Pull a prompt commit from the LangSmith API.
+     *
+     * Public prompts referenced by owner/name cross a trust boundary because the
+     * prompt manifest may contain serialized LangChain objects and configuration
+     * that affect runtime behavior. For example, a prompt can intentionally
+     * configure a model with a custom base URL, headers, model name, or other
+     * constructor arguments. These are supported features, but they also mean the
+     * prompt contents should be treated as executable configuration rather than
+     * plain text.
+     *
+     * Set `dangerouslyPullPublicPrompt: true` only after reviewing and trusting
+     * the prompt contents, not merely the publishing account. Prompts from your
+     * own or your organization's account can still be unsafe if that account or
+     * prompt was compromised.
+     */
     async pullPromptCommit(promptIdentifier, options) {
+        assertPullPublicPromptAllowed(promptIdentifier, options?.dangerouslyPullPublicPrompt);
         // Check cache first if not skipped
         const refreshFunc = this._fetchPromptFromApi.bind(this, promptIdentifier, options);
         if (!options?.skipCache && this._promptCache) {
@@ -4384,12 +4530,26 @@ class Client {
     /**
      * This method should not be used directly, use `import { pull } from "langchain/hub"` instead.
      * Using this method directly returns the JSON string of the prompt rather than a LangChain object.
+     *
+     * Public prompts referenced by owner/name cross a trust boundary because the
+     * prompt manifest may contain serialized LangChain objects and configuration
+     * that affect runtime behavior. For example, a prompt can intentionally
+     * configure a model with a custom base URL, headers, model name, or other
+     * constructor arguments. These are supported features, but they also mean the
+     * prompt contents should be treated as executable configuration rather than
+     * plain text.
+     *
+     * Set `dangerouslyPullPublicPrompt: true` only after reviewing and trusting
+     * the prompt contents, not merely the publishing account. Prompts from your
+     * own or your organization's account can still be unsafe if that account or
+     * prompt was compromised.
      * @private
      */
     async _pullPrompt(promptIdentifier, options) {
         const promptObject = await this.pullPromptCommit(promptIdentifier, {
             includeModel: options?.includeModel,
             skipCache: options?.skipCache,
+            dangerouslyPullPublicPrompt: options?.dangerouslyPullPublicPrompt,
         });
         const prompt = JSON.stringify(promptObject.manifest);
         return prompt;
@@ -4424,6 +4584,251 @@ class Client {
         });
         return url;
     }
+    /**
+     * Check if an agent repo exists.
+     */
+    async agentExists(identifier) {
+        const [owner, name] = (0, prompts_js_1.parseHubIdentifier)(identifier);
+        return this._repoExists(owner, name);
+    }
+    /**
+     * Check if a skill repo exists.
+     */
+    async skillExists(identifier) {
+        const [owner, name] = (0, prompts_js_1.parseHubIdentifier)(identifier);
+        return this._repoExists(owner, name);
+    }
+    /**
+     * Pull an agent directory from Hub.
+     * @param identifier The identifier (owner/name[:version]).
+     * @param options.version Commit hash or tag; overrides identifier's version.
+     */
+    async pullAgent(identifier, options) {
+        return (await this._pullDirectory(identifier, "agent", options?.version));
+    }
+    /**
+     * Pull a skill directory from Hub.
+     */
+    async pullSkill(identifier, options) {
+        return (await this._pullDirectory(identifier, "skill", options?.version));
+    }
+    /**
+     * Push an agent to Hub. Creates the repo if missing, patches metadata if
+     * provided, then commits the given files.
+     * @returns The URL of the resulting commit.
+     */
+    async pushAgent(identifier, options) {
+        return this._pushDirectory(identifier, "agent", options);
+    }
+    /**
+     * Push a skill to Hub.
+     */
+    async pushSkill(identifier, options) {
+        return this._pushDirectory(identifier, "skill", options);
+    }
+    /**
+     * Delete an agent and all its owned child file repos.
+     */
+    async deleteAgent(identifier) {
+        return this._deleteDirectory(identifier);
+    }
+    /**
+     * Delete a skill and all its owned child file repos.
+     */
+    async deleteSkill(identifier) {
+        return this._deleteDirectory(identifier);
+    }
+    /**
+     * List agent repos. Yields one at a time, auto-paginating.
+     */
+    async *listAgents(options) {
+        yield* this._listReposByType("agent", options);
+    }
+    /**
+     * List skill repos. Yields one at a time, auto-paginating.
+     */
+    async *listSkills(options) {
+        yield* this._listReposByType("skill", options);
+    }
+    async *_listReposByType(repoType, options) {
+        const params = new URLSearchParams();
+        params.append("repo_type", repoType);
+        params.append("is_archived", (!!options?.isArchived).toString());
+        if (options?.isPublic !== undefined) {
+            params.append("is_public", options.isPublic.toString());
+        }
+        if (options?.query) {
+            params.append("query", options.query);
+        }
+        for await (const repos of this._getPaginated("/repos", params, (res) => res.repos)) {
+            yield* repos;
+        }
+    }
+    async _pullDirectory(identifier, repoType, version) {
+        const [owner, name, parsedVersion] = (0, prompts_js_1.parseHubIdentifier)(identifier);
+        const resolvedVersion = version ?? (parsedVersion !== "latest" ? parsedVersion : undefined);
+        const url = new URL(`${this.apiUrl}/v1/platform/hub/repos/${owner}/${name}/directories`);
+        url.searchParams.set("repo_type", repoType);
+        if (resolvedVersion) {
+            url.searchParams.set("commit", resolvedVersion);
+        }
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(url.toString(), {
+                method: "GET",
+                headers: this._mergedHeaders,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await (0, error_js_1.raiseForStatus)(res, "pull directory");
+            return res;
+        });
+        return (await response.json());
+    }
+    async _pushDirectory(identifier, repoType, options) {
+        if (options.parentCommit !== undefined &&
+            (options.parentCommit.length < 8 || options.parentCommit.length > 64)) {
+            throw new Error("parent_commit must be 8-64 characters");
+        }
+        const [owner, name] = (0, prompts_js_1.parseHubIdentifier)(identifier);
+        if (!(await this._currentTenantIsOwner(owner))) {
+            throw await this._ownerConflictError(`push ${repoType}`, owner);
+        }
+        if (await this._repoExists(owner, name)) {
+            if (options.description !== undefined ||
+                options.readme !== undefined ||
+                options.tags !== undefined ||
+                options.isPublic !== undefined) {
+                await this._updateRepoMetadata(owner, name, options);
+            }
+        }
+        else {
+            const REPO_HANDLE_PATTERN = /^[a-z][a-z0-9-_]*$/;
+            if (!REPO_HANDLE_PATTERN.test(name)) {
+                throw new Error(`Invalid repo_handle ${JSON.stringify(name)}: must match ${REPO_HANDLE_PATTERN}`);
+            }
+            await this._createRepo(name, repoType, options);
+        }
+        const body = { files: options.files };
+        if (options.parentCommit) {
+            body.parent_commit = options.parentCommit;
+        }
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/v1/platform/hub/repos/${owner}/${name}/directories/commits`, {
+                method: "POST",
+                headers: {
+                    ...this._mergedHeaders,
+                    "Content-Type": "application/json",
+                },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body: JSON.stringify(body),
+            });
+            await (0, error_js_1.raiseForStatus)(res, `push ${repoType}`);
+            return res;
+        });
+        const data = (await response.json());
+        const commitHash = data.commit.commit_hash;
+        return `${this.getHostUrl()}/hub/${owner}/${name}:${commitHash.slice(0, 8)}`;
+    }
+    async _deleteDirectory(identifier) {
+        const [owner, name] = (0, prompts_js_1.parseHubIdentifier)(identifier);
+        if (!(await this._currentTenantIsOwner(owner))) {
+            throw await this._ownerConflictError("delete", owner);
+        }
+        await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/v1/platform/hub/repos/${owner}/${name}/directories`, {
+                method: "DELETE",
+                headers: this._mergedHeaders,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await (0, error_js_1.raiseForStatus)(res, "delete directory");
+            return res;
+        });
+    }
+    async _repoExists(owner, name) {
+        try {
+            await this.caller.call(async () => {
+                const res = await this._fetch(`${this.apiUrl}/repos/${owner}/${name}`, {
+                    method: "GET",
+                    headers: this._mergedHeaders,
+                    signal: AbortSignal.timeout(this.timeout_ms),
+                    ...this.fetchOptions,
+                });
+                await (0, error_js_1.raiseForStatus)(res, "check repo exists");
+                return res;
+            });
+            return true;
+        }
+        catch (e) {
+            if ((0, error_js_1.isLangSmithNotFoundError)(e)) {
+                return false;
+            }
+            throw e;
+        }
+    }
+    async _createRepo(name, repoType, options) {
+        const body = {
+            repo_handle: name,
+            repo_type: repoType,
+            is_public: !!options.isPublic,
+        };
+        if (options.description !== undefined)
+            body.description = options.description;
+        if (options.readme !== undefined)
+            body.readme = options.readme;
+        if (options.tags !== undefined)
+            body.tags = options.tags;
+        try {
+            await this.caller.call(async () => {
+                const res = await this._fetch(`${this.apiUrl}/repos/`, {
+                    method: "POST",
+                    headers: {
+                        ...this._mergedHeaders,
+                        "Content-Type": "application/json",
+                    },
+                    signal: AbortSignal.timeout(this.timeout_ms),
+                    ...this.fetchOptions,
+                    body: JSON.stringify(body),
+                });
+                await (0, error_js_1.raiseForStatus)(res, `create ${repoType}`);
+                return res;
+            });
+        }
+        catch (e) {
+            if ((0, error_js_1.isLangSmithConflictError)(e)) {
+                return;
+            }
+            throw e;
+        }
+    }
+    async _updateRepoMetadata(owner, name, options) {
+        const body = {};
+        if (options.description !== undefined)
+            body.description = options.description;
+        if (options.readme !== undefined)
+            body.readme = options.readme;
+        if (options.tags !== undefined)
+            body.tags = options.tags;
+        if (options.isPublic !== undefined)
+            body.is_public = options.isPublic;
+        if (Object.keys(body).length === 0)
+            return;
+        await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/repos/${owner}/${name}`, {
+                method: "PATCH",
+                headers: {
+                    ...this._mergedHeaders,
+                    "Content-Type": "application/json",
+                },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body: JSON.stringify(body),
+            });
+            await (0, error_js_1.raiseForStatus)(res, "update repo metadata");
+            return res;
+        });
+    }
     /**
      * Clone a public dataset to your own langsmith tenant.
      * This operation is idempotent. If you already have a dataset with the given name,
@@ -4501,7 +4906,7 @@ class Client {
                 throw new Error(`Invalid public ${kind} URL: ${urlOrToken}`);
             }
         }
-        catch (error) {
+        catch (_error) {
             throw new Error(`Invalid public ${kind} URL or token: ${urlOrToken}`);
         }
     }
@@ -4555,6 +4960,12 @@ class Client {
          * ```
          */
         await new Promise((resolve) => setTimeout(resolve, 1));
+        // Wait for any in-flight drains (whose serialize work may still be
+        // in-progress on a worker thread and not yet registered with the
+        // batchIngestCaller queue) before checking queue idleness.
+        while (this._pendingDrains.size > 0) {
+            await Promise.all([...this._pendingDrains]);
+        }
         await Promise.all([
             ...this.autoBatchQueue.items.map(({ itemPromise }) => itemPromise),
             this.batchIngestCaller.queue.onIdle(),
@@ -4563,6 +4974,33 @@ class Client {
             await (0, otel_js_1.getDefaultOTLPTracerComponents)()?.DEFAULT_LANGSMITH_SPAN_PROCESSOR?.forceFlush();
         }
     }
+    /**
+     * Returns a string representation of the Client instance.
+     * This method is called when the object is converted to a string
+     * or logged, ensuring sensitive information like API keys is not exposed.
+     *
+     * @returns A string representation of the Client.
+     */
+    toString() {
+        const params = [`apiUrl=${JSON.stringify(this.apiUrl)}`];
+        if (this.webUrl !== undefined) {
+            params.push(`webUrl=${JSON.stringify(this.webUrl)}`);
+        }
+        if (this.workspaceId !== undefined) {
+            params.push(`workspaceId=${JSON.stringify(this.workspaceId)}`);
+        }
+        return `[LangSmithClient ${params.join(" ")}]`;
+    }
+    /**
+     * Custom inspect method for Node.js.
+     * This method is called when the object is inspected in the Node.js REPL
+     * or with console.log, ensuring sensitive information like API keys is not exposed.
+     *
+     * @returns A string representation of the Client for inspection.
+     */
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+        return this.toString();
+    }
 }
 exports.Client = Client;
 Object.defineProperty(Client, "_fallbackDirsCreated", {