langgraph-ui-components 0.0.2 → 0.0.3

package/dist/index.es113.js

@@ -1,889 +1,447 @@
-import { Client } from "./index.es166.js";
-import { isTracingEnabled } from "./index.es177.js";
-import { isConflictingEndpointsError, ConflictingEndpointsError } from "./index.es175.js";
-import { _LC_CONTEXT_VARIABLES_KEY, _REPLICA_TRACE_ROOTS_KEY } from "./index.es178.js";
-import { getContextVar, setContextVar } from "./index.es179.js";
-import { getEnvironmentVariable, getRuntimeEnvironment, getLangSmithEnvironmentVariable } from "./index.es171.js";
-import { getDefaultProjectName } from "./index.es149.js";
-import { warnOnce } from "./index.es173.js";
-import { uuid7FromTime } from "./index.es172.js";
-import { v5 } from "uuid";
-const UUID_NAMESPACE_DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
-function getReplicaKey(replica) {
-  const sortedKeys = Object.keys(replica).sort();
-  const keyData = sortedKeys.map((key) => `${key}:${replica[key] ?? ""}`).join("|");
-  return v5(keyData, UUID_NAMESPACE_DNS);
-}
-function stripNonAlphanumeric(input) {
-  return input.replace(/[-:.]/g, "");
+import { __export } from "./index.es46.js";
+import { getRuntimeEnvironment } from "./index.es127.js";
+import { BaseCallbackHandler } from "./index.es128.js";
+import { convertToDottedOrderFormat, RunTree } from "./index.es110.js";
+var base_exports = {};
+__export(base_exports, {
+  BaseTracer: () => BaseTracer,
+  isBaseTracer: () => isBaseTracer
+});
+const convertRunTreeToRun = (runTree) => {
+  if (!runTree) return void 0;
+  runTree.events = runTree.events ?? [];
+  runTree.child_runs = runTree.child_runs ?? [];
+  return runTree;
+};
+function convertRunToRunTree(run, parentRun) {
+  if (!run) return void 0;
+  return new RunTree({
+    ...run,
+    start_time: run._serialized_start_time ?? run.start_time,
+    parent_run: convertRunToRunTree(parentRun),
+    child_runs: run.child_runs.map((r) => convertRunToRunTree(r)).filter((r) => r !== void 0),
+    extra: {
+      ...run.extra,
+      runtime: getRuntimeEnvironment()
+    },
+    tracingEnabled: false
+  });
 }
-function getMicrosecondPrecisionDatestring(epoch, executionOrder = 1) {
-  const paddedOrder = executionOrder.toFixed(0).slice(0, 3).padStart(3, "0");
-  return `${new Date(epoch).toISOString().slice(0, -1)}${paddedOrder}Z`;
+function _coerceToDict(value, defaultKey) {
+  return value && !Array.isArray(value) && typeof value === "object" ? value : { [defaultKey]: value };
 }
-function convertToDottedOrderFormat(epoch, runId, executionOrder = 1) {
-  const microsecondPrecisionDatestring = getMicrosecondPrecisionDatestring(epoch, executionOrder);
-  return {
-    dottedOrder: stripNonAlphanumeric(microsecondPrecisionDatestring) + runId,
-    microsecondPrecisionDatestring
-  };
+function isBaseTracer(x) {
+  return typeof x._addRunToRunMap === "function";
 }
-class Baggage {
-  constructor(metadata, tags, project_name, replicas) {
-    Object.defineProperty(this, "metadata", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "tags", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "project_name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "replicas", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    this.metadata = metadata;
-    this.tags = tags;
-    this.project_name = project_name;
-    this.replicas = replicas;
+var BaseTracer = class extends BaseCallbackHandler {
+  /** @deprecated Use `runTreeMap` instead. */
+  runMap = /* @__PURE__ */ new Map();
+  runTreeMap = /* @__PURE__ */ new Map();
+  usesRunTreeMap = false;
+  constructor(_fields) {
+    super(...arguments);
   }
-  static fromHeader(value) {
-    const items = value.split(",");
-    let metadata = {};
-    let tags = [];
-    let project_name;
-    let replicas;
-    for (const item of items) {
-      const [key, uriValue] = item.split("=");
-      const value2 = decodeURIComponent(uriValue);
-      if (key === "langsmith-metadata") {
-        metadata = JSON.parse(value2);
-      } else if (key === "langsmith-tags") {
-        tags = value2.split(",");
-      } else if (key === "langsmith-project") {
-        project_name = value2;
-      } else if (key === "langsmith-replicas") {
-        replicas = JSON.parse(value2);
-      }
-    }
-    return new Baggage(metadata, tags, project_name, replicas);
+  copy() {
+    return this;
   }
-  toHeader() {
-    const items = [];
-    if (this.metadata && Object.keys(this.metadata).length > 0) {
-      items.push(`langsmith-metadata=${encodeURIComponent(JSON.stringify(this.metadata))}`);
-    }
-    if (this.tags && this.tags.length > 0) {
-      items.push(`langsmith-tags=${encodeURIComponent(this.tags.join(","))}`);
-    }
-    if (this.project_name) {
-      items.push(`langsmith-project=${encodeURIComponent(this.project_name)}`);
-    }
-    return items.join(",");
+  getRunById(runId) {
+    if (runId === void 0) return void 0;
+    return this.usesRunTreeMap ? convertRunTreeToRun(this.runTreeMap.get(runId)) : this.runMap.get(runId);
   }
-}
-class RunTree {
-  constructor(originalConfig) {
-    Object.defineProperty(this, "id", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "run_type", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "project_name", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "parent_run", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "parent_run_id", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "child_runs", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "start_time", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "end_time", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "extra", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "tags", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "error", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "serialized", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "inputs", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "outputs", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "reference_example_id", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "client", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "events", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "trace_id", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "dotted_order", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "tracingEnabled", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "execution_order", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "child_execution_order", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "attachments", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "replicas", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "distributedParentId", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "_serialized_start_time", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "_awaitInputsOnPost", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    if (isRunTree(originalConfig)) {
-      Object.assign(this, { ...originalConfig });
-      return;
-    }
-    const defaultConfig = RunTree.getDefaultConfig();
-    const { metadata, ...config } = originalConfig;
-    const client = config.client ?? RunTree.getSharedClient();
-    const dedupedMetadata = {
-      ...metadata,
-      ...config?.extra?.metadata
-    };
-    config.extra = { ...config.extra, metadata: dedupedMetadata };
-    if ("id" in config && config.id == null) {
-      delete config.id;
-    }
-    Object.assign(this, { ...defaultConfig, ...config, client });
-    this.execution_order ??= 1;
-    this.child_execution_order ??= 1;
-    if (!this.dotted_order) {
-      this._serialized_start_time = getMicrosecondPrecisionDatestring(this.start_time, this.execution_order);
-    }
-    if (!this.id) {
-      this.id = uuid7FromTime(this._serialized_start_time ?? this.start_time);
-    }
-    if (!this.trace_id) {
-      if (this.parent_run) {
-        this.trace_id = this.parent_run.trace_id ?? this.id;
-      } else {
-        this.trace_id = this.id;
-      }
-    }
-    this.replicas = _ensureWriteReplicas(this.replicas);
-    if (!this.dotted_order) {
-      const { dottedOrder } = convertToDottedOrderFormat(this.start_time, this.id, this.execution_order);
-      if (this.parent_run) {
-        this.dotted_order = this.parent_run.dotted_order + "." + dottedOrder;
-      } else {
-        this.dotted_order = dottedOrder;
-      }
-    }
+  stringifyError(error) {
+    if (error instanceof Error) return error.message + (error?.stack ? `
+
+${error.stack}` : "");
+    if (typeof error === "string") return error;
+    return `${error}`;
+  }
+  _addChildRun(parentRun, childRun) {
+    parentRun.child_runs.push(childRun);
   }
-  set metadata(metadata) {
-    this.extra = {
-      ...this.extra,
-      metadata: {
-        ...this.extra?.metadata,
-        ...metadata
+  _addRunToRunMap(run) {
+    const { dottedOrder: currentDottedOrder, microsecondPrecisionDatestring } = convertToDottedOrderFormat(new Date(run.start_time).getTime(), run.id, run.execution_order);
+    const storedRun = { ...run };
+    const parentRun = this.getRunById(storedRun.parent_run_id);
+    if (storedRun.parent_run_id !== void 0) if (parentRun) {
+      this._addChildRun(parentRun, storedRun);
+      parentRun.child_execution_order = Math.max(parentRun.child_execution_order, storedRun.child_execution_order);
+      storedRun.trace_id = parentRun.trace_id;
+      if (parentRun.dotted_order !== void 0) {
+        storedRun.dotted_order = [parentRun.dotted_order, currentDottedOrder].join(".");
+        storedRun._serialized_start_time = microsecondPrecisionDatestring;
       }
-    };
+    } else storedRun.parent_run_id = void 0;
+    else {
+      storedRun.trace_id = storedRun.id;
+      storedRun.dotted_order = currentDottedOrder;
+      storedRun._serialized_start_time = microsecondPrecisionDatestring;
+    }
+    if (this.usesRunTreeMap) {
+      const runTree = convertRunToRunTree(storedRun, parentRun);
+      if (runTree !== void 0) this.runTreeMap.set(storedRun.id, runTree);
+    } else this.runMap.set(storedRun.id, storedRun);
+    return storedRun;
+  }
+  async _endTrace(run) {
+    const parentRun = run.parent_run_id !== void 0 && this.getRunById(run.parent_run_id);
+    if (parentRun) parentRun.child_execution_order = Math.max(parentRun.child_execution_order, run.child_execution_order);
+    else await this.persistRun(run);
+    await this.onRunUpdate?.(run);
+    if (this.usesRunTreeMap) this.runTreeMap.delete(run.id);
+    else this.runMap.delete(run.id);
   }
-  get metadata() {
-    return this.extra?.metadata;
+  _getExecutionOrder(parentRunId) {
+    const parentRun = parentRunId !== void 0 && this.getRunById(parentRunId);
+    if (!parentRun) return 1;
+    return parentRun.child_execution_order + 1;
   }
-  static getDefaultConfig() {
+  /**
+  * Create and add a run to the run map for LLM start events.
+  * This must sometimes be done synchronously to avoid race conditions
+  * when callbacks are backgrounded, so we expose it as a separate method here.
+  */
+  _createRunForLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
+    const execution_order = this._getExecutionOrder(parentRunId);
     const start_time = Date.now();
-    return {
-      run_type: "chain",
-      project_name: getDefaultProjectName(),
-      child_runs: [],
-      api_url: getEnvironmentVariable("LANGCHAIN_ENDPOINT") ?? "http://localhost:1984",
-      api_key: getEnvironmentVariable("LANGCHAIN_API_KEY"),
-      caller_options: {},
+    const finalExtraParams = metadata ? {
+      ...extraParams,
+      metadata
+    } : extraParams;
+    const run = {
+      id: runId,
+      name: name ?? llm.id[llm.id.length - 1],
+      parent_run_id: parentRunId,
       start_time,
-      serialized: {},
-      inputs: {},
-      extra: {}
+      serialized: llm,
+      events: [{
+        name: "start",
+        time: new Date(start_time).toISOString()
+      }],
+      inputs: { prompts },
+      execution_order,
+      child_runs: [],
+      child_execution_order: execution_order,
+      run_type: "llm",
+      extra: finalExtraParams ?? {},
+      tags: tags || []
     };
+    return this._addRunToRunMap(run);
   }
-  static getSharedClient() {
-    if (!RunTree.sharedClient) {
-      RunTree.sharedClient = new Client();
-    }
-    return RunTree.sharedClient;
+  async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
+    const run = this.getRunById(runId) ?? this._createRunForLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name);
+    await this.onRunCreate?.(run);
+    await this.onLLMStart?.(run);
+    return run;
   }
-  createChild(config) {
-    const child_execution_order = this.child_execution_order + 1;
-    const inheritedReplicas = this.replicas?.map((replica) => {
-      const { reroot, ...rest } = replica;
-      return rest;
-    });
-    const childReplicas = config.replicas ?? inheritedReplicas;
-    const child = new RunTree({
-      ...config,
-      parent_run: this,
-      project_name: this.project_name,
-      replicas: childReplicas,
-      client: this.client,
-      tracingEnabled: this.tracingEnabled,
-      execution_order: child_execution_order,
-      child_execution_order
-    });
-    if (_LC_CONTEXT_VARIABLES_KEY in this) {
-      child[_LC_CONTEXT_VARIABLES_KEY] = this[_LC_CONTEXT_VARIABLES_KEY];
-    }
-    const LC_CHILD = /* @__PURE__ */ Symbol.for("lc:child_config");
-    const presentConfig = config.extra?.[LC_CHILD] ?? this.extra[LC_CHILD];
-    if (isRunnableConfigLike(presentConfig)) {
-      const newConfig = { ...presentConfig };
-      const callbacks = isCallbackManagerLike(newConfig.callbacks) ? newConfig.callbacks.copy?.() : void 0;
-      if (callbacks) {
-        Object.assign(callbacks, { _parentRunId: child.id });
-        callbacks.handlers?.find(isLangChainTracerLike)?.updateFromRunTree?.(child);
-        newConfig.callbacks = callbacks;
-      }
-      child.extra[LC_CHILD] = newConfig;
-    }
-    const visited = /* @__PURE__ */ new Set();
-    let current = this;
-    while (current != null && !visited.has(current.id)) {
-      visited.add(current.id);
-      current.child_execution_order = Math.max(current.child_execution_order, child_execution_order);
-      current = current.parent_run;
-    }
-    this.child_runs.push(child);
-    return child;
+  /**
+  * Create and add a run to the run map for chat model start events.
+  * This must sometimes be done synchronously to avoid race conditions
+  * when callbacks are backgrounded, so we expose it as a separate method here.
+  */
+  _createRunForChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
+    const execution_order = this._getExecutionOrder(parentRunId);
+    const start_time = Date.now();
+    const finalExtraParams = metadata ? {
+      ...extraParams,
+      metadata
+    } : extraParams;
+    const run = {
+      id: runId,
+      name: name ?? llm.id[llm.id.length - 1],
+      parent_run_id: parentRunId,
+      start_time,
+      serialized: llm,
+      events: [{
+        name: "start",
+        time: new Date(start_time).toISOString()
+      }],
+      inputs: { messages },
+      execution_order,
+      child_runs: [],
+      child_execution_order: execution_order,
+      run_type: "llm",
+      extra: finalExtraParams ?? {},
+      tags: tags || []
+    };
+    return this._addRunToRunMap(run);
   }
-  async end(outputs, error, endTime = Date.now(), metadata) {
-    this.outputs = this.outputs ?? outputs;
-    this.error = this.error ?? error;
-    this.end_time = this.end_time ?? endTime;
-    if (metadata && Object.keys(metadata).length > 0) {
-      this.extra = this.extra ? { ...this.extra, metadata: { ...this.extra.metadata, ...metadata } } : { metadata };
-    }
+  async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
+    const run = this.getRunById(runId) ?? this._createRunForChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name);
+    await this.onRunCreate?.(run);
+    await this.onLLMStart?.(run);
+    return run;
   }
-  _convertToCreate(run, runtimeEnv, excludeChildRuns = true) {
-    const runExtra = run.extra ?? {};
-    if (runExtra?.runtime?.library === void 0) {
-      if (!runExtra.runtime) {
-        runExtra.runtime = {};
-      }
-      if (runtimeEnv) {
-        for (const [k, v] of Object.entries(runtimeEnv)) {
-          if (!runExtra.runtime[k]) {
-            runExtra.runtime[k] = v;
-          }
-        }
-      }
-    }
-    let child_runs;
-    let parent_run_id;
-    if (!excludeChildRuns) {
-      child_runs = run.child_runs.map((child_run) => this._convertToCreate(child_run, runtimeEnv, excludeChildRuns));
-      parent_run_id = void 0;
-    } else {
-      parent_run_id = run.parent_run?.id ?? run.parent_run_id;
-      child_runs = [];
-    }
-    return {
-      id: run.id,
-      name: run.name,
-      start_time: run._serialized_start_time ?? run.start_time,
-      end_time: run.end_time,
-      run_type: run.run_type,
-      reference_example_id: run.reference_example_id,
-      extra: runExtra,
-      serialized: run.serialized,
-      error: run.error,
-      inputs: run.inputs,
-      outputs: run.outputs,
-      session_name: run.project_name,
-      child_runs,
-      parent_run_id,
-      trace_id: run.trace_id,
-      dotted_order: run.dotted_order,
-      tags: run.tags,
-      attachments: run.attachments,
-      events: run.events
+  async handleLLMEnd(output, runId, _parentRunId, _tags, extraParams) {
+    const run = this.getRunById(runId);
+    if (!run || run?.run_type !== "llm") throw new Error("No LLM run to end.");
+    run.end_time = Date.now();
+    run.outputs = output;
+    run.events.push({
+      name: "end",
+      time: new Date(run.end_time).toISOString()
+    });
+    run.extra = {
+      ...run.extra,
+      ...extraParams
     };
+    await this.onLLMEnd?.(run);
+    await this._endTrace(run);
+    return run;
   }
-  _sliceParentId(parentId, run) {
-    if (run.dotted_order) {
-      const segs = run.dotted_order.split(".");
-      let startIdx = null;
-      for (let idx = 0; idx < segs.length; idx++) {
-        const segId = segs[idx].slice(-36);
-        if (segId === parentId) {
-          startIdx = idx;
-          break;
-        }
-      }
-      if (startIdx !== null) {
-        const trimmedSegs = segs.slice(startIdx + 1);
-        run.dotted_order = trimmedSegs.join(".");
-        if (trimmedSegs.length > 0) {
-          run.trace_id = trimmedSegs[0].slice(-36);
-        } else {
-          run.trace_id = run.id;
-        }
-      }
-    }
-    if (run.parent_run_id === parentId) {
-      run.parent_run_id = void 0;
-    }
-  }
-  _setReplicaTraceRoot(replicaKey, traceRootId) {
-    const replicaTraceRoots = getContextVar(this, _REPLICA_TRACE_ROOTS_KEY) ?? {};
-    replicaTraceRoots[replicaKey] = traceRootId;
-    setContextVar(this, _REPLICA_TRACE_ROOTS_KEY, replicaTraceRoots);
-    for (const child of this.child_runs) {
-      child._setReplicaTraceRoot(replicaKey, traceRootId);
-    }
+  async handleLLMError(error, runId, _parentRunId, _tags, extraParams) {
+    const run = this.getRunById(runId);
+    if (!run || run?.run_type !== "llm") throw new Error("No LLM run to end.");
+    run.end_time = Date.now();
+    run.error = this.stringifyError(error);
+    run.events.push({
+      name: "error",
+      time: new Date(run.end_time).toISOString()
+    });
+    run.extra = {
+      ...run.extra,
+      ...extraParams
+    };
+    await this.onLLMError?.(run);
+    await this._endTrace(run);
+    return run;
   }
-  _remapForProject(params) {
-    const { projectName, runtimeEnv, excludeChildRuns = true, reroot = false, distributedParentId, apiUrl, apiKey, workspaceId } = params;
-    const baseRun = this._convertToCreate(this, runtimeEnv, excludeChildRuns);
-    if (projectName === this.project_name) {
-      return {
-        ...baseRun,
-        session_name: projectName
-      };
-    }
-    if (reroot) {
-      if (distributedParentId) {
-        this._sliceParentId(distributedParentId, baseRun);
-      } else {
-        baseRun.parent_run_id = void 0;
-        if (baseRun.dotted_order) {
-          const segs = baseRun.dotted_order.split(".");
-          if (segs.length > 0) {
-            baseRun.dotted_order = segs[segs.length - 1];
-            baseRun.trace_id = baseRun.id;
-          }
-        }
-      }
-      const replicaKey = getReplicaKey({
-        projectName,
-        apiUrl,
-        apiKey,
-        workspaceId
-      });
-      this._setReplicaTraceRoot(replicaKey, baseRun.id);
-    }
-    let ancestorRerootedTraceId;
-    if (!reroot) {
-      const replicaTraceRoots = getContextVar(this, _REPLICA_TRACE_ROOTS_KEY) ?? {};
-      const replicaKey = getReplicaKey({
-        projectName,
-        apiUrl,
-        apiKey,
-        workspaceId
-      });
-      ancestorRerootedTraceId = replicaTraceRoots[replicaKey];
-      if (ancestorRerootedTraceId) {
-        baseRun.trace_id = ancestorRerootedTraceId;
-        if (baseRun.dotted_order) {
-          const segs = baseRun.dotted_order.split(".");
-          let rootIdx = null;
-          for (let idx = 0; idx < segs.length; idx++) {
-            const segId = segs[idx].slice(-36);
-            if (segId === ancestorRerootedTraceId) {
-              rootIdx = idx;
-              break;
-            }
-          }
-          if (rootIdx !== null) {
-            const trimmedSegs = segs.slice(rootIdx);
-            baseRun.dotted_order = trimmedSegs.join(".");
-          }
-        }
-      }
-    }
-    const oldId = baseRun.id;
-    const newId = v5(`${oldId}:${projectName}`, UUID_NAMESPACE_DNS);
-    let newTraceId;
-    if (baseRun.trace_id) {
-      newTraceId = v5(`${baseRun.trace_id}:${projectName}`, UUID_NAMESPACE_DNS);
-    } else {
-      newTraceId = newId;
-    }
-    let newParentId;
-    if (baseRun.parent_run_id) {
-      newParentId = v5(`${baseRun.parent_run_id}:${projectName}`, UUID_NAMESPACE_DNS);
-    }
-    let newDottedOrder;
-    if (baseRun.dotted_order) {
-      const segs = baseRun.dotted_order.split(".");
-      const remappedSegs = segs.map((seg) => {
-        const segId = seg.slice(-36);
-        const remappedId = v5(`${segId}:${projectName}`, UUID_NAMESPACE_DNS);
-        return seg.slice(0, -36) + remappedId;
-      });
-      newDottedOrder = remappedSegs.join(".");
-    }
-    return {
-      ...baseRun,
-      id: newId,
-      trace_id: newTraceId,
-      parent_run_id: newParentId,
-      dotted_order: newDottedOrder,
-      session_name: projectName
+  /**
+  * Create and add a run to the run map for chain start events.
+  * This must sometimes be done synchronously to avoid race conditions
+  * when callbacks are backgrounded, so we expose it as a separate method here.
+  */
+  _createRunForChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name, extra) {
+    const execution_order = this._getExecutionOrder(parentRunId);
+    const start_time = Date.now();
+    const run = {
+      id: runId,
+      name: name ?? chain.id[chain.id.length - 1],
+      parent_run_id: parentRunId,
+      start_time,
+      serialized: chain,
+      events: [{
+        name: "start",
+        time: new Date(start_time).toISOString()
+      }],
+      inputs,
+      execution_order,
+      child_execution_order: execution_order,
+      run_type: runType ?? "chain",
+      child_runs: [],
+      extra: metadata ? {
+        ...extra,
+        metadata
+      } : { ...extra },
+      tags: tags || []
     };
+    return this._addRunToRunMap(run);
   }
-  async postRun(excludeChildRuns = true) {
-    if (this._awaitInputsOnPost) {
-      this.inputs = await this.inputs;
-    }
-    try {
-      const runtimeEnv = getRuntimeEnvironment();
-      if (this.replicas && this.replicas.length > 0) {
-        for (const { projectName, apiKey, apiUrl, workspaceId, reroot } of this.replicas) {
-          const runCreate = this._remapForProject({
-            projectName: projectName ?? this.project_name,
-            runtimeEnv,
-            excludeChildRuns: true,
-            reroot,
-            distributedParentId: this.distributedParentId,
-            apiUrl,
-            apiKey,
-            workspaceId
-          });
-          await this.client.createRun(runCreate, {
-            apiKey,
-            apiUrl,
-            workspaceId
-          });
-        }
-      } else {
-        const runCreate = this._convertToCreate(this, runtimeEnv, excludeChildRuns);
-        await this.client.createRun(runCreate);
-      }
-      if (!excludeChildRuns) {
-        warnOnce("Posting with excludeChildRuns=false is deprecated and will be removed in a future version.");
-        for (const childRun of this.child_runs) {
-          await childRun.postRun(false);
-        }
-      }
-      this.child_runs = [];
-    } catch (error) {
-      console.error(`Error in postRun for run ${this.id}:`, error);
-    }
+  async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
+    const run = this.getRunById(runId) ?? this._createRunForChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name);
+    await this.onRunCreate?.(run);
+    await this.onChainStart?.(run);
+    return run;
   }
-  async patchRun(options) {
-    if (this.replicas && this.replicas.length > 0) {
-      for (const { projectName, apiKey, apiUrl, workspaceId, updates, reroot } of this.replicas) {
-        const runData = this._remapForProject({
-          projectName: projectName ?? this.project_name,
-          runtimeEnv: void 0,
-          excludeChildRuns: true,
-          reroot,
-          distributedParentId: this.distributedParentId,
-          apiUrl,
-          apiKey,
-          workspaceId
-        });
-        const updatePayload = {
-          id: runData.id,
-          name: runData.name,
-          run_type: runData.run_type,
-          start_time: runData.start_time,
-          outputs: runData.outputs,
-          error: runData.error,
-          parent_run_id: runData.parent_run_id,
-          session_name: runData.session_name,
-          reference_example_id: runData.reference_example_id,
-          end_time: runData.end_time,
-          dotted_order: runData.dotted_order,
-          trace_id: runData.trace_id,
-          events: runData.events,
-          tags: runData.tags,
-          extra: runData.extra,
-          attachments: this.attachments,
-          ...updates
-        };
-        if (!options?.excludeInputs) {
-          updatePayload.inputs = runData.inputs;
-        }
-        await this.client.updateRun(runData.id, updatePayload, {
-          apiKey,
-          apiUrl,
-          workspaceId
-        });
-      }
-    } else {
-      try {
-        const runUpdate = {
-          name: this.name,
-          run_type: this.run_type,
-          start_time: this._serialized_start_time ?? this.start_time,
-          end_time: this.end_time,
-          error: this.error,
-          outputs: this.outputs,
-          parent_run_id: this.parent_run?.id ?? this.parent_run_id,
-          reference_example_id: this.reference_example_id,
-          extra: this.extra,
-          events: this.events,
-          dotted_order: this.dotted_order,
-          trace_id: this.trace_id,
-          tags: this.tags,
-          attachments: this.attachments,
-          session_name: this.project_name
-        };
-        if (!options?.excludeInputs) {
-          runUpdate.inputs = this.inputs;
-        }
-        await this.client.updateRun(this.id, runUpdate);
-      } catch (error) {
-        console.error(`Error in patchRun for run ${this.id}`, error);
-      }
-    }
-    this.child_runs = [];
+  async handleChainEnd(outputs, runId, _parentRunId, _tags, kwargs) {
+    const run = this.getRunById(runId);
+    if (!run) throw new Error("No chain run to end.");
+    run.end_time = Date.now();
+    run.outputs = _coerceToDict(outputs, "output");
+    run.events.push({
+      name: "end",
+      time: new Date(run.end_time).toISOString()
+    });
+    if (kwargs?.inputs !== void 0) run.inputs = _coerceToDict(kwargs.inputs, "input");
+    await this.onChainEnd?.(run);
+    await this._endTrace(run);
+    return run;
   }
-  toJSON() {
-    return this._convertToCreate(this, void 0, false);
+  async handleChainError(error, runId, _parentRunId, _tags, kwargs) {
+    const run = this.getRunById(runId);
+    if (!run) throw new Error("No chain run to end.");
+    run.end_time = Date.now();
+    run.error = this.stringifyError(error);
+    run.events.push({
+      name: "error",
+      time: new Date(run.end_time).toISOString()
+    });
+    if (kwargs?.inputs !== void 0) run.inputs = _coerceToDict(kwargs.inputs, "input");
+    await this.onChainError?.(run);
+    await this._endTrace(run);
+    return run;
   }
   /**
-   * Add an event to the run tree.
-   * @param event - A single event or string to add
-   */
-  addEvent(event) {
-    if (!this.events) {
-      this.events = [];
-    }
-    if (typeof event === "string") {
-      this.events.push({
-        name: "event",
-        time: (/* @__PURE__ */ new Date()).toISOString(),
-        message: event
-      });
-    } else {
-      this.events.push({
-        ...event,
-        time: event.time ?? (/* @__PURE__ */ new Date()).toISOString()
-      });
-    }
+  * Create and add a run to the run map for tool start events.
+  * This must sometimes be done synchronously to avoid race conditions
+  * when callbacks are backgrounded, so we expose it as a separate method here.
+  */
+  _createRunForToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
+    const execution_order = this._getExecutionOrder(parentRunId);
+    const start_time = Date.now();
+    const run = {
+      id: runId,
+      name: name ?? tool.id[tool.id.length - 1],
+      parent_run_id: parentRunId,
+      start_time,
+      serialized: tool,
+      events: [{
+        name: "start",
+        time: new Date(start_time).toISOString()
+      }],
+      inputs: { input },
+      execution_order,
+      child_execution_order: execution_order,
+      run_type: "tool",
+      child_runs: [],
+      extra: metadata ? { metadata } : {},
+      tags: tags || []
+    };
+    return this._addRunToRunMap(run);
   }
-  static fromRunnableConfig(parentConfig, props) {
-    const callbackManager = parentConfig?.callbacks;
-    let parentRun;
-    let projectName;
-    let client;
-    let tracingEnabled = isTracingEnabled();
-    if (callbackManager) {
-      const parentRunId = callbackManager?.getParentRunId?.() ?? "";
-      const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name == "langchain_tracer");
-      parentRun = langChainTracer?.getRun?.(parentRunId);
-      projectName = langChainTracer?.projectName;
-      client = langChainTracer?.client;
-      tracingEnabled = tracingEnabled || !!langChainTracer;
-    }
-    if (!parentRun) {
-      return new RunTree({
-        ...props,
-        client,
-        tracingEnabled,
-        project_name: projectName
-      });
-    }
-    const parentRunTree = new RunTree({
-      name: parentRun.name,
-      id: parentRun.id,
-      trace_id: parentRun.trace_id,
-      dotted_order: parentRun.dotted_order,
-      client,
-      tracingEnabled,
-      project_name: projectName,
-      tags: [
-        ...new Set((parentRun?.tags ?? []).concat(parentConfig?.tags ?? []))
-      ],
-      extra: {
-        metadata: {
-          ...parentRun?.extra?.metadata,
-          ...parentConfig?.metadata
-        }
-      }
-    });
-    return parentRunTree.createChild(props);
+  async handleToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
+    const run = this.getRunById(runId) ?? this._createRunForToolStart(tool, input, runId, parentRunId, tags, metadata, name);
+    await this.onRunCreate?.(run);
+    await this.onToolStart?.(run);
+    return run;
   }
-  static fromDottedOrder(dottedOrder) {
-    return this.fromHeaders({ "langsmith-trace": dottedOrder });
+  async handleToolEnd(output, runId) {
+    const run = this.getRunById(runId);
+    if (!run || run?.run_type !== "tool") throw new Error("No tool run to end");
+    run.end_time = Date.now();
+    run.outputs = { output };
+    run.events.push({
+      name: "end",
+      time: new Date(run.end_time).toISOString()
+    });
+    await this.onToolEnd?.(run);
+    await this._endTrace(run);
+    return run;
   }
-  static fromHeaders(headers, inheritArgs) {
-    const rawHeaders = "get" in headers && typeof headers.get === "function" ? {
-      "langsmith-trace": headers.get("langsmith-trace"),
-      baggage: headers.get("baggage")
-    } : headers;
-    const headerTrace = rawHeaders["langsmith-trace"];
-    if (!headerTrace || typeof headerTrace !== "string")
-      return void 0;
-    const parentDottedOrder = headerTrace.trim();
-    const parsedDottedOrder = parentDottedOrder.split(".").map((part) => {
-      const [strTime, uuid] = part.split("Z");
-      return { strTime, time: Date.parse(strTime + "Z"), uuid };
-    });
-    const traceId = parsedDottedOrder[0].uuid;
-    const config = {
-      ...inheritArgs,
-      name: inheritArgs?.["name"] ?? "parent",
-      run_type: inheritArgs?.["run_type"] ?? "chain",
-      start_time: inheritArgs?.["start_time"] ?? Date.now(),
-      id: parsedDottedOrder.at(-1)?.uuid,
-      trace_id: traceId,
-      dotted_order: parentDottedOrder
-    };
-    if (rawHeaders["baggage"] && typeof rawHeaders["baggage"] === "string") {
-      const baggage = Baggage.fromHeader(rawHeaders["baggage"]);
-      config.metadata = baggage.metadata;
-      config.tags = baggage.tags;
-      config.project_name = baggage.project_name;
-      config.replicas = baggage.replicas;
-    }
-    const runTree = new RunTree(config);
-    runTree.distributedParentId = runTree.id;
-    return runTree;
+  async handleToolError(error, runId) {
+    const run = this.getRunById(runId);
+    if (!run || run?.run_type !== "tool") throw new Error("No tool run to end");
+    run.end_time = Date.now();
+    run.error = this.stringifyError(error);
+    run.events.push({
+      name: "error",
+      time: new Date(run.end_time).toISOString()
+    });
+    await this.onToolError?.(run);
+    await this._endTrace(run);
+    return run;
+  }
+  async handleAgentAction(action, runId) {
+    const run = this.getRunById(runId);
+    if (!run || run?.run_type !== "chain") return;
+    const agentRun = run;
+    agentRun.actions = agentRun.actions || [];
+    agentRun.actions.push(action);
+    agentRun.events.push({
+      name: "agent_action",
+      time: (/* @__PURE__ */ new Date()).toISOString(),
+      kwargs: { action }
+    });
+    await this.onAgentAction?.(run);
+  }
+  async handleAgentEnd(action, runId) {
+    const run = this.getRunById(runId);
+    if (!run || run?.run_type !== "chain") return;
+    run.events.push({
+      name: "agent_end",
+      time: (/* @__PURE__ */ new Date()).toISOString(),
+      kwargs: { action }
+    });
+    await this.onAgentEnd?.(run);
   }
-  toHeaders(headers) {
-    const result = {
-      "langsmith-trace": this.dotted_order,
-      baggage: new Baggage(this.extra?.metadata, this.tags, this.project_name, this.replicas).toHeader()
+  /**
+  * Create and add a run to the run map for retriever start events.
+  * This must sometimes be done synchronously to avoid race conditions
+  * when callbacks are backgrounded, so we expose it as a separate method here.
+  */
+  _createRunForRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
+    const execution_order = this._getExecutionOrder(parentRunId);
+    const start_time = Date.now();
+    const run = {
+      id: runId,
+      name: name ?? retriever.id[retriever.id.length - 1],
+      parent_run_id: parentRunId,
+      start_time,
+      serialized: retriever,
+      events: [{
+        name: "start",
+        time: new Date(start_time).toISOString()
+      }],
+      inputs: { query },
+      execution_order,
+      child_execution_order: execution_order,
+      run_type: "retriever",
+      child_runs: [],
+      extra: metadata ? { metadata } : {},
+      tags: tags || []
     };
-    if (headers) {
-      for (const [key, value] of Object.entries(result)) {
-        headers.set(key, value);
-      }
-    }
-    return result;
+    return this._addRunToRunMap(run);
   }
-}
-Object.defineProperty(RunTree, "sharedClient", {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: null
-});
-function isRunTree(x) {
-  return x != null && typeof x.createChild === "function" && typeof x.postRun === "function";
-}
-function isLangChainTracerLike(x) {
-  return typeof x === "object" && x != null && typeof x.name === "string" && x.name === "langchain_tracer";
-}
-function containsLangChainTracerLike(x) {
-  return Array.isArray(x) && x.some((callback) => isLangChainTracerLike(callback));
-}
-function isCallbackManagerLike(x) {
-  return typeof x === "object" && x != null && Array.isArray(x.handlers);
-}
-function isRunnableConfigLike(x) {
-  const callbacks = x?.callbacks;
-  return x != null && typeof callbacks === "object" && // Callback manager with a langchain tracer
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  (containsLangChainTracerLike(callbacks?.handlers) || // Or it's an array with a LangChainTracerLike object within it
-  containsLangChainTracerLike(callbacks));
-}
-function _getWriteReplicasFromEnv() {
-  const envVar = getEnvironmentVariable("LANGSMITH_RUNS_ENDPOINTS");
-  if (!envVar)
-    return [];
-  try {
-    const parsed = JSON.parse(envVar);
-    if (Array.isArray(parsed)) {
-      const replicas = [];
-      for (const item of parsed) {
-        if (typeof item !== "object" || item === null) {
-          console.warn(`Invalid item type in LANGSMITH_RUNS_ENDPOINTS: expected object, got ${typeof item}`);
-          continue;
-        }
-        if (typeof item.api_url !== "string") {
-          console.warn(`Invalid api_url type in LANGSMITH_RUNS_ENDPOINTS: expected string, got ${typeof item.api_url}`);
-          continue;
-        }
-        if (typeof item.api_key !== "string") {
-          console.warn(`Invalid api_key type in LANGSMITH_RUNS_ENDPOINTS: expected string, got ${typeof item.api_key}`);
-          continue;
-        }
-        replicas.push({
-          apiUrl: item.api_url.replace(/\/$/, ""),
-          apiKey: item.api_key
-        });
-      }
-      return replicas;
-    } else if (typeof parsed === "object" && parsed !== null) {
-      _checkEndpointEnvUnset(parsed);
-      const replicas = [];
-      for (const [url, key] of Object.entries(parsed)) {
-        const cleanUrl = url.replace(/\/$/, "");
-        if (typeof key === "string") {
-          replicas.push({
-            apiUrl: cleanUrl,
-            apiKey: key
-          });
-        } else {
-          console.warn(`Invalid value type in LANGSMITH_RUNS_ENDPOINTS for URL ${url}: expected string, got ${typeof key}`);
-          continue;
-        }
-      }
-      return replicas;
-    } else {
-      console.warn(`Invalid LANGSMITH_RUNS_ENDPOINTS – must be valid JSON array of objects with api_url and api_key properties, or object mapping url->apiKey, got ${typeof parsed}`);
-      return [];
-    }
-  } catch (e) {
-    if (isConflictingEndpointsError(e)) {
-      throw e;
-    }
-    console.warn("Invalid LANGSMITH_RUNS_ENDPOINTS – must be valid JSON array of objects with api_url and api_key properties, or object mapping url->apiKey");
-    return [];
+  async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
+    const run = this.getRunById(runId) ?? this._createRunForRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name);
+    await this.onRunCreate?.(run);
+    await this.onRetrieverStart?.(run);
+    return run;
   }
-}
-function _ensureWriteReplicas(replicas) {
-  if (replicas) {
-    return replicas.map((replica) => {
-      if (Array.isArray(replica)) {
-        return {
-          projectName: replica[0],
-          updates: replica[1]
-        };
+  async handleRetrieverEnd(documents, runId) {
+    const run = this.getRunById(runId);
+    if (!run || run?.run_type !== "retriever") throw new Error("No retriever run to end");
+    run.end_time = Date.now();
+    run.outputs = { documents };
+    run.events.push({
+      name: "end",
+      time: new Date(run.end_time).toISOString()
+    });
+    await this.onRetrieverEnd?.(run);
+    await this._endTrace(run);
+    return run;
+  }
+  async handleRetrieverError(error, runId) {
+    const run = this.getRunById(runId);
+    if (!run || run?.run_type !== "retriever") throw new Error("No retriever run to end");
+    run.end_time = Date.now();
+    run.error = this.stringifyError(error);
+    run.events.push({
+      name: "error",
+      time: new Date(run.end_time).toISOString()
+    });
+    await this.onRetrieverError?.(run);
+    await this._endTrace(run);
+    return run;
+  }
+  async handleText(text, runId) {
+    const run = this.getRunById(runId);
+    if (!run || run?.run_type !== "chain") return;
+    run.events.push({
+      name: "text",
+      time: (/* @__PURE__ */ new Date()).toISOString(),
+      kwargs: { text }
+    });
+    await this.onText?.(run);
+  }
+  async handleLLMNewToken(token, idx, runId, _parentRunId, _tags, fields) {
+    const run = this.getRunById(runId);
+    if (!run || run?.run_type !== "llm") throw new Error(`Invalid "runId" provided to "handleLLMNewToken" callback.`);
+    run.events.push({
+      name: "new_token",
+      time: (/* @__PURE__ */ new Date()).toISOString(),
+      kwargs: {
+        token,
+        idx,
+        chunk: fields?.chunk
       }
-      return replica;
     });
+    await this.onLLMNewToken?.(run, token, { chunk: fields?.chunk });
+    return run;
   }
-  return _getWriteReplicasFromEnv();
-}
-function _checkEndpointEnvUnset(parsed) {
-  if (Object.keys(parsed).length > 0 && getLangSmithEnvironmentVariable("ENDPOINT")) {
-    throw new ConflictingEndpointsError();
-  }
-}
+};
 export {
-  RunTree,
-  convertToDottedOrderFormat,
-  isRunTree,
-  isRunnableConfigLike
+  BaseTracer,
+  base_exports,
+  isBaseTracer
 };
 //# sourceMappingURL=index.es113.js.map