langgraph-ui-components 0.0.4 → 0.0.7

package/dist/index.es115.js

@@ -1,447 +1,283 @@
-import { __export } from "./index.es48.js";
-import { getRuntimeEnvironment } from "./index.es129.js";
-import { BaseCallbackHandler } from "./index.es130.js";
-import { convertToDottedOrderFormat, RunTree } from "./index.es112.js";
-var base_exports = {};
-__export(base_exports, {
-  BaseTracer: () => BaseTracer,
-  isBaseTracer: () => isBaseTracer
+import { __export } from "./index.es52.js";
+import { _deepClone, PatchError, unescapePathComponent, isInteger, hasUndefined } from "./index.es140.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
 });
-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 _coerceToDict(value, defaultKey) {
-  return value && !Array.isArray(value) && typeof value === "object" ? value : { [defaultKey]: value };
+const JsonPatchError = PatchError;
+const deepClone = _deepClone;
+function isDangerousKey(key) {
+  return Object.getOwnPropertyNames(Object.prototype).includes(key);
 }
-function isBaseTracer(x) {
-  return typeof x._addRunToRunMap === "function";
-}
-var BaseTracer = class extends BaseCallbackHandler {
-  /** @deprecated Use `runTreeMap` instead. */
-  runMap = /* @__PURE__ */ new Map();
-  runTreeMap = /* @__PURE__ */ new Map();
-  usesRunTreeMap = false;
-  constructor(_fields) {
-    super(...arguments);
-  }
-  copy() {
-    return this;
-  }
-  getRunById(runId) {
-    if (runId === void 0) return void 0;
-    return this.usesRunTreeMap ? convertRunTreeToRun(this.runTreeMap.get(runId)) : this.runMap.get(runId);
-  }
-  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);
-  }
-  _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);
-  }
-  _getExecutionOrder(parentRunId) {
-    const parentRun = parentRunId !== void 0 && this.getRunById(parentRunId);
-    if (!parentRun) return 1;
-    return parentRun.child_execution_order + 1;
-  }
-  /**
-  * 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();
-    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: { prompts },
-      execution_order,
-      child_runs: [],
-      child_execution_order: execution_order,
-      run_type: "llm",
-      extra: finalExtraParams ?? {},
-      tags: tags || []
+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
     };
-    return this._addRunToRunMap(run);
-  }
-  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;
-  }
-  /**
-  * 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 || []
+  },
+  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
     };
-    return this._addRunToRunMap(run);
-  }
-  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;
-  }
-  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()
+  },
+  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
     });
-    run.extra = {
-      ...run.extra,
-      ...extraParams
+    return {
+      newDocument: document,
+      removed
     };
-    await this.onLLMEnd?.(run);
-    await this._endTrace(run);
-    return run;
-  }
-  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()
+  },
+  copy: function(obj, key, document) {
+    const valueToCopy = getValueByPointer(document, this.from);
+    applyOperation(document, {
+      op: "add",
+      path: this.path,
+      value: _deepClone(valueToCopy)
     });
-    run.extra = {
-      ...run.extra,
-      ...extraParams
+    return { newDocument: document };
+  },
+  test: function(obj, key, document) {
+    return {
+      newDocument: document,
+      test: _areEquals(obj[key], this.value)
     };
-    await this.onLLMError?.(run);
-    await this._endTrace(run);
-    return run;
+  },
+  _get: function(obj, key, document) {
+    this.value = obj[key];
+    return { newDocument: document };
   }
-  /**
-  * 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 || []
+};
+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
     };
-    return this._addRunToRunMap(run);
-  }
-  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 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;
-  }
-  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;
-  }
-  /**
-  * 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 || []
+  },
+  remove: function(arr, i, document) {
+    var removedList = arr.splice(i, 1);
+    return {
+      newDocument: document,
+      removed: removedList[0]
     };
-    return this._addRunToRunMap(run);
-  }
-  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;
-  }
-  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;
-  }
-  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);
-  }
-  /**
-  * 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 || []
+  },
+  replace: function(arr, i, document) {
+    var removed = arr[i];
+    arr[i] = this.value;
+    return {
+      newDocument: document,
+      removed
     };
-    return this._addRunToRunMap(run);
+  },
+  move: objOps.move,
+  copy: objOps.copy,
+  test: objOps.test,
+  _get: objOps._get
+};
+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);
+        }
+      }
+      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;
+        }
+      } 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;
+      }
+      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);
+    }
   }
-  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 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");
   }
-  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;
+  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;
   }
-  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;
+  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);
+    }
   }
-  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);
+}
+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);
+    }
+  } catch (e) {
+    if (e instanceof JsonPatchError) return e;
+    else throw e;
   }
-  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
-      }
-    });
-    await this.onLLMNewToken?.(run, token, { chunk: fields?.chunk });
-    return run;
+}
+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;
+    }
+    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;
+    }
+    return true;
   }
-};
+  return a !== a && b !== b;
+}
 export {
-  BaseTracer,
-  base_exports,
-  isBaseTracer
+  _areEquals,
+  applyOperation,
+  applyPatch,
+  applyReducer,
+  core_exports,
+  getValueByPointer,
+  validate,
+  validator
 };
 //# sourceMappingURL=index.es115.js.map