langgraph-ui-components 0.0.3 → 0.0.6

package/dist/index.es111.js

@@ -1,283 +1,504 @@
-import { __export } from "./index.es46.js";
-import { _deepClone, PatchError, unescapePathComponent, isInteger, hasUndefined } from "./index.es135.js";
-var core_exports = {};
-__export(core_exports, {
-  JsonPatchError: () => JsonPatchError,
-  _areEquals: () => _areEquals,
-  applyOperation: () => applyOperation,
-  applyPatch: () => applyPatch,
-  applyReducer: () => applyReducer,
-  deepClone: () => deepClone,
-  getValueByPointer: () => getValueByPointer,
-  validate: () => validate,
-  validator: () => validator
+import { __export } from "./index.es50.js";
+import { getBufferString } from "./index.es42.js";
+import { getEnvironmentVariable } from "./index.es133.js";
+import { isBaseCallbackHandler, BaseCallbackHandler } from "./index.es134.js";
+import { isBaseTracer } from "./index.es118.js";
+import { ConsoleCallbackHandler } from "./index.es135.js";
+import { LangChainTracer } from "./index.es136.js";
+import { consumeCallback } from "./index.es137.js";
+import "./index.es138.js";
+import { isTracingEnabled } from "./index.es139.js";
+import { _getConfigureHooks, getContextVariable } from "./index.es140.js";
+import { v7 } from "uuid";
+var manager_exports = {};
+__export(manager_exports, {
+  BaseCallbackManager: () => BaseCallbackManager,
+  BaseRunManager: () => BaseRunManager,
+  CallbackManager: () => CallbackManager,
+  CallbackManagerForChainRun: () => CallbackManagerForChainRun,
+  CallbackManagerForLLMRun: () => CallbackManagerForLLMRun,
+  CallbackManagerForRetrieverRun: () => CallbackManagerForRetrieverRun,
+  CallbackManagerForToolRun: () => CallbackManagerForToolRun,
+  ensureHandler: () => ensureHandler,
+  parseCallbackConfigArg: () => parseCallbackConfigArg
 });
-const JsonPatchError = PatchError;
-const deepClone = _deepClone;
-function isDangerousKey(key) {
-  return Object.getOwnPropertyNames(Object.prototype).includes(key);
+function parseCallbackConfigArg(arg) {
+  if (!arg) return {};
+  else if (Array.isArray(arg) || "name" in arg) return { callbacks: arg };
+  else return arg;
 }
-const objOps = {
-  add: function(obj, key, document) {
-    if (isDangerousKey(key)) throw new TypeError("JSON-Patch: modifying `__proto__`, `constructor`, or `prototype` prop is banned for security reasons");
-    obj[key] = this.value;
-    return { newDocument: document };
-  },
-  remove: function(obj, key, document) {
-    if (isDangerousKey(key)) throw new TypeError("JSON-Patch: modifying `__proto__`, `constructor`, or `prototype` prop is banned for security reasons");
-    var removed = obj[key];
-    delete obj[key];
-    return {
-      newDocument: document,
-      removed
-    };
-  },
-  replace: function(obj, key, document) {
-    if (isDangerousKey(key)) throw new TypeError("JSON-Patch: modifying `__proto__`, `constructor`, or `prototype` prop is banned for security reasons");
-    var removed = obj[key];
-    obj[key] = this.value;
-    return {
-      newDocument: document,
-      removed
-    };
-  },
-  move: function(obj, key, document) {
-    let removed = getValueByPointer(document, this.path);
-    if (removed) removed = _deepClone(removed);
-    const originalValue = applyOperation(document, {
-      op: "remove",
-      path: this.from
-    }).removed;
-    applyOperation(document, {
-      op: "add",
-      path: this.path,
-      value: originalValue
-    });
-    return {
-      newDocument: document,
-      removed
-    };
-  },
-  copy: function(obj, key, document) {
-    const valueToCopy = getValueByPointer(document, this.from);
-    applyOperation(document, {
-      op: "add",
-      path: this.path,
-      value: _deepClone(valueToCopy)
-    });
-    return { newDocument: document };
-  },
-  test: function(obj, key, document) {
-    return {
-      newDocument: document,
-      test: _areEquals(obj[key], this.value)
-    };
-  },
-  _get: function(obj, key, document) {
-    this.value = obj[key];
-    return { newDocument: document };
+var BaseCallbackManager = class {
+  setHandler(handler) {
+    return this.setHandlers([handler]);
   }
 };
-var arrOps = {
-  add: function(arr, i, document) {
-    if (isInteger(i)) arr.splice(i, 0, this.value);
-    else arr[i] = this.value;
-    return {
-      newDocument: document,
-      index: i
-    };
-  },
-  remove: function(arr, i, document) {
-    var removedList = arr.splice(i, 1);
-    return {
-      newDocument: document,
-      removed: removedList[0]
-    };
-  },
-  replace: function(arr, i, document) {
-    var removed = arr[i];
-    arr[i] = this.value;
-    return {
-      newDocument: document,
-      removed
-    };
-  },
-  move: objOps.move,
-  copy: objOps.copy,
-  test: objOps.test,
-  _get: objOps._get
+var BaseRunManager = class {
+  constructor(runId, handlers, inheritableHandlers, tags, inheritableTags, metadata, inheritableMetadata, _parentRunId) {
+    this.runId = runId;
+    this.handlers = handlers;
+    this.inheritableHandlers = inheritableHandlers;
+    this.tags = tags;
+    this.inheritableTags = inheritableTags;
+    this.metadata = metadata;
+    this.inheritableMetadata = inheritableMetadata;
+    this._parentRunId = _parentRunId;
+  }
+  get parentRunId() {
+    return this._parentRunId;
+  }
+  async handleText(text) {
+    await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
+      try {
+        await handler.handleText?.(text, this.runId, this._parentRunId, this.tags);
+      } catch (err) {
+        const logFunction = handler.raiseError ? console.error : console.warn;
+        logFunction(`Error in handler ${handler.constructor.name}, handleText: ${err}`);
+        if (handler.raiseError) throw err;
+      }
+    }, handler.awaitHandlers)));
+  }
+  async handleCustomEvent(eventName, data, _runId, _tags, _metadata) {
+    await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
+      try {
+        await handler.handleCustomEvent?.(eventName, data, this.runId, this.tags, this.metadata);
+      } catch (err) {
+        const logFunction = handler.raiseError ? console.error : console.warn;
+        logFunction(`Error in handler ${handler.constructor.name}, handleCustomEvent: ${err}`);
+        if (handler.raiseError) throw err;
+      }
+    }, handler.awaitHandlers)));
+  }
 };
-function getValueByPointer(document, pointer) {
-  if (pointer == "") return document;
-  var getOriginalDestination = {
-    op: "_get",
-    path: pointer
-  };
-  applyOperation(document, getOriginalDestination);
-  return getOriginalDestination.value;
-}
-function applyOperation(document, operation, validateOperation = false, mutateDocument = true, banPrototypeModifications = true, index = 0) {
-  if (validateOperation) if (typeof validateOperation == "function") validateOperation(operation, 0, document, operation.path);
-  else validator(operation, 0);
-  if (operation.path === "") {
-    let returnValue = { newDocument: document };
-    if (operation.op === "add") {
-      returnValue.newDocument = operation.value;
-      return returnValue;
-    } else if (operation.op === "replace") {
-      returnValue.newDocument = operation.value;
-      returnValue.removed = document;
-      return returnValue;
-    } else if (operation.op === "move" || operation.op === "copy") {
-      returnValue.newDocument = getValueByPointer(document, operation.from);
-      if (operation.op === "move") returnValue.removed = document;
-      return returnValue;
-    } else if (operation.op === "test") {
-      returnValue.test = _areEquals(document, operation.value);
-      if (returnValue.test === false) throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
-      returnValue.newDocument = document;
-      return returnValue;
-    } else if (operation.op === "remove") {
-      returnValue.removed = document;
-      returnValue.newDocument = null;
-      return returnValue;
-    } else if (operation.op === "_get") {
-      operation.value = document;
-      return returnValue;
-    } else if (validateOperation) throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index, operation, document);
-    else return returnValue;
-  } else {
-    if (!mutateDocument) document = _deepClone(document);
-    const path = operation.path || "";
-    const keys = path.split("/");
-    let obj = document;
-    let t = 1;
-    let len = keys.length;
-    let existingPathFragment = void 0;
-    let key;
-    let validateFunction;
-    if (typeof validateOperation == "function") validateFunction = validateOperation;
-    else validateFunction = validator;
-    while (true) {
-      key = keys[t];
-      if (key && key.indexOf("~") != -1) key = unescapePathComponent(key);
-      if (banPrototypeModifications && (key == "__proto__" || key == "prototype" && t > 0 && keys[t - 1] == "constructor")) throw new TypeError("JSON-Patch: modifying `__proto__` or `constructor/prototype` prop is banned for security reasons, if this was on purpose, please set `banPrototypeModifications` flag false and pass it to this function. More info in fast-json-patch README");
-      if (validateOperation) {
-        if (existingPathFragment === void 0) {
-          if (obj[key] === void 0) existingPathFragment = keys.slice(0, t).join("/");
-          else if (t == len - 1) existingPathFragment = operation.path;
-          if (existingPathFragment !== void 0) validateFunction(operation, 0, document, existingPathFragment);
-        }
+var CallbackManagerForRetrieverRun = class extends BaseRunManager {
+  getChild(tag) {
+    const manager = new CallbackManager(this.runId);
+    manager.setHandlers(this.inheritableHandlers);
+    manager.addTags(this.inheritableTags);
+    manager.addMetadata(this.inheritableMetadata);
+    if (tag) manager.addTags([tag], false);
+    return manager;
+  }
+  async handleRetrieverEnd(documents) {
+    await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
+      if (!handler.ignoreRetriever) try {
+        await handler.handleRetrieverEnd?.(documents, this.runId, this._parentRunId, this.tags);
+      } catch (err) {
+        const logFunction = handler.raiseError ? console.error : console.warn;
+        logFunction(`Error in handler ${handler.constructor.name}, handleRetriever`);
+        if (handler.raiseError) throw err;
+      }
+    }, handler.awaitHandlers)));
+  }
+  async handleRetrieverError(err) {
+    await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
+      if (!handler.ignoreRetriever) try {
+        await handler.handleRetrieverError?.(err, this.runId, this._parentRunId, this.tags);
+      } catch (error) {
+        const logFunction = handler.raiseError ? console.error : console.warn;
+        logFunction(`Error in handler ${handler.constructor.name}, handleRetrieverError: ${error}`);
+        if (handler.raiseError) throw err;
+      }
+    }, handler.awaitHandlers)));
+  }
+};
+var CallbackManagerForLLMRun = class extends BaseRunManager {
+  async handleLLMNewToken(token, idx, _runId, _parentRunId, _tags, fields) {
+    await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
+      if (!handler.ignoreLLM) try {
+        await handler.handleLLMNewToken?.(token, idx ?? {
+          prompt: 0,
+          completion: 0
+        }, this.runId, this._parentRunId, this.tags, fields);
+      } catch (err) {
+        const logFunction = handler.raiseError ? console.error : console.warn;
+        logFunction(`Error in handler ${handler.constructor.name}, handleLLMNewToken: ${err}`);
+        if (handler.raiseError) throw err;
       }
-      t++;
-      if (Array.isArray(obj)) {
-        if (key === "-") key = obj.length;
-        else if (validateOperation && !isInteger(key)) throw new JsonPatchError("Expected an unsigned base-10 integer value, making the new referenced value the array element with the zero-based index", "OPERATION_PATH_ILLEGAL_ARRAY_INDEX", index, operation, document);
-        else if (isInteger(key)) key = ~~key;
-        if (t >= len) {
-          if (validateOperation && operation.op === "add" && key > obj.length) throw new JsonPatchError("The specified index MUST NOT be greater than the number of elements in the array", "OPERATION_VALUE_OUT_OF_BOUNDS", index, operation, document);
-          const returnValue = arrOps[operation.op].call(operation, obj, key, document);
-          if (returnValue.test === false) throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
-          return returnValue;
+    }, handler.awaitHandlers)));
+  }
+  async handleLLMError(err, _runId, _parentRunId, _tags, extraParams) {
+    await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
+      if (!handler.ignoreLLM) try {
+        await handler.handleLLMError?.(err, this.runId, this._parentRunId, this.tags, extraParams);
+      } catch (err$1) {
+        const logFunction = handler.raiseError ? console.error : console.warn;
+        logFunction(`Error in handler ${handler.constructor.name}, handleLLMError: ${err$1}`);
+        if (handler.raiseError) throw err$1;
+      }
+    }, handler.awaitHandlers)));
+  }
+  async handleLLMEnd(output, _runId, _parentRunId, _tags, extraParams) {
+    await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
+      if (!handler.ignoreLLM) try {
+        await handler.handleLLMEnd?.(output, this.runId, this._parentRunId, this.tags, extraParams);
+      } catch (err) {
+        const logFunction = handler.raiseError ? console.error : console.warn;
+        logFunction(`Error in handler ${handler.constructor.name}, handleLLMEnd: ${err}`);
+        if (handler.raiseError) throw err;
+      }
+    }, handler.awaitHandlers)));
+  }
+};
+var CallbackManagerForChainRun = class extends BaseRunManager {
+  getChild(tag) {
+    const manager = new CallbackManager(this.runId);
+    manager.setHandlers(this.inheritableHandlers);
+    manager.addTags(this.inheritableTags);
+    manager.addMetadata(this.inheritableMetadata);
+    if (tag) manager.addTags([tag], false);
+    return manager;
+  }
+  async handleChainError(err, _runId, _parentRunId, _tags, kwargs) {
+    await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
+      if (!handler.ignoreChain) try {
+        await handler.handleChainError?.(err, this.runId, this._parentRunId, this.tags, kwargs);
+      } catch (err$1) {
+        const logFunction = handler.raiseError ? console.error : console.warn;
+        logFunction(`Error in handler ${handler.constructor.name}, handleChainError: ${err$1}`);
+        if (handler.raiseError) throw err$1;
+      }
+    }, handler.awaitHandlers)));
+  }
+  async handleChainEnd(output, _runId, _parentRunId, _tags, kwargs) {
+    await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
+      if (!handler.ignoreChain) try {
+        await handler.handleChainEnd?.(output, this.runId, this._parentRunId, this.tags, kwargs);
+      } catch (err) {
+        const logFunction = handler.raiseError ? console.error : console.warn;
+        logFunction(`Error in handler ${handler.constructor.name}, handleChainEnd: ${err}`);
+        if (handler.raiseError) throw err;
+      }
+    }, handler.awaitHandlers)));
+  }
+  async handleAgentAction(action) {
+    await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
+      if (!handler.ignoreAgent) try {
+        await handler.handleAgentAction?.(action, this.runId, this._parentRunId, this.tags);
+      } catch (err) {
+        const logFunction = handler.raiseError ? console.error : console.warn;
+        logFunction(`Error in handler ${handler.constructor.name}, handleAgentAction: ${err}`);
+        if (handler.raiseError) throw err;
+      }
+    }, handler.awaitHandlers)));
+  }
+  async handleAgentEnd(action) {
+    await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
+      if (!handler.ignoreAgent) try {
+        await handler.handleAgentEnd?.(action, this.runId, this._parentRunId, this.tags);
+      } catch (err) {
+        const logFunction = handler.raiseError ? console.error : console.warn;
+        logFunction(`Error in handler ${handler.constructor.name}, handleAgentEnd: ${err}`);
+        if (handler.raiseError) throw err;
+      }
+    }, handler.awaitHandlers)));
+  }
+};
+var CallbackManagerForToolRun = class extends BaseRunManager {
+  getChild(tag) {
+    const manager = new CallbackManager(this.runId);
+    manager.setHandlers(this.inheritableHandlers);
+    manager.addTags(this.inheritableTags);
+    manager.addMetadata(this.inheritableMetadata);
+    if (tag) manager.addTags([tag], false);
+    return manager;
+  }
+  async handleToolError(err) {
+    await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
+      if (!handler.ignoreAgent) try {
+        await handler.handleToolError?.(err, this.runId, this._parentRunId, this.tags);
+      } catch (err$1) {
+        const logFunction = handler.raiseError ? console.error : console.warn;
+        logFunction(`Error in handler ${handler.constructor.name}, handleToolError: ${err$1}`);
+        if (handler.raiseError) throw err$1;
+      }
+    }, handler.awaitHandlers)));
+  }
+  async handleToolEnd(output) {
+    await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
+      if (!handler.ignoreAgent) try {
+        await handler.handleToolEnd?.(output, this.runId, this._parentRunId, this.tags);
+      } catch (err) {
+        const logFunction = handler.raiseError ? console.error : console.warn;
+        logFunction(`Error in handler ${handler.constructor.name}, handleToolEnd: ${err}`);
+        if (handler.raiseError) throw err;
+      }
+    }, handler.awaitHandlers)));
+  }
+};
+var CallbackManager = class CallbackManager2 extends BaseCallbackManager {
+  handlers = [];
+  inheritableHandlers = [];
+  tags = [];
+  inheritableTags = [];
+  metadata = {};
+  inheritableMetadata = {};
+  name = "callback_manager";
+  _parentRunId;
+  constructor(parentRunId, options) {
+    super();
+    this.handlers = options?.handlers ?? this.handlers;
+    this.inheritableHandlers = options?.inheritableHandlers ?? this.inheritableHandlers;
+    this.tags = options?.tags ?? this.tags;
+    this.inheritableTags = options?.inheritableTags ?? this.inheritableTags;
+    this.metadata = options?.metadata ?? this.metadata;
+    this.inheritableMetadata = options?.inheritableMetadata ?? this.inheritableMetadata;
+    this._parentRunId = parentRunId;
+  }
+  /**
+  * Gets the parent run ID, if any.
+  *
+  * @returns The parent run ID.
+  */
+  getParentRunId() {
+    return this._parentRunId;
+  }
+  async handleLLMStart(llm, prompts, runId = void 0, _parentRunId = void 0, extraParams = void 0, _tags = void 0, _metadata = void 0, runName = void 0) {
+    return Promise.all(prompts.map(async (prompt, idx) => {
+      const runId_ = idx === 0 && runId ? runId : v7();
+      await Promise.all(this.handlers.map((handler) => {
+        if (handler.ignoreLLM) return;
+        if (isBaseTracer(handler)) handler._createRunForLLMStart(llm, [prompt], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+        return consumeCallback(async () => {
+          try {
+            await handler.handleLLMStart?.(llm, [prompt], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+          } catch (err) {
+            const logFunction = handler.raiseError ? console.error : console.warn;
+            logFunction(`Error in handler ${handler.constructor.name}, handleLLMStart: ${err}`);
+            if (handler.raiseError) throw err;
+          }
+        }, handler.awaitHandlers);
+      }));
+      return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
+    }));
+  }
+  async handleChatModelStart(llm, messages, runId = void 0, _parentRunId = void 0, extraParams = void 0, _tags = void 0, _metadata = void 0, runName = void 0) {
+    return Promise.all(messages.map(async (messageGroup, idx) => {
+      const runId_ = idx === 0 && runId ? runId : v7();
+      await Promise.all(this.handlers.map((handler) => {
+        if (handler.ignoreLLM) return;
+        if (isBaseTracer(handler)) handler._createRunForChatModelStart(llm, [messageGroup], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+        return consumeCallback(async () => {
+          try {
+            if (handler.handleChatModelStart) await handler.handleChatModelStart?.(llm, [messageGroup], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+            else if (handler.handleLLMStart) {
+              const messageString = getBufferString(messageGroup);
+              await handler.handleLLMStart?.(llm, [messageString], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+            }
+          } catch (err) {
+            const logFunction = handler.raiseError ? console.error : console.warn;
+            logFunction(`Error in handler ${handler.constructor.name}, handleLLMStart: ${err}`);
+            if (handler.raiseError) throw err;
+          }
+        }, handler.awaitHandlers);
+      }));
+      return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
+    }));
+  }
+  async handleChainStart(chain, inputs, runId = v7(), runType = void 0, _tags = void 0, _metadata = void 0, runName = void 0, _parentRunId = void 0, extra = void 0) {
+    await Promise.all(this.handlers.map((handler) => {
+      if (handler.ignoreChain) return;
+      if (isBaseTracer(handler)) handler._createRunForChainStart(chain, inputs, runId, this._parentRunId, this.tags, this.metadata, runType, runName, extra);
+      return consumeCallback(async () => {
+        try {
+          await handler.handleChainStart?.(chain, inputs, runId, this._parentRunId, this.tags, this.metadata, runType, runName, extra);
+        } catch (err) {
+          const logFunction = handler.raiseError ? console.error : console.warn;
+          logFunction(`Error in handler ${handler.constructor.name}, handleChainStart: ${err}`);
+          if (handler.raiseError) throw err;
         }
-      } else if (t >= len) {
-        const returnValue = objOps[operation.op].call(operation, obj, key, document);
-        if (returnValue.test === false) throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
-        return returnValue;
+      }, handler.awaitHandlers);
+    }));
+    return new CallbackManagerForChainRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
+  }
+  async handleToolStart(tool, input, runId = v7(), _parentRunId = void 0, _tags = void 0, _metadata = void 0, runName = void 0) {
+    await Promise.all(this.handlers.map((handler) => {
+      if (handler.ignoreAgent) return;
+      if (isBaseTracer(handler)) handler._createRunForToolStart(tool, input, runId, this._parentRunId, this.tags, this.metadata, runName);
+      return consumeCallback(async () => {
+        try {
+          await handler.handleToolStart?.(tool, input, runId, this._parentRunId, this.tags, this.metadata, runName);
+        } catch (err) {
+          const logFunction = handler.raiseError ? console.error : console.warn;
+          logFunction(`Error in handler ${handler.constructor.name}, handleToolStart: ${err}`);
+          if (handler.raiseError) throw err;
+        }
+      }, handler.awaitHandlers);
+    }));
+    return new CallbackManagerForToolRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
+  }
+  async handleRetrieverStart(retriever, query, runId = v7(), _parentRunId = void 0, _tags = void 0, _metadata = void 0, runName = void 0) {
+    await Promise.all(this.handlers.map((handler) => {
+      if (handler.ignoreRetriever) return;
+      if (isBaseTracer(handler)) handler._createRunForRetrieverStart(retriever, query, runId, this._parentRunId, this.tags, this.metadata, runName);
+      return consumeCallback(async () => {
+        try {
+          await handler.handleRetrieverStart?.(retriever, query, runId, this._parentRunId, this.tags, this.metadata, runName);
+        } catch (err) {
+          const logFunction = handler.raiseError ? console.error : console.warn;
+          logFunction(`Error in handler ${handler.constructor.name}, handleRetrieverStart: ${err}`);
+          if (handler.raiseError) throw err;
+        }
+      }, handler.awaitHandlers);
+    }));
+    return new CallbackManagerForRetrieverRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
+  }
+  async handleCustomEvent(eventName, data, runId, _tags, _metadata) {
+    await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
+      if (!handler.ignoreCustomEvent) try {
+        await handler.handleCustomEvent?.(eventName, data, runId, this.tags, this.metadata);
+      } catch (err) {
+        const logFunction = handler.raiseError ? console.error : console.warn;
+        logFunction(`Error in handler ${handler.constructor.name}, handleCustomEvent: ${err}`);
+        if (handler.raiseError) throw err;
       }
-      obj = obj[key];
-      if (validateOperation && t < len && (!obj || typeof obj !== "object")) throw new JsonPatchError("Cannot perform operation at the desired path", "OPERATION_PATH_UNRESOLVABLE", index, operation, document);
+    }, handler.awaitHandlers)));
+  }
+  addHandler(handler, inherit = true) {
+    this.handlers.push(handler);
+    if (inherit) this.inheritableHandlers.push(handler);
+  }
+  removeHandler(handler) {
+    this.handlers = this.handlers.filter((_handler) => _handler !== handler);
+    this.inheritableHandlers = this.inheritableHandlers.filter((_handler) => _handler !== handler);
+  }
+  setHandlers(handlers, inherit = true) {
+    this.handlers = [];
+    this.inheritableHandlers = [];
+    for (const handler of handlers) this.addHandler(handler, inherit);
+  }
+  addTags(tags, inherit = true) {
+    this.removeTags(tags);
+    this.tags.push(...tags);
+    if (inherit) this.inheritableTags.push(...tags);
+  }
+  removeTags(tags) {
+    this.tags = this.tags.filter((tag) => !tags.includes(tag));
+    this.inheritableTags = this.inheritableTags.filter((tag) => !tags.includes(tag));
+  }
+  addMetadata(metadata, inherit = true) {
+    this.metadata = {
+      ...this.metadata,
+      ...metadata
+    };
+    if (inherit) this.inheritableMetadata = {
+      ...this.inheritableMetadata,
+      ...metadata
+    };
+  }
+  removeMetadata(metadata) {
+    for (const key of Object.keys(metadata)) {
+      delete this.metadata[key];
+      delete this.inheritableMetadata[key];
     }
   }
-}
-function applyPatch(document, patch, validateOperation, mutateDocument = true, banPrototypeModifications = true) {
-  if (validateOperation) {
-    if (!Array.isArray(patch)) throw new JsonPatchError("Patch sequence must be an array", "SEQUENCE_NOT_AN_ARRAY");
-  }
-  if (!mutateDocument) document = _deepClone(document);
-  const results = new Array(patch.length);
-  for (let i = 0, length = patch.length; i < length; i++) {
-    results[i] = applyOperation(document, patch[i], validateOperation, true, banPrototypeModifications, i);
-    document = results[i].newDocument;
-  }
-  results.newDocument = document;
-  return results;
-}
-function applyReducer(document, operation, index) {
-  const operationResult = applyOperation(document, operation);
-  if (operationResult.test === false) throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
-  return operationResult.newDocument;
-}
-function validator(operation, index, document, existingPathFragment) {
-  if (typeof operation !== "object" || operation === null || Array.isArray(operation)) throw new JsonPatchError("Operation is not an object", "OPERATION_NOT_AN_OBJECT", index, operation, document);
-  else if (!objOps[operation.op]) throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index, operation, document);
-  else if (typeof operation.path !== "string") throw new JsonPatchError("Operation `path` property is not a string", "OPERATION_PATH_INVALID", index, operation, document);
-  else if (operation.path.indexOf("/") !== 0 && operation.path.length > 0) throw new JsonPatchError('Operation `path` property must start with "/"', "OPERATION_PATH_INVALID", index, operation, document);
-  else if ((operation.op === "move" || operation.op === "copy") && typeof operation.from !== "string") throw new JsonPatchError("Operation `from` property is not present (applicable in `move` and `copy` operations)", "OPERATION_FROM_REQUIRED", index, operation, document);
-  else if ((operation.op === "add" || operation.op === "replace" || operation.op === "test") && operation.value === void 0) throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_REQUIRED", index, operation, document);
-  else if ((operation.op === "add" || operation.op === "replace" || operation.op === "test") && hasUndefined(operation.value)) throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_CANNOT_CONTAIN_UNDEFINED", index, operation, document);
-  else if (document) {
-    if (operation.op == "add") {
-      var pathLen = operation.path.split("/").length;
-      var existingPathLen = existingPathFragment.split("/").length;
-      if (pathLen !== existingPathLen + 1 && pathLen !== existingPathLen) throw new JsonPatchError("Cannot perform an `add` operation at the desired path", "OPERATION_PATH_CANNOT_ADD", index, operation, document);
-    } else if (operation.op === "replace" || operation.op === "remove" || operation.op === "_get") {
-      if (operation.path !== existingPathFragment) throw new JsonPatchError("Cannot perform the operation at a path that does not exist", "OPERATION_PATH_UNRESOLVABLE", index, operation, document);
-    } else if (operation.op === "move" || operation.op === "copy") {
-      var existingValue = {
-        op: "_get",
-        path: operation.from,
-        value: void 0
-      };
-      var error = validate([existingValue], document);
-      if (error && error.name === "OPERATION_PATH_UNRESOLVABLE") throw new JsonPatchError("Cannot perform the operation from a path that does not exist", "OPERATION_FROM_UNRESOLVABLE", index, operation, document);
+  copy(additionalHandlers = [], inherit = true) {
+    const manager = new CallbackManager2(this._parentRunId);
+    for (const handler of this.handlers) {
+      const inheritable = this.inheritableHandlers.includes(handler);
+      manager.addHandler(handler, inheritable);
+    }
+    for (const tag of this.tags) {
+      const inheritable = this.inheritableTags.includes(tag);
+      manager.addTags([tag], inheritable);
+    }
+    for (const key of Object.keys(this.metadata)) {
+      const inheritable = Object.keys(this.inheritableMetadata).includes(key);
+      manager.addMetadata({ [key]: this.metadata[key] }, inheritable);
     }
+    for (const handler of additionalHandlers) {
+      if (manager.handlers.filter((h) => h.name === "console_callback_handler").some((h) => h.name === handler.name)) continue;
+      manager.addHandler(handler, inherit);
+    }
+    return manager;
   }
-}
-function validate(sequence, document, externalValidator) {
-  try {
-    if (!Array.isArray(sequence)) throw new JsonPatchError("Patch sequence must be an array", "SEQUENCE_NOT_AN_ARRAY");
-    if (document) applyPatch(_deepClone(document), _deepClone(sequence), externalValidator || true);
-    else {
-      externalValidator = externalValidator || validator;
-      for (var i = 0; i < sequence.length; i++) externalValidator(sequence[i], i, document, void 0);
+  static fromHandlers(handlers) {
+    class Handler extends BaseCallbackHandler {
+      name = v7();
+      constructor() {
+        super();
+        Object.assign(this, handlers);
+      }
     }
-  } catch (e) {
-    if (e instanceof JsonPatchError) return e;
-    else throw e;
+    const manager = new this();
+    manager.addHandler(new Handler());
+    return manager;
   }
-}
-function _areEquals(a, b) {
-  if (a === b) return true;
-  if (a && b && typeof a == "object" && typeof b == "object") {
-    var arrA = Array.isArray(a), arrB = Array.isArray(b), i, length, key;
-    if (arrA && arrB) {
-      length = a.length;
-      if (length != b.length) return false;
-      for (i = length; i-- !== 0; ) if (!_areEquals(a[i], b[i])) return false;
-      return true;
+  static configure(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options) {
+    return this._configureSync(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options);
+  }
+  static _configureSync(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options) {
+    let callbackManager;
+    if (inheritableHandlers || localHandlers) {
+      if (Array.isArray(inheritableHandlers) || !inheritableHandlers) {
+        callbackManager = new CallbackManager2();
+        callbackManager.setHandlers(inheritableHandlers?.map(ensureHandler) ?? [], true);
+      } else callbackManager = inheritableHandlers;
+      callbackManager = callbackManager.copy(Array.isArray(localHandlers) ? localHandlers.map(ensureHandler) : localHandlers?.handlers, false);
+    }
+    const verboseEnabled = getEnvironmentVariable("LANGCHAIN_VERBOSE") === "true" || options?.verbose;
+    const tracingV2Enabled = LangChainTracer.getTraceableRunTree()?.tracingEnabled || isTracingEnabled();
+    const tracingEnabled = tracingV2Enabled || (getEnvironmentVariable("LANGCHAIN_TRACING") ?? false);
+    if (verboseEnabled || tracingEnabled) {
+      if (!callbackManager) callbackManager = new CallbackManager2();
+      if (verboseEnabled && !callbackManager.handlers.some((handler) => handler.name === ConsoleCallbackHandler.prototype.name)) {
+        const consoleHandler = new ConsoleCallbackHandler();
+        callbackManager.addHandler(consoleHandler, true);
+      }
+      if (tracingEnabled && !callbackManager.handlers.some((handler) => handler.name === "langchain_tracer")) {
+        if (tracingV2Enabled) {
+          const tracerV2 = new LangChainTracer();
+          callbackManager.addHandler(tracerV2, true);
+        }
+      }
+      if (tracingV2Enabled) {
+        const implicitRunTree = LangChainTracer.getTraceableRunTree();
+        if (implicitRunTree && callbackManager._parentRunId === void 0) {
+          callbackManager._parentRunId = implicitRunTree.id;
+          const tracerV2 = callbackManager.handlers.find((handler) => handler.name === "langchain_tracer");
+          tracerV2?.updateFromRunTree(implicitRunTree);
+        }
+      }
+    }
+    for (const { contextVar, inheritable = true, handlerClass, envVar } of _getConfigureHooks()) {
+      const createIfNotInContext = envVar && getEnvironmentVariable(envVar) === "true" && handlerClass;
+      let handler;
+      const contextVarValue = contextVar !== void 0 ? getContextVariable(contextVar) : void 0;
+      if (contextVarValue && isBaseCallbackHandler(contextVarValue)) handler = contextVarValue;
+      else if (createIfNotInContext) handler = new handlerClass({});
+      if (handler !== void 0) {
+        if (!callbackManager) callbackManager = new CallbackManager2();
+        if (!callbackManager.handlers.some((h) => h.name === handler.name)) callbackManager.addHandler(handler, inheritable);
+      }
     }
-    if (arrA != arrB) return false;
-    var keys = Object.keys(a);
-    length = keys.length;
-    if (length !== Object.keys(b).length) return false;
-    for (i = length; i-- !== 0; ) if (!b.hasOwnProperty(keys[i])) return false;
-    for (i = length; i-- !== 0; ) {
-      key = keys[i];
-      if (!_areEquals(a[key], b[key])) return false;
+    if (inheritableTags || localTags) {
+      if (callbackManager) {
+        callbackManager.addTags(inheritableTags ?? []);
+        callbackManager.addTags(localTags ?? [], false);
+      }
     }
-    return true;
+    if (inheritableMetadata || localMetadata) {
+      if (callbackManager) {
+        callbackManager.addMetadata(inheritableMetadata ?? {});
+        callbackManager.addMetadata(localMetadata ?? {}, false);
+      }
+    }
+    return callbackManager;
   }
-  return a !== a && b !== b;
+};
+function ensureHandler(handler) {
+  if ("name" in handler) return handler;
+  return BaseCallbackHandler.fromMethods(handler);
 }
 export {
-  _areEquals,
-  applyOperation,
-  applyPatch,
-  applyReducer,
-  core_exports,
-  getValueByPointer,
-  validate,
-  validator
+  BaseCallbackManager,
+  BaseRunManager,
+  CallbackManager,
+  CallbackManagerForChainRun,
+  CallbackManagerForLLMRun,
+  CallbackManagerForRetrieverRun,
+  CallbackManagerForToolRun,
+  ensureHandler,
+  manager_exports,
+  parseCallbackConfigArg
 };
 //# sourceMappingURL=index.es111.js.map