@hashgraphonline/standards-agent-kit 0.0.18 → 0.0.19

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

@@ -0,0 +1,2002 @@
+import { AsyncCaller as k } from "./utils/async_caller.js";
+import { isLangChainMessage as N, convertLangChainMessageToExample as x } from "./utils/messages.js";
+import { getLangSmithEnvironmentVariable as j, getRuntimeEnvironment as M, getLangChainEnvVarsMetadata as H } from "./utils/env.js";
+import { __version__ as F } from "./index.js";
+import { assertUuid as f } from "./utils/_uuid.js";
+import { warnOnce as J } from "./utils/warn.js";
+import { parsePromptIdentifier as O, isVersionGreaterOrEqual as z } from "./utils/prompts.js";
+import { raiseForStatus as p } from "./utils/error.js";
+import { _getFetchImplementation as u } from "./singletons/fetch.js";
+import { stringify as T } from "./utils/fast-safe-stringify/index.js";
+import R from "../node_modules/uuid/dist/esm-browser/v4.js";
+function D(g) {
+  const t = M(), e = H(), a = g.extra ?? {}, i = a.metadata;
+  return g.extra = {
+    ...a,
+    runtime: {
+      ...t,
+      ...a == null ? void 0 : a.runtime
+    },
+    metadata: {
+      ...e,
+      ...e.revision_id || g.revision_id ? { revision_id: g.revision_id ?? e.revision_id } : {},
+      ...i
+    }
+  }, g;
+}
+const q = () => {
+  const g = j("TRACING_SAMPLING_RATE");
+  if (g === void 0)
+    return;
+  const t = parseFloat(g);
+  if (t < 0 || t > 1)
+    throw new Error(`LANGSMITH_TRACING_SAMPLING_RATE must be between 0 and 1 if set. Got: ${t}`);
+  return t;
+}, G = (g) => {
+  const e = g.replace("http://", "").replace("https://", "").split("/")[0].split(":")[0];
+  return e === "localhost" || e === "127.0.0.1" || e === "::1";
+};
+async function Q(g) {
+  const t = [];
+  for await (const e of g)
+    t.push(e);
+  return t;
+}
+function I(g) {
+  if (g !== void 0)
+    return g.trim().replace(/^"(.*)"$/, "$1").replace(/^'(.*)'$/, "$1");
+}
+const K = async (g) => {
+  if ((g == null ? void 0 : g.status) === 429) {
+    const t = parseInt(g.headers.get("retry-after") ?? "30", 10) * 1e3;
+    if (t > 0)
+      return await new Promise((e) => setTimeout(e, t)), !0;
+  }
+  return !1;
+};
+class Y {
+  constructor() {
+    Object.defineProperty(this, "items", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    }), Object.defineProperty(this, "sizeBytes", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 0
+    });
+  }
+  peek() {
+    return this.items[0];
+  }
+  push(t) {
+    let e;
+    const a = new Promise((s) => {
+      e = s;
+    }), i = T(t.item).length;
+    return this.items.push({
+      action: t.action,
+      payload: t.item,
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      itemPromiseResolve: e,
+      itemPromise: a,
+      size: i
+    }), this.sizeBytes += i, a;
+  }
+  pop(t) {
+    var i;
+    if (t < 1)
+      throw new Error("Number of bytes to pop off may not be less than 1.");
+    const e = [];
+    let a = 0;
+    for (; a + (((i = this.peek()) == null ? void 0 : i.size) ?? 0) < t && this.items.length > 0; ) {
+      const s = this.items.shift();
+      s && (e.push(s), a += s.size, this.sizeBytes -= s.size);
+    }
+    if (e.length === 0 && this.items.length > 0) {
+      const s = this.items.shift();
+      e.push(s), a += s.size, this.sizeBytes -= s.size;
+    }
+    return [
+      e.map((s) => ({ action: s.action, item: s.payload })),
+      () => e.forEach((s) => s.itemPromiseResolve())
+    ];
+  }
+}
+const V = 20971520, W = 1e3;
+class A {
+  constructor(t = {}) {
+    var a;
+    Object.defineProperty(this, "apiKey", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "apiUrl", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "webUrl", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "caller", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "batchIngestCaller", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "timeout_ms", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_tenantId", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: null
+    }), Object.defineProperty(this, "hideInputs", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "hideOutputs", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "tracingSampleRate", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "filteredPostUuids", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: /* @__PURE__ */ new Set()
+    }), Object.defineProperty(this, "autoBatchTracing", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !0
+    }), Object.defineProperty(this, "autoBatchQueue", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: new Y()
+    }), Object.defineProperty(this, "autoBatchTimeout", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "autoBatchInitialDelayMs", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 250
+    }), Object.defineProperty(this, "autoBatchAggregationDelayMs", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 50
+    }), Object.defineProperty(this, "batchSizeBytesLimit", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "fetchOptions", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "settings", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "blockOnRootRunFinalization", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !0
+    }), Object.defineProperty(this, "_serverInfo", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_getServerInfoPromise", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    });
+    const e = A.getDefaultClientConfig();
+    this.tracingSampleRate = q(), this.apiUrl = I(t.apiUrl ?? e.apiUrl) ?? "", this.apiUrl.endsWith("/") && (this.apiUrl = this.apiUrl.slice(0, -1)), this.apiKey = I(t.apiKey ?? e.apiKey), this.webUrl = I(t.webUrl ?? e.webUrl), (a = this.webUrl) != null && a.endsWith("/") && (this.webUrl = this.webUrl.slice(0, -1)), this.timeout_ms = t.timeout_ms ?? 12e3, this.caller = new k(t.callerOptions ?? {}), this.batchIngestCaller = new k({
+      ...t.callerOptions ?? {},
+      onFailedResponseHook: K
+    }), this.hideInputs = t.hideInputs ?? t.anonymizer ?? e.hideInputs, this.hideOutputs = t.hideOutputs ?? t.anonymizer ?? e.hideOutputs, this.autoBatchTracing = t.autoBatchTracing ?? this.autoBatchTracing, this.blockOnRootRunFinalization = t.blockOnRootRunFinalization ?? this.blockOnRootRunFinalization, this.batchSizeBytesLimit = t.batchSizeBytesLimit, this.fetchOptions = t.fetchOptions || {};
+  }
+  static getDefaultClientConfig() {
+    const t = j("API_KEY"), e = j("ENDPOINT") ?? "https://api.smith.langchain.com", a = j("HIDE_INPUTS") === "true", i = j("HIDE_OUTPUTS") === "true";
+    return {
+      apiUrl: e,
+      apiKey: t,
+      webUrl: void 0,
+      hideInputs: a,
+      hideOutputs: i
+    };
+  }
+  getHostUrl() {
+    return this.webUrl ? this.webUrl : G(this.apiUrl) ? (this.webUrl = "http://localhost:3000", this.webUrl) : this.apiUrl.includes("/api") && !this.apiUrl.split(".", 1)[0].endsWith("api") ? (this.webUrl = this.apiUrl.replace("/api", ""), this.webUrl) : this.apiUrl.split(".", 1)[0].includes("dev") ? (this.webUrl = "https://dev.smith.langchain.com", this.webUrl) : this.apiUrl.split(".", 1)[0].includes("eu") ? (this.webUrl = "https://eu.smith.langchain.com", this.webUrl) : (this.webUrl = "https://smith.langchain.com", this.webUrl);
+  }
+  get headers() {
+    const t = {
+      "User-Agent": `langsmith-js/${F}`
+    };
+    return this.apiKey && (t["x-api-key"] = `${this.apiKey}`), t;
+  }
+  processInputs(t) {
+    return this.hideInputs === !1 ? t : this.hideInputs === !0 ? {} : typeof this.hideInputs == "function" ? this.hideInputs(t) : t;
+  }
+  processOutputs(t) {
+    return this.hideOutputs === !1 ? t : this.hideOutputs === !0 ? {} : typeof this.hideOutputs == "function" ? this.hideOutputs(t) : t;
+  }
+  prepareRunCreateOrUpdateInputs(t) {
+    const e = { ...t };
+    return e.inputs !== void 0 && (e.inputs = this.processInputs(e.inputs)), e.outputs !== void 0 && (e.outputs = this.processOutputs(e.outputs)), e;
+  }
+  async _getResponse(t, e) {
+    const a = (e == null ? void 0 : e.toString()) ?? "", i = `${this.apiUrl}${t}?${a}`, s = await this.caller.call(u(), i, {
+      method: "GET",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    return await p(s, `Failed to fetch ${t}`), s;
+  }
+  async _get(t, e) {
+    return (await this._getResponse(t, e)).json();
+  }
+  async *_getPaginated(t, e = new URLSearchParams(), a) {
+    let i = Number(e.get("offset")) || 0;
+    const s = Number(e.get("limit")) || 100;
+    for (; ; ) {
+      e.set("offset", String(i)), e.set("limit", String(s));
+      const r = `${this.apiUrl}${t}?${e}`, o = await this.caller.call(u(), r, {
+        method: "GET",
+        headers: this.headers,
+        signal: AbortSignal.timeout(this.timeout_ms),
+        ...this.fetchOptions
+      });
+      await p(o, `Failed to fetch ${t}`);
+      const n = a ? a(await o.json()) : await o.json();
+      if (n.length === 0 || (yield n, n.length < s))
+        break;
+      i += n.length;
+    }
+  }
+  async *_getCursorPaginatedList(t, e = null, a = "POST", i = "runs") {
+    const s = e ? { ...e } : {};
+    for (; ; ) {
+      const o = await (await this.caller.call(u(), `${this.apiUrl}${t}`, {
+        method: a,
+        headers: { ...this.headers, "Content-Type": "application/json" },
+        signal: AbortSignal.timeout(this.timeout_ms),
+        ...this.fetchOptions,
+        body: JSON.stringify(s)
+      })).json();
+      if (!o || !o[i])
+        break;
+      yield o[i];
+      const n = o.cursors;
+      if (!n || !n.next)
+        break;
+      s.cursor = n.next;
+    }
+  }
+  _filterForSampling(t, e = !1) {
+    if (this.tracingSampleRate === void 0)
+      return t;
+    if (e) {
+      const a = [];
+      for (const i of t)
+        this.filteredPostUuids.has(i.id) ? this.filteredPostUuids.delete(i.id) : a.push(i);
+      return a;
+    } else {
+      const a = [];
+      for (const i of t)
+        i.id !== i.trace_id && !this.filteredPostUuids.has(i.trace_id) || Math.random() < this.tracingSampleRate ? a.push(i) : this.filteredPostUuids.add(i.id);
+      return a;
+    }
+  }
+  async _getBatchSizeLimitBytes() {
+    var e;
+    const t = await this._ensureServerInfo();
+    return this.batchSizeBytesLimit ?? ((e = t.batch_ingest_config) == null ? void 0 : e.size_limit_bytes) ?? V;
+  }
+  async drainAutoBatchQueue() {
+    var t;
+    for (; this.autoBatchQueue.items.length >= 0; ) {
+      const [e, a] = this.autoBatchQueue.pop(await this._getBatchSizeLimitBytes());
+      if (!e.length) {
+        a();
+        return;
+      }
+      try {
+        const i = {
+          runCreates: e.filter((r) => r.action === "create").map((r) => r.item),
+          runUpdates: e.filter((r) => r.action === "update").map((r) => r.item)
+        }, s = await this._ensureServerInfo();
+        (t = s == null ? void 0 : s.batch_ingest_config) != null && t.use_multipart_endpoint ? await this.multipartIngestRuns(i) : await this.batchIngestRuns(i);
+      } finally {
+        a();
+      }
+    }
+  }
+  async processRunOperation(t, e) {
+    const a = this.autoBatchTimeout;
+    clearTimeout(this.autoBatchTimeout), this.autoBatchTimeout = void 0, t.action === "create" && (t.item = D(t.item));
+    const i = this.autoBatchQueue.push(t), s = await this._getBatchSizeLimitBytes();
+    return (e || this.autoBatchQueue.sizeBytes > s) && await this.drainAutoBatchQueue().catch(console.error), this.autoBatchQueue.items.length > 0 && (this.autoBatchTimeout = setTimeout(() => {
+      this.autoBatchTimeout = void 0, this.drainAutoBatchQueue().catch(console.error);
+    }, a ? this.autoBatchAggregationDelayMs : this.autoBatchInitialDelayMs)), i;
+  }
+  async _getServerInfo() {
+    const t = await u()(`${this.apiUrl}/info`, {
+      method: "GET",
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(W),
+      ...this.fetchOptions
+    });
+    return await p(t, "get server info"), t.json();
+  }
+  async _ensureServerInfo() {
+    return this._getServerInfoPromise === void 0 && (this._getServerInfoPromise = (async () => {
+      if (this._serverInfo === void 0)
+        try {
+          this._serverInfo = await this._getServerInfo();
+        } catch {
+          console.warn("[WARNING]: LangSmith failed to fetch info on supported operations. Falling back to single calls and default limits.");
+        }
+      return this._serverInfo ?? {};
+    })()), this._getServerInfoPromise.then((t) => (this._serverInfo === void 0 && (this._getServerInfoPromise = void 0), t));
+  }
+  async _getSettings() {
+    return this.settings || (this.settings = this._get("/settings")), await this.settings;
+  }
+  async createRun(t) {
+    if (!this._filterForSampling([t]).length)
+      return;
+    const e = { ...this.headers, "Content-Type": "application/json" }, a = t.project_name;
+    delete t.project_name;
+    const i = this.prepareRunCreateOrUpdateInputs({
+      session_name: a,
+      ...t,
+      start_time: t.start_time ?? Date.now()
+    });
+    if (this.autoBatchTracing && i.trace_id !== void 0 && i.dotted_order !== void 0) {
+      this.processRunOperation({
+        action: "create",
+        item: i
+      }).catch(console.error);
+      return;
+    }
+    const s = D(i), r = await this.caller.call(u(), `${this.apiUrl}/runs`, {
+      method: "POST",
+      headers: e,
+      body: T(s),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(r, "create run", !0);
+  }
+  /**
+   * Batch ingest/upsert multiple runs in the Langsmith system.
+   * @param runs
+   */
+  async batchIngestRuns({ runCreates: t, runUpdates: e }) {
+    if (t === void 0 && e === void 0)
+      return;
+    let a = (t == null ? void 0 : t.map((n) => this.prepareRunCreateOrUpdateInputs(n))) ?? [], i = (e == null ? void 0 : e.map((n) => this.prepareRunCreateOrUpdateInputs(n))) ?? [];
+    if (a.length > 0 && i.length > 0) {
+      const n = a.reduce((l, h) => (h.id && (l[h.id] = h), l), {}), d = [];
+      for (const l of i)
+        l.id !== void 0 && n[l.id] ? n[l.id] = {
+          ...n[l.id],
+          ...l
+        } : d.push(l);
+      a = Object.values(n), i = d;
+    }
+    const s = {
+      post: this._filterForSampling(a),
+      patch: this._filterForSampling(i, !0)
+    };
+    if (!s.post.length && !s.patch.length)
+      return;
+    if ((await this._ensureServerInfo()).version === void 0) {
+      this.autoBatchTracing = !1;
+      for (const n of s.post)
+        await this.createRun(n);
+      for (const n of s.patch)
+        n.id !== void 0 && await this.updateRun(n.id, n);
+      return;
+    }
+    const o = {
+      post: [],
+      patch: []
+    };
+    for (const n of ["post", "patch"]) {
+      const d = n, l = s[d].reverse();
+      let h = l.pop();
+      for (; h !== void 0; )
+        o[d].push(h), h = l.pop();
+    }
+    (o.post.length > 0 || o.patch.length > 0) && await this._postBatchIngestRuns(T(o));
+  }
+  async _postBatchIngestRuns(t) {
+    const e = {
+      ...this.headers,
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    }, a = await this.batchIngestCaller.call(u(), `${this.apiUrl}/runs/batch`, {
+      method: "POST",
+      headers: e,
+      body: t,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(a, "batch create run", !0);
+  }
+  /**
+   * Batch ingest/upsert multiple runs in the Langsmith system.
+   * @param runs
+   */
+  async multipartIngestRuns({ runCreates: t, runUpdates: e }) {
+    if (t === void 0 && e === void 0)
+      return;
+    const a = {};
+    let i = [];
+    for (const l of t ?? []) {
+      const h = this.prepareRunCreateOrUpdateInputs(l);
+      h.id !== void 0 && h.attachments !== void 0 && (a[h.id] = h.attachments), delete h.attachments, i.push(h);
+    }
+    let s = [];
+    for (const l of e ?? [])
+      s.push(this.prepareRunCreateOrUpdateInputs(l));
+    if (i.find((l) => l.trace_id === void 0 || l.dotted_order === void 0) !== void 0)
+      throw new Error('Multipart ingest requires "trace_id" and "dotted_order" to be set when creating a run');
+    if (s.find((l) => l.trace_id === void 0 || l.dotted_order === void 0) !== void 0)
+      throw new Error('Multipart ingest requires "trace_id" and "dotted_order" to be set when updating a run');
+    if (i.length > 0 && s.length > 0) {
+      const l = i.reduce((c, _) => (_.id && (c[_.id] = _), c), {}), h = [];
+      for (const c of s)
+        c.id !== void 0 && l[c.id] ? l[c.id] = {
+          ...l[c.id],
+          ...c
+        } : h.push(c);
+      i = Object.values(l), s = h;
+    }
+    if (i.length === 0 && s.length === 0)
+      return;
+    const n = [], d = [];
+    for (const [l, h] of [
+      ["post", i],
+      ["patch", s]
+    ])
+      for (const c of h) {
+        const { inputs: _, outputs: m, events: b, ...w } = c, y = { inputs: _, outputs: m, events: b }, U = T(w);
+        d.push({
+          name: `${l}.${w.id}`,
+          payload: new Blob([U], {
+            type: `application/json; length=${U.length}`
+            // encoding=gzip
+          })
+        });
+        for (const [S, v] of Object.entries(y)) {
+          if (v === void 0)
+            continue;
+          const E = T(v);
+          d.push({
+            name: `${l}.${w.id}.${S}`,
+            payload: new Blob([E], {
+              type: `application/json; length=${E.length}`
+            })
+          });
+        }
+        if (w.id !== void 0) {
+          const S = a[w.id];
+          if (S) {
+            delete a[w.id];
+            for (const [v, [E, P]] of Object.entries(S))
+              d.push({
+                name: `attachment.${w.id}.${v}`,
+                payload: new Blob([P], {
+                  type: `${E}; length=${P.length}`
+                })
+              });
+          }
+        }
+        n.push(`trace=${w.trace_id},id=${w.id}`);
+      }
+    await this._sendMultipartRequest(d, n.join("; "));
+  }
+  async _sendMultipartRequest(t, e) {
+    try {
+      const a = new FormData();
+      for (const i of t)
+        a.append(i.name, i.payload);
+      await this.batchIngestCaller.call(u(), `${this.apiUrl}/runs/multipart`, {
+        method: "POST",
+        headers: {
+          ...this.headers
+        },
+        body: a,
+        signal: AbortSignal.timeout(this.timeout_ms),
+        ...this.fetchOptions
+      });
+    } catch (a) {
+      let i = "Failed to multipart ingest runs";
+      a instanceof Error ? i += `: ${a.stack || a.message}` : i += `: ${String(a)}`, console.warn(`${i.trim()}
+
+Context: ${e}`);
+    }
+  }
+  async updateRun(t, e) {
+    f(t), e.inputs && (e.inputs = this.processInputs(e.inputs)), e.outputs && (e.outputs = this.processOutputs(e.outputs));
+    const a = { ...e, id: t };
+    if (!this._filterForSampling([a], !0).length)
+      return;
+    if (this.autoBatchTracing && a.trace_id !== void 0 && a.dotted_order !== void 0) {
+      if (e.end_time !== void 0 && a.parent_run_id === void 0 && this.blockOnRootRunFinalization) {
+        await this.processRunOperation({ action: "update", item: a }, !0);
+        return;
+      } else
+        this.processRunOperation({ action: "update", item: a }).catch(console.error);
+      return;
+    }
+    const i = { ...this.headers, "Content-Type": "application/json" }, s = await this.caller.call(u(), `${this.apiUrl}/runs/${t}`, {
+      method: "PATCH",
+      headers: i,
+      body: T(e),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(s, "update run", !0);
+  }
+  async readRun(t, { loadChildRuns: e } = { loadChildRuns: !1 }) {
+    f(t);
+    let a = await this._get(`/runs/${t}`);
+    return e && a.child_run_ids && (a = await this._loadChildRuns(a)), a;
+  }
+  async getRunUrl({ runId: t, run: e, projectOpts: a }) {
+    if (e !== void 0) {
+      let i;
+      e.session_id ? i = e.session_id : a != null && a.projectName ? i = (await this.readProject({ projectName: a == null ? void 0 : a.projectName })).id : a != null && a.projectId ? i = a == null ? void 0 : a.projectId : i = (await this.readProject({
+        projectName: j("PROJECT") || "default"
+      })).id;
+      const s = await this._getTenantId();
+      return `${this.getHostUrl()}/o/${s}/projects/p/${i}/r/${e.id}?poll=true`;
+    } else if (t !== void 0) {
+      const i = await this.readRun(t);
+      if (!i.app_path)
+        throw new Error(`Run ${t} has no app_path`);
+      return `${this.getHostUrl()}${i.app_path}`;
+    } else
+      throw new Error("Must provide either runId or run");
+  }
+  async _loadChildRuns(t) {
+    const e = await Q(this.listRuns({ id: t.child_run_ids })), a = {}, i = {};
+    e.sort((s, r) => ((s == null ? void 0 : s.dotted_order) ?? "").localeCompare((r == null ? void 0 : r.dotted_order) ?? ""));
+    for (const s of e) {
+      if (s.parent_run_id === null || s.parent_run_id === void 0)
+        throw new Error(`Child run ${s.id} has no parent`);
+      s.parent_run_id in a || (a[s.parent_run_id] = []), a[s.parent_run_id].push(s), i[s.id] = s;
+    }
+    t.child_runs = a[t.id] || [];
+    for (const s in a)
+      s !== t.id && (i[s].child_runs = a[s]);
+    return t;
+  }
+  /**
+   * List runs from the LangSmith server.
+   * @param projectId - The ID of the project to filter by.
+   * @param projectName - The name of the project to filter by.
+   * @param parentRunId - The ID of the parent run to filter by.
+   * @param traceId - The ID of the trace to filter by.
+   * @param referenceExampleId - The ID of the reference example to filter by.
+   * @param startTime - The start time to filter by.
+   * @param isRoot - Indicates whether to only return root runs.
+   * @param runType - The run type to filter by.
+   * @param error - Indicates whether to filter by error runs.
+   * @param id - The ID of the run to filter by.
+   * @param query - The query string to filter by.
+   * @param filter - The filter string to apply to the run spans.
+   * @param traceFilter - The filter string to apply on the root run of the trace.
+   * @param limit - The maximum number of runs to retrieve.
+   * @returns {AsyncIterable<Run>} - The runs.
+   *
+   * @example
+   * // List all runs in a project
+   * const projectRuns = client.listRuns({ projectName: "<your_project>" });
+   *
+   * @example
+   * // List LLM and Chat runs in the last 24 hours
+   * const todaysLLMRuns = client.listRuns({
+   *   projectName: "<your_project>",
+   *   start_time: new Date(Date.now() - 24 * 60 * 60 * 1000),
+   *   run_type: "llm",
+   * });
+   *
+   * @example
+   * // List traces in a project
+   * const rootRuns = client.listRuns({
+   *   projectName: "<your_project>",
+   *   execution_order: 1,
+   * });
+   *
+   * @example
+   * // List runs without errors
+   * const correctRuns = client.listRuns({
+   *   projectName: "<your_project>",
+   *   error: false,
+   * });
+   *
+   * @example
+   * // List runs by run ID
+   * const runIds = [
+   *   "a36092d2-4ad5-4fb4-9c0d-0dba9a2ed836",
+   *   "9398e6be-964f-4aa4-8ae9-ad78cd4b7074",
+   * ];
+   * const selectedRuns = client.listRuns({ run_ids: runIds });
+   *
+   * @example
+   * // List all "chain" type runs that took more than 10 seconds and had `total_tokens` greater than 5000
+   * const chainRuns = client.listRuns({
+   *   projectName: "<your_project>",
+   *   filter: 'and(eq(run_type, "chain"), gt(latency, 10), gt(total_tokens, 5000))',
+   * });
+   *
+   * @example
+   * // List all runs called "extractor" whose root of the trace was assigned feedback "user_score" score of 1
+   * const goodExtractorRuns = client.listRuns({
+   *   projectName: "<your_project>",
+   *   filter: 'eq(name, "extractor")',
+   *   traceFilter: 'and(eq(feedback_key, "user_score"), eq(feedback_score, 1))',
+   * });
+   *
+   * @example
+   * // List all runs that started after a specific timestamp and either have "error" not equal to null or a "Correctness" feedback score equal to 0
+   * const complexRuns = client.listRuns({
+   *   projectName: "<your_project>",
+   *   filter: 'and(gt(start_time, "2023-07-15T12:34:56Z"), or(neq(error, null), and(eq(feedback_key, "Correctness"), eq(feedback_score, 0.0))))',
+   * });
+   *
+   * @example
+   * // List all runs where `tags` include "experimental" or "beta" and `latency` is greater than 2 seconds
+   * const taggedRuns = client.listRuns({
+   *   projectName: "<your_project>",
+   *   filter: 'and(or(has(tags, "experimental"), has(tags, "beta")), gt(latency, 2))',
+   * });
+   */
+  async *listRuns(t) {
+    const { projectId: e, projectName: a, parentRunId: i, traceId: s, referenceExampleId: r, startTime: o, executionOrder: n, isRoot: d, runType: l, error: h, id: c, query: _, filter: m, traceFilter: b, treeFilter: w, limit: y, select: U } = t;
+    let S = [];
+    if (e && (S = Array.isArray(e) ? e : [e]), a) {
+      const $ = Array.isArray(a) ? a : [a], C = await Promise.all($.map((L) => this.readProject({ projectName: L }).then((B) => B.id)));
+      S.push(...C);
+    }
+    const v = [
+      "app_path",
+      "child_run_ids",
+      "completion_cost",
+      "completion_tokens",
+      "dotted_order",
+      "end_time",
+      "error",
+      "events",
+      "extra",
+      "feedback_stats",
+      "first_token_time",
+      "id",
+      "inputs",
+      "name",
+      "outputs",
+      "parent_run_id",
+      "parent_run_ids",
+      "prompt_cost",
+      "prompt_tokens",
+      "reference_example_id",
+      "run_type",
+      "session_id",
+      "start_time",
+      "status",
+      "tags",
+      "total_cost",
+      "total_tokens",
+      "trace_id"
+    ], E = {
+      session: S.length ? S : null,
+      run_type: l,
+      reference_example: r,
+      query: _,
+      filter: m,
+      trace_filter: b,
+      tree_filter: w,
+      execution_order: n,
+      parent_run: i,
+      start_time: o ? o.toISOString() : null,
+      error: h,
+      id: c,
+      limit: y,
+      trace: s,
+      select: U || v,
+      is_root: d
+    };
+    let P = 0;
+    for await (const $ of this._getCursorPaginatedList("/runs/query", E))
+      if (y) {
+        if (P >= y)
+          break;
+        if ($.length + P > y) {
+          yield* $.slice(0, y - P);
+          break;
+        }
+        P += $.length, yield* $;
+      } else
+        yield* $;
+  }
+  async getRunStats({ id: t, trace: e, parentRun: a, runType: i, projectNames: s, projectIds: r, referenceExampleIds: o, startTime: n, endTime: d, error: l, query: h, filter: c, traceFilter: _, treeFilter: m, isRoot: b, dataSourceType: w }) {
+    let y = r || [];
+    s && (y = [
+      ...r || [],
+      ...await Promise.all(s.map((P) => this.readProject({ projectName: P }).then(($) => $.id)))
+    ]);
+    const S = Object.fromEntries(Object.entries({
+      id: t,
+      trace: e,
+      parent_run: a,
+      run_type: i,
+      session: y,
+      reference_example: o,
+      start_time: n,
+      end_time: d,
+      error: l,
+      query: h,
+      filter: c,
+      trace_filter: _,
+      tree_filter: m,
+      is_root: b,
+      data_source_type: w
+    }).filter(([P, $]) => $ !== void 0));
+    return await (await this.caller.call(u(), `${this.apiUrl}/runs/stats`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(S),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    })).json();
+  }
+  async shareRun(t, { shareId: e } = {}) {
+    const a = {
+      run_id: t,
+      share_token: e || R()
+    };
+    f(t);
+    const s = await (await this.caller.call(u(), `${this.apiUrl}/runs/${t}/share`, {
+      method: "PUT",
+      headers: this.headers,
+      body: JSON.stringify(a),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    })).json();
+    if (s === null || !("share_token" in s))
+      throw new Error("Invalid response from server");
+    return `${this.getHostUrl()}/public/${s.share_token}/r`;
+  }
+  async unshareRun(t) {
+    f(t);
+    const e = await this.caller.call(u(), `${this.apiUrl}/runs/${t}/share`, {
+      method: "DELETE",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(e, "unshare run", !0);
+  }
+  async readRunSharedLink(t) {
+    f(t);
+    const a = await (await this.caller.call(u(), `${this.apiUrl}/runs/${t}/share`, {
+      method: "GET",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    })).json();
+    if (!(a === null || !("share_token" in a)))
+      return `${this.getHostUrl()}/public/${a.share_token}/r`;
+  }
+  async listSharedRuns(t, { runIds: e } = {}) {
+    const a = new URLSearchParams({
+      share_token: t
+    });
+    if (e !== void 0)
+      for (const r of e)
+        a.append("id", r);
+    return f(t), await (await this.caller.call(u(), `${this.apiUrl}/public/${t}/runs${a}`, {
+      method: "GET",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    })).json();
+  }
+  async readDatasetSharedSchema(t, e) {
+    if (!t && !e)
+      throw new Error("Either datasetId or datasetName must be given");
+    t || (t = (await this.readDataset({ datasetName: e })).id), f(t);
+    const i = await (await this.caller.call(u(), `${this.apiUrl}/datasets/${t}/share`, {
+      method: "GET",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    })).json();
+    return i.url = `${this.getHostUrl()}/public/${i.share_token}/d`, i;
+  }
+  async shareDataset(t, e) {
+    if (!t && !e)
+      throw new Error("Either datasetId or datasetName must be given");
+    t || (t = (await this.readDataset({ datasetName: e })).id);
+    const a = {
+      dataset_id: t
+    };
+    f(t);
+    const s = await (await this.caller.call(u(), `${this.apiUrl}/datasets/${t}/share`, {
+      method: "PUT",
+      headers: this.headers,
+      body: JSON.stringify(a),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    })).json();
+    return s.url = `${this.getHostUrl()}/public/${s.share_token}/d`, s;
+  }
+  async unshareDataset(t) {
+    f(t);
+    const e = await this.caller.call(u(), `${this.apiUrl}/datasets/${t}/share`, {
+      method: "DELETE",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(e, "unshare dataset", !0);
+  }
+  async readSharedDataset(t) {
+    return f(t), await (await this.caller.call(u(), `${this.apiUrl}/public/${t}/datasets`, {
+      method: "GET",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    })).json();
+  }
+  /**
+   * Get shared examples.
+   *
+   * @param {string} shareToken The share token to get examples for. A share token is the UUID (or LangSmith URL, including UUID) generated when explicitly marking an example as public.
+   * @param {Object} [options] Additional options for listing the examples.
+   * @param {string[] | undefined} [options.exampleIds] A list of example IDs to filter by.
+   * @returns {Promise<Example[]>} The shared examples.
+   */
+  async listSharedExamples(t, e) {
+    const a = {};
+    e != null && e.exampleIds && (a.id = e.exampleIds);
+    const i = new URLSearchParams();
+    Object.entries(a).forEach(([o, n]) => {
+      Array.isArray(n) ? n.forEach((d) => i.append(o, d)) : i.append(o, n);
+    });
+    const s = await this.caller.call(u(), `${this.apiUrl}/public/${t}/examples?${i.toString()}`, {
+      method: "GET",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    }), r = await s.json();
+    if (!s.ok)
+      throw "detail" in r ? new Error(`Failed to list shared examples.
+Status: ${s.status}
+Message: ${r.detail.join(`
+`)}`) : new Error(`Failed to list shared examples: ${s.status} ${s.statusText}`);
+    return r.map((o) => ({
+      ...o,
+      _hostUrl: this.getHostUrl()
+    }));
+  }
+  async createProject({ projectName: t, description: e = null, metadata: a = null, upsert: i = !1, projectExtra: s = null, referenceDatasetId: r = null }) {
+    const o = i ? "?upsert=true" : "", n = `${this.apiUrl}/sessions${o}`, d = s || {};
+    a && (d.metadata = a);
+    const l = {
+      name: t,
+      extra: d,
+      description: e
+    };
+    r !== null && (l.reference_dataset_id = r);
+    const h = await this.caller.call(u(), n, {
+      method: "POST",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(l),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    return await p(h, "create project"), await h.json();
+  }
+  async updateProject(t, { name: e = null, description: a = null, metadata: i = null, projectExtra: s = null, endTime: r = null }) {
+    const o = `${this.apiUrl}/sessions/${t}`;
+    let n = s;
+    i && (n = { ...n || {}, metadata: i });
+    const d = {
+      name: e,
+      extra: n,
+      description: a,
+      end_time: r ? new Date(r).toISOString() : null
+    }, l = await this.caller.call(u(), o, {
+      method: "PATCH",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(d),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    return await p(l, "update project"), await l.json();
+  }
+  async hasProject({ projectId: t, projectName: e }) {
+    let a = "/sessions";
+    const i = new URLSearchParams();
+    if (t !== void 0 && e !== void 0)
+      throw new Error("Must provide either projectName or projectId, not both");
+    if (t !== void 0)
+      f(t), a += `/${t}`;
+    else if (e !== void 0)
+      i.append("name", e);
+    else
+      throw new Error("Must provide projectName or projectId");
+    const s = await this.caller.call(u(), `${this.apiUrl}${a}?${i}`, {
+      method: "GET",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    try {
+      const r = await s.json();
+      return s.ok ? Array.isArray(r) ? r.length > 0 : !0 : !1;
+    } catch {
+      return !1;
+    }
+  }
+  async readProject({ projectId: t, projectName: e, includeStats: a }) {
+    let i = "/sessions";
+    const s = new URLSearchParams();
+    if (t !== void 0 && e !== void 0)
+      throw new Error("Must provide either projectName or projectId, not both");
+    if (t !== void 0)
+      f(t), i += `/${t}`;
+    else if (e !== void 0)
+      s.append("name", e);
+    else
+      throw new Error("Must provide projectName or projectId");
+    a !== void 0 && s.append("include_stats", a.toString());
+    const r = await this._get(i, s);
+    let o;
+    if (Array.isArray(r)) {
+      if (r.length === 0)
+        throw new Error(`Project[id=${t}, name=${e}] not found`);
+      o = r[0];
+    } else
+      o = r;
+    return o;
+  }
+  async getProjectUrl({ projectId: t, projectName: e }) {
+    if (t === void 0 && e === void 0)
+      throw new Error("Must provide either projectName or projectId");
+    const a = await this.readProject({ projectId: t, projectName: e }), i = await this._getTenantId();
+    return `${this.getHostUrl()}/o/${i}/projects/p/${a.id}`;
+  }
+  async getDatasetUrl({ datasetId: t, datasetName: e }) {
+    if (t === void 0 && e === void 0)
+      throw new Error("Must provide either datasetName or datasetId");
+    const a = await this.readDataset({ datasetId: t, datasetName: e }), i = await this._getTenantId();
+    return `${this.getHostUrl()}/o/${i}/datasets/${a.id}`;
+  }
+  async _getTenantId() {
+    if (this._tenantId !== null)
+      return this._tenantId;
+    const t = new URLSearchParams({ limit: "1" });
+    for await (const e of this._getPaginated("/sessions", t))
+      return this._tenantId = e[0].tenant_id, e[0].tenant_id;
+    throw new Error("No projects found to resolve tenant.");
+  }
+  async *listProjects({ projectIds: t, name: e, nameContains: a, referenceDatasetId: i, referenceDatasetName: s, referenceFree: r, metadata: o } = {}) {
+    const n = new URLSearchParams();
+    if (t !== void 0)
+      for (const d of t)
+        n.append("id", d);
+    if (e !== void 0 && n.append("name", e), a !== void 0 && n.append("name_contains", a), i !== void 0)
+      n.append("reference_dataset", i);
+    else if (s !== void 0) {
+      const d = await this.readDataset({
+        datasetName: s
+      });
+      n.append("reference_dataset", d.id);
+    }
+    r !== void 0 && n.append("reference_free", r.toString()), o !== void 0 && n.append("metadata", JSON.stringify(o));
+    for await (const d of this._getPaginated("/sessions", n))
+      yield* d;
+  }
+  async deleteProject({ projectId: t, projectName: e }) {
+    let a;
+    if (t === void 0 && e === void 0)
+      throw new Error("Must provide projectName or projectId");
+    if (t !== void 0 && e !== void 0)
+      throw new Error("Must provide either projectName or projectId, not both");
+    t === void 0 ? a = (await this.readProject({ projectName: e })).id : a = t, f(a);
+    const i = await this.caller.call(u(), `${this.apiUrl}/sessions/${a}`, {
+      method: "DELETE",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(i, `delete session ${a} (${e})`, !0);
+  }
+  async uploadCsv({ csvFile: t, fileName: e, inputKeys: a, outputKeys: i, description: s, dataType: r, name: o }) {
+    const n = `${this.apiUrl}/datasets/upload`, d = new FormData();
+    d.append("file", t, e), a.forEach((c) => {
+      d.append("input_keys", c);
+    }), i.forEach((c) => {
+      d.append("output_keys", c);
+    }), s && d.append("description", s), r && d.append("data_type", r), o && d.append("name", o);
+    const l = await this.caller.call(u(), n, {
+      method: "POST",
+      headers: this.headers,
+      body: d,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    return await p(l, "upload CSV"), await l.json();
+  }
+  async createDataset(t, { description: e, dataType: a, inputsSchema: i, outputsSchema: s, metadata: r } = {}) {
+    const o = {
+      name: t,
+      description: e,
+      extra: r ? { metadata: r } : void 0
+    };
+    a && (o.data_type = a), i && (o.inputs_schema_definition = i), s && (o.outputs_schema_definition = s);
+    const n = await this.caller.call(u(), `${this.apiUrl}/datasets`, {
+      method: "POST",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(o),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    return await p(n, "create dataset"), await n.json();
+  }
+  async readDataset({ datasetId: t, datasetName: e }) {
+    let a = "/datasets";
+    const i = new URLSearchParams({ limit: "1" });
+    if (t !== void 0 && e !== void 0)
+      throw new Error("Must provide either datasetName or datasetId, not both");
+    if (t !== void 0)
+      f(t), a += `/${t}`;
+    else if (e !== void 0)
+      i.append("name", e);
+    else
+      throw new Error("Must provide datasetName or datasetId");
+    const s = await this._get(a, i);
+    let r;
+    if (Array.isArray(s)) {
+      if (s.length === 0)
+        throw new Error(`Dataset[id=${t}, name=${e}] not found`);
+      r = s[0];
+    } else
+      r = s;
+    return r;
+  }
+  async hasDataset({ datasetId: t, datasetName: e }) {
+    try {
+      return await this.readDataset({ datasetId: t, datasetName: e }), !0;
+    } catch (a) {
+      if (
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        a instanceof Error && a.message.toLocaleLowerCase().includes("not found")
+      )
+        return !1;
+      throw a;
+    }
+  }
+  async diffDatasetVersions({ datasetId: t, datasetName: e, fromVersion: a, toVersion: i }) {
+    let s = t;
+    if (s === void 0 && e === void 0)
+      throw new Error("Must provide either datasetName or datasetId");
+    if (s !== void 0 && e !== void 0)
+      throw new Error("Must provide either datasetName or datasetId, not both");
+    s === void 0 && (s = (await this.readDataset({ datasetName: e })).id);
+    const r = new URLSearchParams({
+      from_version: typeof a == "string" ? a : a.toISOString(),
+      to_version: typeof i == "string" ? i : i.toISOString()
+    });
+    return await this._get(`/datasets/${s}/versions/diff`, r);
+  }
+  async readDatasetOpenaiFinetuning({ datasetId: t, datasetName: e }) {
+    const a = "/datasets";
+    if (t === void 0) if (e !== void 0)
+      t = (await this.readDataset({ datasetName: e })).id;
+    else
+      throw new Error("Must provide datasetName or datasetId");
+    return (await (await this._getResponse(`${a}/${t}/openai_ft`)).text()).trim().split(`
+`).map((o) => JSON.parse(o));
+  }
+  async *listDatasets({ limit: t = 100, offset: e = 0, datasetIds: a, datasetName: i, datasetNameContains: s, metadata: r } = {}) {
+    const o = "/datasets", n = new URLSearchParams({
+      limit: t.toString(),
+      offset: e.toString()
+    });
+    if (a !== void 0)
+      for (const d of a)
+        n.append("id", d);
+    i !== void 0 && n.append("name", i), s !== void 0 && n.append("name_contains", s), r !== void 0 && n.append("metadata", JSON.stringify(r));
+    for await (const d of this._getPaginated(o, n))
+      yield* d;
+  }
+  /**
+   * Update a dataset
+   * @param props The dataset details to update
+   * @returns The updated dataset
+   */
+  async updateDataset(t) {
+    const { datasetId: e, datasetName: a, ...i } = t;
+    if (!e && !a)
+      throw new Error("Must provide either datasetName or datasetId");
+    const s = e ?? (await this.readDataset({ datasetName: a })).id;
+    f(s);
+    const r = await this.caller.call(u(), `${this.apiUrl}/datasets/${s}`, {
+      method: "PATCH",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(i),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    return await p(r, "update dataset"), await r.json();
+  }
+  async deleteDataset({ datasetId: t, datasetName: e }) {
+    let a = "/datasets", i = t;
+    if (t !== void 0 && e !== void 0)
+      throw new Error("Must provide either datasetName or datasetId, not both");
+    if (e !== void 0 && (i = (await this.readDataset({ datasetName: e })).id), i !== void 0)
+      f(i), a += `/${i}`;
+    else
+      throw new Error("Must provide datasetName or datasetId");
+    const s = await this.caller.call(u(), this.apiUrl + a, {
+      method: "DELETE",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(s, `delete ${a}`), await s.json();
+  }
+  async indexDataset({ datasetId: t, datasetName: e, tag: a }) {
+    let i = t;
+    if (!i && !e)
+      throw new Error("Must provide either datasetName or datasetId");
+    if (i && e)
+      throw new Error("Must provide either datasetName or datasetId, not both");
+    i || (i = (await this.readDataset({ datasetName: e })).id), f(i);
+    const s = {
+      tag: a
+    }, r = await this.caller.call(u(), `${this.apiUrl}/datasets/${i}/index`, {
+      method: "POST",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(s),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(r, "index dataset"), await r.json();
+  }
+  /**
+   * Lets you run a similarity search query on a dataset.
+   *
+   * Requires the dataset to be indexed. Please see the `indexDataset` method to set up indexing.
+   *
+   * @param inputs      The input on which to run the similarity search. Must have the
+   *                    same schema as the dataset.
+   *
+   * @param datasetId   The dataset to search for similar examples.
+   *
+   * @param limit       The maximum number of examples to return. Will return the top `limit` most
+   *                    similar examples in order of most similar to least similar. If no similar
+   *                    examples are found, random examples will be returned.
+   *
+   * @param filter      A filter string to apply to the search. Only examples will be returned that
+   *                    match the filter string. Some examples of filters
+   *
+   *                    - eq(metadata.mykey, "value")
+   *                    - and(neq(metadata.my.nested.key, "value"), neq(metadata.mykey, "value"))
+   *                    - or(eq(metadata.mykey, "value"), eq(metadata.mykey, "othervalue"))
+   *
+   * @returns           A list of similar examples.
+   *
+   *
+   * @example
+   * dataset_id = "123e4567-e89b-12d3-a456-426614174000"
+   * inputs = {"text": "How many people live in Berlin?"}
+   * limit = 5
+   * examples = await client.similarExamples(inputs, dataset_id, limit)
+   */
+  async similarExamples(t, e, a, { filter: i } = {}) {
+    const s = {
+      limit: a,
+      inputs: t
+    };
+    i !== void 0 && (s.filter = i), f(e);
+    const r = await this.caller.call(u(), `${this.apiUrl}/datasets/${e}/search`, {
+      method: "POST",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(s),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    return await p(r, "fetch similar examples"), (await r.json()).examples;
+  }
+  async createExample(t, e, { datasetId: a, datasetName: i, createdAt: s, exampleId: r, metadata: o, split: n, sourceRunId: d }) {
+    let l = a;
+    if (l === void 0 && i === void 0)
+      throw new Error("Must provide either datasetName or datasetId");
+    if (l !== void 0 && i !== void 0)
+      throw new Error("Must provide either datasetName or datasetId, not both");
+    l === void 0 && (l = (await this.readDataset({ datasetName: i })).id);
+    const h = s || /* @__PURE__ */ new Date(), c = {
+      dataset_id: l,
+      inputs: t,
+      outputs: e,
+      created_at: h == null ? void 0 : h.toISOString(),
+      id: r,
+      metadata: o,
+      split: n,
+      source_run_id: d
+    }, _ = await this.caller.call(u(), `${this.apiUrl}/examples`, {
+      method: "POST",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(c),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    return await p(_, "create example"), await _.json();
+  }
+  async createExamples(t) {
+    const { inputs: e, outputs: a, metadata: i, sourceRunIds: s, exampleIds: r, datasetId: o, datasetName: n } = t;
+    let d = o;
+    if (d === void 0 && n === void 0)
+      throw new Error("Must provide either datasetName or datasetId");
+    if (d !== void 0 && n !== void 0)
+      throw new Error("Must provide either datasetName or datasetId, not both");
+    d === void 0 && (d = (await this.readDataset({ datasetName: n })).id);
+    const l = e.map((_, m) => ({
+      dataset_id: d,
+      inputs: _,
+      outputs: a ? a[m] : void 0,
+      metadata: i ? i[m] : void 0,
+      split: t.splits ? t.splits[m] : void 0,
+      id: r ? r[m] : void 0,
+      source_run_id: s ? s[m] : void 0
+    })), h = await this.caller.call(u(), `${this.apiUrl}/examples/bulk`, {
+      method: "POST",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(l),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    return await p(h, "create examples"), await h.json();
+  }
+  async createLLMExample(t, e, a) {
+    return this.createExample({ input: t }, { output: e }, a);
+  }
+  async createChatExample(t, e, a) {
+    const i = t.map((r) => N(r) ? x(r) : r), s = N(e) ? x(e) : e;
+    return this.createExample({ input: i }, { output: s }, a);
+  }
+  async readExample(t) {
+    f(t);
+    const e = `/examples/${t}`;
+    return await this._get(e);
+  }
+  async *listExamples({ datasetId: t, datasetName: e, exampleIds: a, asOf: i, splits: s, inlineS3Urls: r, metadata: o, limit: n, offset: d, filter: l } = {}) {
+    let h;
+    if (t !== void 0 && e !== void 0)
+      throw new Error("Must provide either datasetName or datasetId, not both");
+    if (t !== void 0)
+      h = t;
+    else if (e !== void 0)
+      h = (await this.readDataset({ datasetName: e })).id;
+    else
+      throw new Error("Must provide a datasetName or datasetId");
+    const c = new URLSearchParams({ dataset: h }), _ = i ? typeof i == "string" ? i : i == null ? void 0 : i.toISOString() : void 0;
+    _ && c.append("as_of", _);
+    const m = r ?? !0;
+    if (c.append("inline_s3_urls", m.toString()), a !== void 0)
+      for (const w of a)
+        c.append("id", w);
+    if (s !== void 0)
+      for (const w of s)
+        c.append("splits", w);
+    if (o !== void 0) {
+      const w = JSON.stringify(o);
+      c.append("metadata", w);
+    }
+    n !== void 0 && c.append("limit", n.toString()), d !== void 0 && c.append("offset", d.toString()), l !== void 0 && c.append("filter", l);
+    let b = 0;
+    for await (const w of this._getPaginated("/examples", c)) {
+      for (const y of w)
+        yield y, b++;
+      if (n !== void 0 && b >= n)
+        break;
+    }
+  }
+  async deleteExample(t) {
+    f(t);
+    const e = `/examples/${t}`, a = await this.caller.call(u(), this.apiUrl + e, {
+      method: "DELETE",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(a, `delete ${e}`), await a.json();
+  }
+  async updateExample(t, e) {
+    f(t);
+    const a = await this.caller.call(u(), `${this.apiUrl}/examples/${t}`, {
+      method: "PATCH",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(e),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    return await p(a, "update example"), await a.json();
+  }
+  async updateExamples(t) {
+    const e = await this.caller.call(u(), `${this.apiUrl}/examples/bulk`, {
+      method: "PATCH",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(t),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    return await p(e, "update examples"), await e.json();
+  }
+  async listDatasetSplits({ datasetId: t, datasetName: e, asOf: a }) {
+    let i;
+    if (t === void 0 && e === void 0)
+      throw new Error("Must provide dataset name or ID");
+    if (t !== void 0 && e !== void 0)
+      throw new Error("Must provide either datasetName or datasetId, not both");
+    t === void 0 ? i = (await this.readDataset({ datasetName: e })).id : i = t, f(i);
+    const s = new URLSearchParams(), r = a ? typeof a == "string" ? a : a == null ? void 0 : a.toISOString() : void 0;
+    return r && s.append("as_of", r), await this._get(`/datasets/${i}/splits`, s);
+  }
+  async updateDatasetSplits({ datasetId: t, datasetName: e, splitName: a, exampleIds: i, remove: s = !1 }) {
+    let r;
+    if (t === void 0 && e === void 0)
+      throw new Error("Must provide dataset name or ID");
+    if (t !== void 0 && e !== void 0)
+      throw new Error("Must provide either datasetName or datasetId, not both");
+    t === void 0 ? r = (await this.readDataset({ datasetName: e })).id : r = t, f(r);
+    const o = {
+      split_name: a,
+      examples: i.map((d) => (f(d), d)),
+      remove: s
+    }, n = await this.caller.call(u(), `${this.apiUrl}/datasets/${r}/splits`, {
+      method: "PUT",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(o),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(n, "update dataset splits", !0);
+  }
+  /**
+   * @deprecated This method is deprecated and will be removed in future LangSmith versions, use `evaluate` from `langsmith/evaluation` instead.
+   */
+  async evaluateRun(t, e, { sourceInfo: a, loadChildRuns: i, referenceExample: s } = { loadChildRuns: !1 }) {
+    J("This method is deprecated and will be removed in future LangSmith versions, use `evaluate` from `langsmith/evaluation` instead.");
+    let r;
+    if (typeof t == "string")
+      r = await this.readRun(t, { loadChildRuns: i });
+    else if (typeof t == "object" && "id" in t)
+      r = t;
+    else
+      throw new Error(`Invalid run type: ${typeof t}`);
+    r.reference_example_id !== null && r.reference_example_id !== void 0 && (s = await this.readExample(r.reference_example_id));
+    const o = await e.evaluateRun(r, s), [n, d] = await this._logEvaluationFeedback(o, r, a);
+    return d[0];
+  }
+  async createFeedback(t, e, { score: a, value: i, correction: s, comment: r, sourceInfo: o, feedbackSourceType: n = "api", sourceRunId: d, feedbackId: l, feedbackConfig: h, projectId: c, comparativeExperimentId: _ }) {
+    var U;
+    if (!t && !c)
+      throw new Error("One of runId or projectId must be provided");
+    if (t && c)
+      throw new Error("Only one of runId or projectId can be provided");
+    const m = {
+      type: n ?? "api",
+      metadata: o ?? {}
+    };
+    d !== void 0 && (m == null ? void 0 : m.metadata) !== void 0 && !m.metadata.__run && (m.metadata.__run = { run_id: d }), (m == null ? void 0 : m.metadata) !== void 0 && ((U = m.metadata.__run) == null ? void 0 : U.run_id) !== void 0 && f(m.metadata.__run.run_id);
+    const b = {
+      id: l ?? R(),
+      run_id: t,
+      key: e,
+      score: a,
+      value: i,
+      correction: s,
+      comment: r,
+      feedback_source: m,
+      comparative_experiment_id: _,
+      feedbackConfig: h,
+      session_id: c
+    }, w = `${this.apiUrl}/feedback`, y = await this.caller.call(u(), w, {
+      method: "POST",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(b),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    return await p(y, "create feedback", !0), b;
+  }
+  async updateFeedback(t, { score: e, value: a, correction: i, comment: s }) {
+    const r = {};
+    e != null && (r.score = e), a != null && (r.value = a), i != null && (r.correction = i), s != null && (r.comment = s), f(t);
+    const o = await this.caller.call(u(), `${this.apiUrl}/feedback/${t}`, {
+      method: "PATCH",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(r),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(o, "update feedback", !0);
+  }
+  async readFeedback(t) {
+    f(t);
+    const e = `/feedback/${t}`;
+    return await this._get(e);
+  }
+  async deleteFeedback(t) {
+    f(t);
+    const e = `/feedback/${t}`, a = await this.caller.call(u(), this.apiUrl + e, {
+      method: "DELETE",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(a, `delete ${e}`), await a.json();
+  }
+  async *listFeedback({ runIds: t, feedbackKeys: e, feedbackSourceTypes: a } = {}) {
+    const i = new URLSearchParams();
+    if (t && i.append("run", t.join(",")), e)
+      for (const s of e)
+        i.append("key", s);
+    if (a)
+      for (const s of a)
+        i.append("source", s);
+    for await (const s of this._getPaginated("/feedback", i))
+      yield* s;
+  }
+  /**
+   * Creates a presigned feedback token and URL.
+   *
+   * The token can be used to authorize feedback metrics without
+   * needing an API key. This is useful for giving browser-based
+   * applications the ability to submit feedback without needing
+   * to expose an API key.
+   *
+   * @param runId - The ID of the run.
+   * @param feedbackKey - The feedback key.
+   * @param options - Additional options for the token.
+   * @param options.expiration - The expiration time for the token.
+   *
+   * @returns A promise that resolves to a FeedbackIngestToken.
+   */
+  async createPresignedFeedbackToken(t, e, { expiration: a, feedbackConfig: i } = {}) {
+    const s = {
+      run_id: t,
+      feedback_key: e,
+      feedback_config: i
+    };
+    return a ? typeof a == "string" ? s.expires_at = a : (a != null && a.hours || a != null && a.minutes || a != null && a.days) && (s.expires_in = a) : s.expires_in = {
+      hours: 3
+    }, await (await this.caller.call(u(), `${this.apiUrl}/feedback/tokens`, {
+      method: "POST",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(s),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    })).json();
+  }
+  async createComparativeExperiment({ name: t, experimentIds: e, referenceDatasetId: a, createdAt: i, description: s, metadata: r, id: o }) {
+    var l;
+    if (e.length === 0)
+      throw new Error("At least one experiment is required");
+    if (a || (a = (await this.readProject({
+      projectId: e[0]
+    })).reference_dataset_id), !a == null)
+      throw new Error("A reference dataset is required");
+    const n = {
+      id: o,
+      name: t,
+      experiment_ids: e,
+      reference_dataset_id: a,
+      description: s,
+      created_at: (l = i ?? /* @__PURE__ */ new Date()) == null ? void 0 : l.toISOString(),
+      extra: {}
+    };
+    return r && (n.extra.metadata = r), await (await this.caller.call(u(), `${this.apiUrl}/datasets/comparative`, {
+      method: "POST",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(n),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    })).json();
+  }
+  /**
+   * Retrieves a list of presigned feedback tokens for a given run ID.
+   * @param runId The ID of the run.
+   * @returns An async iterable of FeedbackIngestToken objects.
+   */
+  async *listPresignedFeedbackTokens(t) {
+    f(t);
+    const e = new URLSearchParams({ run_id: t });
+    for await (const a of this._getPaginated("/feedback/tokens", e))
+      yield* a;
+  }
+  _selectEvalResults(t) {
+    let e;
+    return "results" in t ? e = t.results : e = [t], e;
+  }
+  async _logEvaluationFeedback(t, e, a) {
+    const i = this._selectEvalResults(t), s = [];
+    for (const r of i) {
+      let o = a || {};
+      r.evaluatorInfo && (o = { ...r.evaluatorInfo, ...o });
+      let n = null;
+      r.targetRunId ? n = r.targetRunId : e && (n = e.id), s.push(await this.createFeedback(n, r.key, {
+        score: r.score,
+        value: r.value,
+        comment: r.comment,
+        correction: r.correction,
+        sourceInfo: o,
+        sourceRunId: r.sourceRunId,
+        feedbackConfig: r.feedbackConfig,
+        feedbackSourceType: "model"
+      }));
+    }
+    return [i, s];
+  }
+  async logEvaluationFeedback(t, e, a) {
+    const [i] = await this._logEvaluationFeedback(t, e, a);
+    return i;
+  }
+  /**
+   * API for managing annotation queues
+   */
+  /**
+   * List the annotation queues on the LangSmith API.
+   * @param options - The options for listing annotation queues
+   * @param options.queueIds - The IDs of the queues to filter by
+   * @param options.name - The name of the queue to filter by
+   * @param options.nameContains - The substring that the queue name should contain
+   * @param options.limit - The maximum number of queues to return
+   * @returns An iterator of AnnotationQueue objects
+   */
+  async *listAnnotationQueues(t = {}) {
+    const { queueIds: e, name: a, nameContains: i, limit: s } = t, r = new URLSearchParams();
+    e && e.forEach((n, d) => {
+      f(n, `queueIds[${d}]`), r.append("ids", n);
+    }), a && r.append("name", a), i && r.append("name_contains", i), r.append("limit", (s !== void 0 ? Math.min(s, 100) : 100).toString());
+    let o = 0;
+    for await (const n of this._getPaginated("/annotation-queues", r))
+      if (yield* n, o++, s !== void 0 && o >= s)
+        break;
+  }
+  /**
+   * Create an annotation queue on the LangSmith API.
+   * @param options - The options for creating an annotation queue
+   * @param options.name - The name of the annotation queue
+   * @param options.description - The description of the annotation queue
+   * @param options.queueId - The ID of the annotation queue
+   * @returns The created AnnotationQueue object
+   */
+  async createAnnotationQueue(t) {
+    const { name: e, description: a, queueId: i } = t, s = {
+      name: e,
+      description: a,
+      id: i || R()
+    }, r = await this.caller.call(u(), `${this.apiUrl}/annotation-queues`, {
+      method: "POST",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(Object.fromEntries(Object.entries(s).filter(([n, d]) => d !== void 0))),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    return await p(r, "create annotation queue"), await r.json();
+  }
+  /**
+   * Read an annotation queue with the specified queue ID.
+   * @param queueId - The ID of the annotation queue to read
+   * @returns The AnnotationQueue object
+   */
+  async readAnnotationQueue(t) {
+    const e = await this.listAnnotationQueues({
+      queueIds: [t]
+    }).next();
+    if (e.done)
+      throw new Error(`Annotation queue with ID ${t} not found`);
+    return e.value;
+  }
+  /**
+   * Update an annotation queue with the specified queue ID.
+   * @param queueId - The ID of the annotation queue to update
+   * @param options - The options for updating the annotation queue
+   * @param options.name - The new name for the annotation queue
+   * @param options.description - The new description for the annotation queue
+   */
+  async updateAnnotationQueue(t, e) {
+    const { name: a, description: i } = e, s = await this.caller.call(u(), `${this.apiUrl}/annotation-queues/${f(t, "queueId")}`, {
+      method: "PATCH",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify({ name: a, description: i }),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(s, "update annotation queue");
+  }
+  /**
+   * Delete an annotation queue with the specified queue ID.
+   * @param queueId - The ID of the annotation queue to delete
+   */
+  async deleteAnnotationQueue(t) {
+    const e = await this.caller.call(u(), `${this.apiUrl}/annotation-queues/${f(t, "queueId")}`, {
+      method: "DELETE",
+      headers: { ...this.headers, Accept: "application/json" },
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(e, "delete annotation queue");
+  }
+  /**
+   * Add runs to an annotation queue with the specified queue ID.
+   * @param queueId - The ID of the annotation queue
+   * @param runIds - The IDs of the runs to be added to the annotation queue
+   */
+  async addRunsToAnnotationQueue(t, e) {
+    const a = await this.caller.call(u(), `${this.apiUrl}/annotation-queues/${f(t, "queueId")}/runs`, {
+      method: "POST",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(e.map((i, s) => f(i, `runIds[${s}]`).toString())),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(a, "add runs to annotation queue");
+  }
+  /**
+   * Get a run from an annotation queue at the specified index.
+   * @param queueId - The ID of the annotation queue
+   * @param index - The index of the run to retrieve
+   * @returns A Promise that resolves to a RunWithAnnotationQueueInfo object
+   * @throws {Error} If the run is not found at the given index or for other API-related errors
+   */
+  async getRunFromAnnotationQueue(t, e) {
+    const a = `/annotation-queues/${f(t, "queueId")}/run`, i = await this.caller.call(u(), `${this.apiUrl}${a}/${e}`, {
+      method: "GET",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    return await p(i, "get run from annotation queue"), await i.json();
+  }
+  async _currentTenantIsOwner(t) {
+    const e = await this._getSettings();
+    return t == "-" || e.tenant_handle === t;
+  }
+  async _ownerConflictError(t, e) {
+    const a = await this._getSettings();
+    return new Error(`Cannot ${t} for another tenant.
+
+      Current tenant: ${a.tenant_handle}
+
+      Requested tenant: ${e}`);
+  }
+  async _getLatestCommitHash(t) {
+    const e = await this.caller.call(u(), `${this.apiUrl}/commits/${t}/?limit=1&offset=0`, {
+      method: "GET",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    }), a = await e.json();
+    if (!e.ok) {
+      const i = typeof a.detail == "string" ? a.detail : JSON.stringify(a.detail), s = new Error(`Error ${e.status}: ${e.statusText}
+${i}`);
+      throw s.statusCode = e.status, s;
+    }
+    if (a.commits.length !== 0)
+      return a.commits[0].commit_hash;
+  }
+  async _likeOrUnlikePrompt(t, e) {
+    const [a, i, s] = O(t), r = await this.caller.call(u(), `${this.apiUrl}/likes/${a}/${i}`, {
+      method: "POST",
+      body: JSON.stringify({ like: e }),
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    return await p(r, `${e ? "like" : "unlike"} prompt`), await r.json();
+  }
+  async _getPromptUrl(t) {
+    const [e, a, i] = O(t);
+    if (await this._currentTenantIsOwner(e)) {
+      const s = await this._getSettings();
+      return i !== "latest" ? `${this.getHostUrl()}/prompts/${a}/${i.substring(0, 8)}?organizationId=${s.id}` : `${this.getHostUrl()}/prompts/${a}?organizationId=${s.id}`;
+    } else
+      return i !== "latest" ? `${this.getHostUrl()}/hub/${e}/${a}/${i.substring(0, 8)}` : `${this.getHostUrl()}/hub/${e}/${a}`;
+  }
+  async promptExists(t) {
+    return !!await this.getPrompt(t);
+  }
+  async likePrompt(t) {
+    return this._likeOrUnlikePrompt(t, !0);
+  }
+  async unlikePrompt(t) {
+    return this._likeOrUnlikePrompt(t, !1);
+  }
+  async *listCommits(t) {
+    for await (const e of this._getPaginated(`/commits/${t}/`, new URLSearchParams(), (a) => a.commits))
+      yield* e;
+  }
+  async *listPrompts(t) {
+    const e = new URLSearchParams();
+    e.append("sort_field", (t == null ? void 0 : t.sortField) ?? "updated_at"), e.append("sort_direction", "desc"), e.append("is_archived", (!!(t != null && t.isArchived)).toString()), (t == null ? void 0 : t.isPublic) !== void 0 && e.append("is_public", t.isPublic.toString()), t != null && t.query && e.append("query", t.query);
+    for await (const a of this._getPaginated("/repos", e, (i) => i.repos))
+      yield* a;
+  }
+  async getPrompt(t) {
+    const [e, a, i] = O(t), s = await this.caller.call(u(), `${this.apiUrl}/repos/${e}/${a}`, {
+      method: "GET",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    if (s.status === 404)
+      return null;
+    await p(s, "get prompt");
+    const r = await s.json();
+    return r.repo ? r.repo : null;
+  }
+  async createPrompt(t, e) {
+    const a = await this._getSettings();
+    if (e != null && e.isPublic && !a.tenant_handle)
+      throw new Error(`Cannot create a public prompt without first
+
+        creating a LangChain Hub handle. 
+        You can add a handle by creating a public prompt at:
+
+        https://smith.langchain.com/prompts`);
+    const [i, s, r] = O(t);
+    if (!await this._currentTenantIsOwner(i))
+      throw await this._ownerConflictError("create a prompt", i);
+    const o = {
+      repo_handle: s,
+      ...(e == null ? void 0 : e.description) && { description: e.description },
+      ...(e == null ? void 0 : e.readme) && { readme: e.readme },
+      ...(e == null ? void 0 : e.tags) && { tags: e.tags },
+      is_public: !!(e != null && e.isPublic)
+    }, n = await this.caller.call(u(), `${this.apiUrl}/repos/`, {
+      method: "POST",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(o),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(n, "create prompt");
+    const { repo: d } = await n.json();
+    return d;
+  }
+  async createCommit(t, e, a) {
+    if (!await this.promptExists(t))
+      throw new Error("Prompt does not exist, you must create it first.");
+    const [i, s, r] = O(t), o = (a == null ? void 0 : a.parentCommitHash) === "latest" || !(a != null && a.parentCommitHash) ? await this._getLatestCommitHash(`${i}/${s}`) : a == null ? void 0 : a.parentCommitHash, n = {
+      manifest: JSON.parse(JSON.stringify(e)),
+      parent_commit: o
+    }, d = await this.caller.call(u(), `${this.apiUrl}/commits/${i}/${s}`, {
+      method: "POST",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(n),
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(d, "create commit");
+    const l = await d.json();
+    return this._getPromptUrl(`${i}/${s}${l.commit_hash ? `:${l.commit_hash}` : ""}`);
+  }
+  async updatePrompt(t, e) {
+    if (!await this.promptExists(t))
+      throw new Error("Prompt does not exist, you must create it first.");
+    const [a, i] = O(t);
+    if (!await this._currentTenantIsOwner(a))
+      throw await this._ownerConflictError("update a prompt", a);
+    const s = {};
+    if ((e == null ? void 0 : e.description) !== void 0 && (s.description = e.description), (e == null ? void 0 : e.readme) !== void 0 && (s.readme = e.readme), (e == null ? void 0 : e.tags) !== void 0 && (s.tags = e.tags), (e == null ? void 0 : e.isPublic) !== void 0 && (s.is_public = e.isPublic), (e == null ? void 0 : e.isArchived) !== void 0 && (s.is_archived = e.isArchived), Object.keys(s).length === 0)
+      throw new Error("No valid update options provided");
+    const r = await this.caller.call(u(), `${this.apiUrl}/repos/${a}/${i}`, {
+      method: "PATCH",
+      body: JSON.stringify(s),
+      headers: {
+        ...this.headers,
+        "Content-Type": "application/json"
+      },
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    return await p(r, "update prompt"), r.json();
+  }
+  async deletePrompt(t) {
+    if (!await this.promptExists(t))
+      throw new Error("Prompt does not exist, you must create it first.");
+    const [e, a, i] = O(t);
+    if (!await this._currentTenantIsOwner(e))
+      throw await this._ownerConflictError("delete a prompt", e);
+    return await (await this.caller.call(u(), `${this.apiUrl}/repos/${e}/${a}`, {
+      method: "DELETE",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    })).json();
+  }
+  async pullPromptCommit(t, e) {
+    const [a, i, s] = O(t), r = await this._getServerInfo(), o = z(r.version, "0.5.23");
+    let n = s;
+    if (!o && s === "latest") {
+      const h = await this._getLatestCommitHash(`${a}/${i}`);
+      if (h)
+        n = h;
+      else
+        throw new Error("No commits found");
+    }
+    const d = await this.caller.call(u(), `${this.apiUrl}/commits/${a}/${i}/${n}${e != null && e.includeModel ? "?include_model=true" : ""}`, {
+      method: "GET",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms),
+      ...this.fetchOptions
+    });
+    await p(d, "pull prompt commit");
+    const l = await d.json();
+    return {
+      owner: a,
+      repo: i,
+      commit_hash: l.commit_hash,
+      manifest: l.manifest,
+      examples: l.examples
+    };
+  }
+  /**
+   * 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.
+   * @private
+   */
+  async _pullPrompt(t, e) {
+    const a = await this.pullPromptCommit(t, {
+      includeModel: e == null ? void 0 : e.includeModel
+    });
+    return JSON.stringify(a.manifest);
+  }
+  async pushPrompt(t, e) {
+    return await this.promptExists(t) ? e && Object.keys(e).some((i) => i !== "object") && await this.updatePrompt(t, {
+      description: e == null ? void 0 : e.description,
+      readme: e == null ? void 0 : e.readme,
+      tags: e == null ? void 0 : e.tags,
+      isPublic: e == null ? void 0 : e.isPublic
+    }) : await this.createPrompt(t, {
+      description: e == null ? void 0 : e.description,
+      readme: e == null ? void 0 : e.readme,
+      tags: e == null ? void 0 : e.tags,
+      isPublic: e == null ? void 0 : e.isPublic
+    }), e != null && e.object ? await this.createCommit(t, e == null ? void 0 : e.object, {
+      parentCommitHash: e == null ? void 0 : e.parentCommitHash
+    }) : await this._getPromptUrl(t);
+  }
+  /**
+     * Clone a public dataset to your own langsmith tenant.
+     * This operation is idempotent. If you already have a dataset with the given name,
+     * this function will do nothing.
+  
+     * @param {string} tokenOrUrl The token of the public dataset to clone.
+     * @param {Object} [options] Additional options for cloning the dataset.
+     * @param {string} [options.sourceApiUrl] The URL of the langsmith server where the data is hosted. Defaults to the API URL of your current client.
+     * @param {string} [options.datasetName] The name of the dataset to create in your tenant. Defaults to the name of the public dataset.
+     * @returns {Promise<void>}
+     */
+  async clonePublicDataset(t, e = {}) {
+    const { sourceApiUrl: a = this.apiUrl, datasetName: i } = e, [s, r] = this.parseTokenOrUrl(t, a), o = new A({
+      apiUrl: s,
+      // Placeholder API key not needed anymore in most cases, but
+      // some private deployments may have API key-based rate limiting
+      // that would cause this to fail if we provide no value.
+      apiKey: "placeholder"
+    }), n = await o.readSharedDataset(r), d = i || n.name;
+    try {
+      if (await this.hasDataset({ datasetId: d })) {
+        console.log(`Dataset ${d} already exists in your tenant. Skipping.`);
+        return;
+      }
+    } catch {
+    }
+    const l = await o.listSharedExamples(r), h = await this.createDataset(d, {
+      description: n.description,
+      dataType: n.data_type || "kv",
+      inputsSchema: n.inputs_schema_definition ?? void 0,
+      outputsSchema: n.outputs_schema_definition ?? void 0
+    });
+    try {
+      await this.createExamples({
+        inputs: l.map((c) => c.inputs),
+        outputs: l.flatMap((c) => c.outputs ? [c.outputs] : []),
+        datasetId: h.id
+      });
+    } catch (c) {
+      throw console.error(`An error occurred while creating dataset ${d}. You should delete it manually.`), c;
+    }
+  }
+  parseTokenOrUrl(t, e, a = 2, i = "dataset") {
+    try {
+      return f(t), [e, t];
+    } catch {
+    }
+    try {
+      const r = new URL(t).pathname.split("/").filter((o) => o !== "");
+      if (r.length >= a) {
+        const o = r[r.length - a];
+        return [e, o];
+      } else
+        throw new Error(`Invalid public ${i} URL: ${t}`);
+    } catch {
+      throw new Error(`Invalid public ${i} URL or token: ${t}`);
+    }
+  }
+  /**
+   * Awaits all pending trace batches. Useful for environments where
+   * you need to be sure that all tracing requests finish before execution ends,
+   * such as serverless environments.
+   *
+   * @example
+   * ```
+   * import { Client } from "langsmith";
+   *
+   * const client = new Client();
+   *
+   * try {
+   *   // Tracing happens here
+   *   ...
+   * } finally {
+   *   await client.awaitPendingTraceBatches();
+   * }
+   * ```
+   *
+   * @returns A promise that resolves once all currently pending traces have sent.
+   */
+  awaitPendingTraceBatches() {
+    return Promise.all(this.autoBatchQueue.items.map(({ itemPromise: t }) => t));
+  }
+}
+export {
+  A as Client,
+  V as DEFAULT_BATCH_SIZE_LIMIT_BYTES,
+  Y as Queue,
+  D as mergeRuntimeEnvIntoRunCreate
+};
+//# sourceMappingURL=client.js.map