@xpert-ai/chatkit-types 0.0.3 → 0.0.4

package/dist/index.js

@@ -1,3 +1,798 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var _a;
+var __defProp2 = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp2(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var decamelize = function(str, sep) {
+  if (typeof str !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  sep = typeof sep === "undefined" ? "_" : sep;
+  return str.replace(/([a-z\d])([A-Z])/g, "$1" + sep + "$2").replace(/([A-Z]+)([A-Z][a-z\d]+)/g, "$1" + sep + "$2").toLowerCase();
+};
+const snakeCase = /* @__PURE__ */ getDefaultExportFromCjs(decamelize);
+var camelcase = { exports: {} };
+const UPPERCASE = /[\p{Lu}]/u;
+const LOWERCASE = /[\p{Ll}]/u;
+const LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/gu;
+const IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u;
+const SEPARATORS = /[_.\- ]+/;
+const LEADING_SEPARATORS = new RegExp("^" + SEPARATORS.source);
+const SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, "gu");
+const NUMBERS_AND_IDENTIFIER = new RegExp("\\d+" + IDENTIFIER.source, "gu");
+const preserveCamelCase = (string, toLowerCase, toUpperCase) => {
+  let isLastCharLower = false;
+  let isLastCharUpper = false;
+  let isLastLastCharUpper = false;
+  for (let i = 0; i < string.length; i++) {
+    const character = string[i];
+    if (isLastCharLower && UPPERCASE.test(character)) {
+      string = string.slice(0, i) + "-" + string.slice(i);
+      isLastCharLower = false;
+      isLastLastCharUpper = isLastCharUpper;
+      isLastCharUpper = true;
+      i++;
+    } else if (isLastCharUpper && isLastLastCharUpper && LOWERCASE.test(character)) {
+      string = string.slice(0, i - 1) + "-" + string.slice(i - 1);
+      isLastLastCharUpper = isLastCharUpper;
+      isLastCharUpper = false;
+      isLastCharLower = true;
+    } else {
+      isLastCharLower = toLowerCase(character) === character && toUpperCase(character) !== character;
+      isLastLastCharUpper = isLastCharUpper;
+      isLastCharUpper = toUpperCase(character) === character && toLowerCase(character) !== character;
+    }
+  }
+  return string;
+};
+const preserveConsecutiveUppercase = (input, toLowerCase) => {
+  LEADING_CAPITAL.lastIndex = 0;
+  return input.replace(LEADING_CAPITAL, (m1) => toLowerCase(m1));
+};
+const postProcess = (input, toUpperCase) => {
+  SEPARATORS_AND_IDENTIFIER.lastIndex = 0;
+  NUMBERS_AND_IDENTIFIER.lastIndex = 0;
+  return input.replace(SEPARATORS_AND_IDENTIFIER, (_, identifier) => toUpperCase(identifier)).replace(NUMBERS_AND_IDENTIFIER, (m) => toUpperCase(m));
+};
+const camelCase = (input, options) => {
+  if (!(typeof input === "string" || Array.isArray(input))) {
+    throw new TypeError("Expected the input to be `string | string[]`");
+  }
+  options = {
+    pascalCase: false,
+    preserveConsecutiveUppercase: false,
+    ...options
+  };
+  if (Array.isArray(input)) {
+    input = input.map((x) => x.trim()).filter((x) => x.length).join("-");
+  } else {
+    input = input.trim();
+  }
+  if (input.length === 0) {
+    return "";
+  }
+  const toLowerCase = options.locale === false ? (string) => string.toLowerCase() : (string) => string.toLocaleLowerCase(options.locale);
+  const toUpperCase = options.locale === false ? (string) => string.toUpperCase() : (string) => string.toLocaleUpperCase(options.locale);
+  if (input.length === 1) {
+    return options.pascalCase ? toUpperCase(input) : toLowerCase(input);
+  }
+  const hasUpperCase = input !== toLowerCase(input);
+  if (hasUpperCase) {
+    input = preserveCamelCase(input, toLowerCase, toUpperCase);
+  }
+  input = input.replace(LEADING_SEPARATORS, "");
+  if (options.preserveConsecutiveUppercase) {
+    input = preserveConsecutiveUppercase(input, toLowerCase);
+  } else {
+    input = toLowerCase(input);
+  }
+  if (options.pascalCase) {
+    input = toUpperCase(input.charAt(0)) + input.slice(1);
+  }
+  return postProcess(input, toUpperCase);
+};
+camelcase.exports = camelCase;
+camelcase.exports.default = camelCase;
+function keyToJson(key, map) {
+  return (map == null ? void 0 : map[key]) || snakeCase(key);
+}
+function mapKeys(fields, mapper, map) {
+  const mapped = {};
+  for (const key in fields) if (Object.hasOwn(fields, key)) mapped[mapper(key, map)] = fields[key];
+  return mapped;
+}
+var serializable_exports = {};
+__export(serializable_exports, {
+  Serializable: () => Serializable,
+  get_lc_unique_name: () => get_lc_unique_name
+});
+function shallowCopy(obj) {
+  return Array.isArray(obj) ? [...obj] : { ...obj };
+}
+function replaceSecrets(root, secretsMap) {
+  const result = shallowCopy(root);
+  for (const [path, secretId] of Object.entries(secretsMap)) {
+    const [last, ...partsReverse] = path.split(".").reverse();
+    let current = result;
+    for (const part of partsReverse.reverse()) {
+      if (current[part] === void 0) break;
+      current[part] = shallowCopy(current[part]);
+      current = current[part];
+    }
+    if (current[last] !== void 0) current[last] = {
+      lc: 1,
+      type: "secret",
+      id: [secretId]
+    };
+  }
+  return result;
+}
+function get_lc_unique_name(serializableClass) {
+  const parentClass = Object.getPrototypeOf(serializableClass);
+  const lcNameIsSubclassed = typeof serializableClass.lc_name === "function" && (typeof parentClass.lc_name !== "function" || serializableClass.lc_name() !== parentClass.lc_name());
+  if (lcNameIsSubclassed) return serializableClass.lc_name();
+  else return serializableClass.name;
+}
+var Serializable = class Serializable2 {
+  constructor(kwargs, ..._args) {
+    __publicField(this, "lc_serializable", false);
+    __publicField(this, "lc_kwargs");
+    if (this.lc_serializable_keys !== void 0) this.lc_kwargs = Object.fromEntries(Object.entries(kwargs || {}).filter(([key]) => {
+      var _a2;
+      return (_a2 = this.lc_serializable_keys) == null ? void 0 : _a2.includes(key);
+    }));
+    else this.lc_kwargs = kwargs ?? {};
+  }
+  /**
+  * The name of the serializable. Override to provide an alias or
+  * to preserve the serialized module name in minified environments.
+  *
+  * Implemented as a static method to support loading logic.
+  */
+  static lc_name() {
+    return this.name;
+  }
+  /**
+  * The final serialized identifier for the module.
+  */
+  get lc_id() {
+    return [...this.lc_namespace, get_lc_unique_name(this.constructor)];
+  }
+  /**
+  * A map of secrets, which will be omitted from serialization.
+  * Keys are paths to the secret in constructor args, e.g. "foo.bar.baz".
+  * Values are the secret ids, which will be used when deserializing.
+  */
+  get lc_secrets() {
+    return void 0;
+  }
+  /**
+  * A map of additional attributes to merge with constructor args.
+  * Keys are the attribute names, e.g. "foo".
+  * Values are the attribute values, which will be serialized.
+  * These attributes need to be accepted by the constructor as arguments.
+  */
+  get lc_attributes() {
+    return void 0;
+  }
+  /**
+  * A map of aliases for constructor args.
+  * Keys are the attribute names, e.g. "foo".
+  * Values are the alias that will replace the key in serialization.
+  * This is used to eg. make argument names match Python.
+  */
+  get lc_aliases() {
+    return void 0;
+  }
+  /**
+  * A manual list of keys that should be serialized.
+  * If not overridden, all fields passed into the constructor will be serialized.
+  */
+  get lc_serializable_keys() {
+    return void 0;
+  }
+  toJSON() {
+    if (!this.lc_serializable) return this.toJSONNotImplemented();
+    if (this.lc_kwargs instanceof Serializable2 || typeof this.lc_kwargs !== "object" || Array.isArray(this.lc_kwargs)) return this.toJSONNotImplemented();
+    const aliases = {};
+    const secrets = {};
+    const kwargs = Object.keys(this.lc_kwargs).reduce((acc, key) => {
+      acc[key] = key in this ? this[key] : this.lc_kwargs[key];
+      return acc;
+    }, {});
+    for (let current = Object.getPrototypeOf(this); current; current = Object.getPrototypeOf(current)) {
+      Object.assign(aliases, Reflect.get(current, "lc_aliases", this));
+      Object.assign(secrets, Reflect.get(current, "lc_secrets", this));
+      Object.assign(kwargs, Reflect.get(current, "lc_attributes", this));
+    }
+    Object.keys(secrets).forEach((keyPath) => {
+      let read = this;
+      let write = kwargs;
+      const [last, ...partsReverse] = keyPath.split(".").reverse();
+      for (const key of partsReverse.reverse()) {
+        if (!(key in read) || read[key] === void 0) return;
+        if (!(key in write) || write[key] === void 0) {
+          if (typeof read[key] === "object" && read[key] != null) write[key] = {};
+          else if (Array.isArray(read[key])) write[key] = [];
+        }
+        read = read[key];
+        write = write[key];
+      }
+      if (last in read && read[last] !== void 0) write[last] = write[last] || read[last];
+    });
+    return {
+      lc: 1,
+      type: "constructor",
+      id: this.lc_id,
+      kwargs: mapKeys(Object.keys(secrets).length ? replaceSecrets(kwargs, secrets) : kwargs, keyToJson, aliases)
+    };
+  }
+  toJSONNotImplemented() {
+    return {
+      lc: 1,
+      type: "not_implemented",
+      id: this.lc_id
+    };
+  }
+};
+function isDataContentBlock(content_block) {
+  return typeof content_block === "object" && content_block !== null && "type" in content_block && typeof content_block.type === "string" && "source_type" in content_block && (content_block.source_type === "url" || content_block.source_type === "base64" || content_block.source_type === "text" || content_block.source_type === "id");
+}
+function isURLContentBlock(content_block) {
+  return isDataContentBlock(content_block) && content_block.source_type === "url" && "url" in content_block && typeof content_block.url === "string";
+}
+function isBase64ContentBlock(content_block) {
+  return isDataContentBlock(content_block) && content_block.source_type === "base64" && "data" in content_block && typeof content_block.data === "string";
+}
+function isIDContentBlock(content_block) {
+  return isDataContentBlock(content_block) && content_block.source_type === "id" && "id" in content_block && typeof content_block.id === "string";
+}
+function parseBase64DataUrl({ dataUrl: data_url, asTypedArray = false }) {
+  const formatMatch = data_url.match(/^data:(\w+\/\w+);base64,([A-Za-z0-9+/]+=*)$/);
+  let mime_type;
+  if (formatMatch) {
+    mime_type = formatMatch[1].toLowerCase();
+    const data = asTypedArray ? Uint8Array.from(atob(formatMatch[2]), (c) => c.charCodeAt(0)) : formatMatch[2];
+    return {
+      mime_type,
+      data
+    };
+  }
+  return void 0;
+}
+function _isContentBlock(block, type) {
+  return _isObject(block) && block.type === type;
+}
+function _isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function _isString(value) {
+  return typeof value === "string";
+}
+function convertToV1FromAnthropicContentBlock(block) {
+  if (_isContentBlock(block, "document") && _isObject(block.source) && "type" in block.source) {
+    if (block.source.type === "base64" && _isString(block.source.media_type) && _isString(block.source.data)) return {
+      type: "file",
+      mimeType: block.source.media_type,
+      data: block.source.data
+    };
+    else if (block.source.type === "url" && _isString(block.source.url)) return {
+      type: "file",
+      url: block.source.url
+    };
+    else if (block.source.type === "file" && _isString(block.source.file_id)) return {
+      type: "file",
+      fileId: block.source.file_id
+    };
+    else if (block.source.type === "text" && _isString(block.source.data)) return {
+      type: "file",
+      mimeType: String(block.source.media_type ?? "text/plain"),
+      data: block.source.data
+    };
+  } else if (_isContentBlock(block, "image") && _isObject(block.source) && "type" in block.source) {
+    if (block.source.type === "base64" && _isString(block.source.media_type) && _isString(block.source.data)) return {
+      type: "image",
+      mimeType: block.source.media_type,
+      data: block.source.data
+    };
+    else if (block.source.type === "url" && _isString(block.source.url)) return {
+      type: "image",
+      url: block.source.url
+    };
+    else if (block.source.type === "file" && _isString(block.source.file_id)) return {
+      type: "image",
+      fileId: block.source.file_id
+    };
+  }
+  return void 0;
+}
+function convertToV1FromAnthropicInput(content) {
+  function* iterateContent() {
+    for (const block of content) {
+      const stdBlock = convertToV1FromAnthropicContentBlock(block);
+      if (stdBlock) yield stdBlock;
+      else yield block;
+    }
+  }
+  return Array.from(iterateContent());
+}
+function convertToV1FromDataContentBlock(block) {
+  if (isURLContentBlock(block)) return {
+    type: block.type,
+    mimeType: block.mime_type,
+    url: block.url,
+    metadata: block.metadata
+  };
+  if (isBase64ContentBlock(block)) return {
+    type: block.type,
+    mimeType: block.mime_type ?? "application/octet-stream",
+    data: block.data,
+    metadata: block.metadata
+  };
+  if (isIDContentBlock(block)) return {
+    type: block.type,
+    mimeType: block.mime_type,
+    fileId: block.id,
+    metadata: block.metadata
+  };
+  return block;
+}
+function convertToV1FromDataContent(content) {
+  return content.map(convertToV1FromDataContentBlock);
+}
+function isOpenAIDataBlock(block) {
+  if (_isContentBlock(block, "image_url") && _isObject(block.image_url)) return true;
+  if (_isContentBlock(block, "input_audio") && _isObject(block.input_audio)) return true;
+  if (_isContentBlock(block, "file") && _isObject(block.file)) return true;
+  return false;
+}
+function convertToV1FromOpenAIDataBlock(block) {
+  if (_isContentBlock(block, "image_url") && _isObject(block.image_url) && _isString(block.image_url.url)) {
+    const parsed = parseBase64DataUrl({ dataUrl: block.image_url.url });
+    if (parsed) return {
+      type: "image",
+      mimeType: parsed.mime_type,
+      data: parsed.data
+    };
+    else return {
+      type: "image",
+      url: block.image_url.url
+    };
+  } else if (_isContentBlock(block, "input_audio") && _isObject(block.input_audio) && _isString(block.input_audio.data) && _isString(block.input_audio.format)) return {
+    type: "audio",
+    data: block.input_audio.data,
+    mimeType: `audio/${block.input_audio.format}`
+  };
+  else if (_isContentBlock(block, "file") && _isObject(block.file) && _isString(block.file.data)) {
+    const parsed = parseBase64DataUrl({ dataUrl: block.file.data });
+    if (parsed) return {
+      type: "file",
+      data: parsed.data,
+      mimeType: parsed.mime_type
+    };
+    else if (_isString(block.file.file_id)) return {
+      type: "file",
+      fileId: block.file.file_id
+    };
+  }
+  return block;
+}
+function convertToV1FromChatCompletionsInput(blocks) {
+  const convertedBlocks = [];
+  for (const block of blocks) if (isOpenAIDataBlock(block)) convertedBlocks.push(convertToV1FromOpenAIDataBlock(block));
+  else convertedBlocks.push(block);
+  return convertedBlocks;
+}
+function isMessage(message) {
+  return typeof message === "object" && message !== null && "type" in message && "content" in message && (typeof message.content === "string" || Array.isArray(message.content));
+}
+function convertToFormattedString(message, format = "pretty") {
+  if (format === "pretty") return convertToPrettyString(message);
+  return JSON.stringify(message);
+}
+function convertToPrettyString(message) {
+  const lines = [];
+  const title = ` ${message.type.charAt(0).toUpperCase() + message.type.slice(1)} Message `;
+  const sepLen = Math.floor((80 - title.length) / 2);
+  const sep = "=".repeat(sepLen);
+  const secondSep = title.length % 2 === 0 ? sep : `${sep}=`;
+  lines.push(`${sep}${title}${secondSep}`);
+  if (message.type === "ai") {
+    const aiMessage = message;
+    if (aiMessage.tool_calls && aiMessage.tool_calls.length > 0) {
+      lines.push("Tool Calls:");
+      for (const tc of aiMessage.tool_calls) {
+        lines.push(`  ${tc.name} (${tc.id})`);
+        lines.push(` Call ID: ${tc.id}`);
+        lines.push("  Args:");
+        for (const [key, value] of Object.entries(tc.args)) lines.push(`    ${key}: ${typeof value === "object" ? JSON.stringify(value) : value}`);
+      }
+    }
+  }
+  if (message.type === "tool") {
+    const toolMessage = message;
+    if (toolMessage.name) lines.push(`Name: ${toolMessage.name}`);
+  }
+  if (typeof message.content === "string" && message.content.trim()) {
+    if (lines.length > 1) lines.push("");
+    lines.push(message.content);
+  }
+  return lines.join("\n");
+}
+const MESSAGE_SYMBOL = Symbol.for("langchain.message");
+function mergeContent(firstContent, secondContent) {
+  if (typeof firstContent === "string") {
+    if (firstContent === "") return secondContent;
+    if (typeof secondContent === "string") return firstContent + secondContent;
+    else if (Array.isArray(secondContent) && secondContent.length === 0) return firstContent;
+    else if (Array.isArray(secondContent) && secondContent.some((c) => isDataContentBlock(c))) return [{
+      type: "text",
+      source_type: "text",
+      text: firstContent
+    }, ...secondContent];
+    else return [{
+      type: "text",
+      text: firstContent
+    }, ...secondContent];
+  } else if (Array.isArray(secondContent)) return _mergeLists(firstContent, secondContent) ?? [...firstContent, ...secondContent];
+  else if (secondContent === "") return firstContent;
+  else if (Array.isArray(firstContent) && firstContent.some((c) => isDataContentBlock(c))) return [...firstContent, {
+    type: "file",
+    source_type: "text",
+    text: secondContent
+  }];
+  else return [...firstContent, {
+    type: "text",
+    text: secondContent
+  }];
+}
+function _mergeStatus(left, right) {
+  if (left === "error" || right === "error") return "error";
+  return "success";
+}
+function stringifyWithDepthLimit(obj, depthLimit) {
+  function helper(obj$1, currentDepth) {
+    if (typeof obj$1 !== "object" || obj$1 === null || obj$1 === void 0) return obj$1;
+    if (currentDepth >= depthLimit) {
+      if (Array.isArray(obj$1)) return "[Array]";
+      return "[Object]";
+    }
+    if (Array.isArray(obj$1)) return obj$1.map((item) => helper(item, currentDepth + 1));
+    const result = {};
+    for (const key of Object.keys(obj$1)) result[key] = helper(obj$1[key], currentDepth + 1);
+    return result;
+  }
+  return JSON.stringify(helper(obj, 0), null, 2);
+}
+var BaseMessage = class extends Serializable {
+  constructor(arg) {
+    const fields = typeof arg === "string" || Array.isArray(arg) ? { content: arg } : arg;
+    if (!fields.additional_kwargs) fields.additional_kwargs = {};
+    if (!fields.response_metadata) fields.response_metadata = {};
+    super(fields);
+    __publicField(this, "lc_namespace", ["langchain_core", "messages"]);
+    __publicField(this, "lc_serializable", true);
+    __publicField(this, _a, true);
+    __publicField(this, "id");
+    __publicField(this, "name");
+    __publicField(this, "content");
+    __publicField(this, "additional_kwargs");
+    __publicField(this, "response_metadata");
+    this.name = fields.name;
+    if (fields.content === void 0 && fields.contentBlocks !== void 0) {
+      this.content = fields.contentBlocks;
+      this.response_metadata = {
+        output_version: "v1",
+        ...fields.response_metadata
+      };
+    } else if (fields.content !== void 0) {
+      this.content = fields.content ?? [];
+      this.response_metadata = fields.response_metadata;
+    } else {
+      this.content = [];
+      this.response_metadata = fields.response_metadata;
+    }
+    this.additional_kwargs = fields.additional_kwargs;
+    this.id = fields.id;
+  }
+  get lc_aliases() {
+    return {
+      additional_kwargs: "additional_kwargs",
+      response_metadata: "response_metadata"
+    };
+  }
+  /**
+  * @deprecated Use .getType() instead or import the proper typeguard.
+  * For example:
+  *
+  * ```ts
+  * import { isAIMessage } from "@langchain/core/messages";
+  *
+  * const message = new AIMessage("Hello!");
+  * isAIMessage(message); // true
+  * ```
+  */
+  _getType() {
+    return this.type;
+  }
+  /**
+  * @deprecated Use .type instead
+  * The type of the message.
+  */
+  getType() {
+    return this._getType();
+  }
+  /** Get text content of the message. */
+  get text() {
+    if (typeof this.content === "string") return this.content;
+    if (!Array.isArray(this.content)) return "";
+    return this.content.map((c) => {
+      if (typeof c === "string") return c;
+      if (c.type === "text") return c.text;
+      return "";
+    }).join("");
+  }
+  get contentBlocks() {
+    const blocks = typeof this.content === "string" ? [{
+      type: "text",
+      text: this.content
+    }] : this.content;
+    const parsingSteps = [
+      convertToV1FromDataContent,
+      convertToV1FromChatCompletionsInput,
+      convertToV1FromAnthropicInput
+    ];
+    const parsedBlocks = parsingSteps.reduce((blocks$1, step) => step(blocks$1), blocks);
+    return parsedBlocks;
+  }
+  toDict() {
+    return {
+      type: this.getType(),
+      data: this.toJSON().kwargs
+    };
+  }
+  static lc_name() {
+    return "BaseMessage";
+  }
+  get _printableFields() {
+    return {
+      id: this.id,
+      content: this.content,
+      name: this.name,
+      additional_kwargs: this.additional_kwargs,
+      response_metadata: this.response_metadata
+    };
+  }
+  static isInstance(obj) {
+    return typeof obj === "object" && obj !== null && MESSAGE_SYMBOL in obj && obj[MESSAGE_SYMBOL] === true && isMessage(obj);
+  }
+  _updateId(value) {
+    this.id = value;
+    this.lc_kwargs.id = value;
+  }
+  get [(_a = MESSAGE_SYMBOL, Symbol.toStringTag)]() {
+    return this.constructor.lc_name();
+  }
+  [Symbol.for("nodejs.util.inspect.custom")](depth) {
+    if (depth === null) return this;
+    const printable = stringifyWithDepthLimit(this._printableFields, Math.max(4, depth));
+    return `${this.constructor.lc_name()} ${printable}`;
+  }
+  toFormattedString(format = "pretty") {
+    return convertToFormattedString(this, format);
+  }
+};
+function _mergeDicts(left = {}, right = {}) {
+  const merged = { ...left };
+  for (const [key, value] of Object.entries(right)) if (merged[key] == null) merged[key] = value;
+  else if (value == null) continue;
+  else if (typeof merged[key] !== typeof value || Array.isArray(merged[key]) !== Array.isArray(value)) throw new Error(`field[${key}] already exists in the message chunk, but with a different type.`);
+  else if (typeof merged[key] === "string") if (key === "type") continue;
+  else if ([
+    "id",
+    "name",
+    "output_version",
+    "model_provider"
+  ].includes(key)) {
+    if (value) merged[key] = value;
+  } else merged[key] += value;
+  else if (typeof merged[key] === "object" && !Array.isArray(merged[key])) merged[key] = _mergeDicts(merged[key], value);
+  else if (Array.isArray(merged[key])) merged[key] = _mergeLists(merged[key], value);
+  else if (merged[key] === value) continue;
+  else console.warn(`field[${key}] already exists in this message chunk and value has unsupported type.`);
+  return merged;
+}
+function _mergeLists(left, right) {
+  if (left === void 0 && right === void 0) return void 0;
+  else if (left === void 0 || right === void 0) return left || right;
+  else {
+    const merged = [...left];
+    for (const item of right) if (typeof item === "object" && item !== null && "index" in item && typeof item.index === "number") {
+      const toMerge = merged.findIndex((leftItem) => {
+        const isObject = typeof leftItem === "object";
+        const indiciesMatch = "index" in leftItem && leftItem.index === item.index;
+        const idsMatch = "id" in leftItem && "id" in item && (leftItem == null ? void 0 : leftItem.id) === (item == null ? void 0 : item.id);
+        const eitherItemMissingID = !("id" in leftItem) || !(leftItem == null ? void 0 : leftItem.id) || !("id" in item) || !(item == null ? void 0 : item.id);
+        return isObject && indiciesMatch && (idsMatch || eitherItemMissingID);
+      });
+      if (toMerge !== -1 && typeof merged[toMerge] === "object" && merged[toMerge] !== null) merged[toMerge] = _mergeDicts(merged[toMerge], item);
+      else merged.push(item);
+    } else if (typeof item === "object" && item !== null && "text" in item && item.text === "") continue;
+    else merged.push(item);
+    return merged;
+  }
+}
+function _mergeObj(left, right) {
+  if (left === void 0 && right === void 0) return void 0;
+  if (left === void 0 || right === void 0) return left ?? right;
+  else if (typeof left !== typeof right) throw new Error(`Cannot merge objects of different types.
+Left ${typeof left}
+Right ${typeof right}`);
+  else if (typeof left === "string" && typeof right === "string") return left + right;
+  else if (Array.isArray(left) && Array.isArray(right)) return _mergeLists(left, right);
+  else if (typeof left === "object" && typeof right === "object") return _mergeDicts(left, right);
+  else if (left === right) return left;
+  else throw new Error(`Can not merge objects of different types.
+Left ${left}
+Right ${right}`);
+}
+var BaseMessageChunk = class BaseMessageChunk2 extends BaseMessage {
+  static isInstance(obj) {
+    if (!super.isInstance(obj)) return false;
+    let proto = Object.getPrototypeOf(obj);
+    while (proto !== null) {
+      if (proto === BaseMessageChunk2.prototype) return true;
+      proto = Object.getPrototypeOf(proto);
+    }
+    return false;
+  }
+};
+var tool_exports = {};
+__export(tool_exports, {
+  ToolMessage: () => ToolMessage,
+  ToolMessageChunk: () => ToolMessageChunk,
+  defaultToolCallParser: () => defaultToolCallParser,
+  isDirectToolOutput: () => isDirectToolOutput,
+  isToolMessage: () => isToolMessage,
+  isToolMessageChunk: () => isToolMessageChunk
+});
+function isDirectToolOutput(x) {
+  return x != null && typeof x === "object" && "lc_direct_tool_output" in x && x.lc_direct_tool_output === true;
+}
+var ToolMessage = class extends BaseMessage {
+  constructor(fields, tool_call_id, name) {
+    const toolMessageFields = typeof fields === "string" || Array.isArray(fields) ? {
+      content: fields,
+      name,
+      tool_call_id
+    } : fields;
+    super(toolMessageFields);
+    __publicField(this, "lc_direct_tool_output", true);
+    __publicField(this, "type", "tool");
+    /**
+    * Status of the tool invocation.
+    * @version 0.2.19
+    */
+    __publicField(this, "status");
+    __publicField(this, "tool_call_id");
+    __publicField(this, "metadata");
+    /**
+    * Artifact of the Tool execution which is not meant to be sent to the model.
+    *
+    * Should only be specified if it is different from the message content, e.g. if only
+    * a subset of the full tool output is being passed as message content but the full
+    * output is needed in other parts of the code.
+    */
+    __publicField(this, "artifact");
+    this.tool_call_id = toolMessageFields.tool_call_id;
+    this.artifact = toolMessageFields.artifact;
+    this.status = toolMessageFields.status;
+    this.metadata = toolMessageFields.metadata;
+  }
+  static lc_name() {
+    return "ToolMessage";
+  }
+  get lc_aliases() {
+    return { tool_call_id: "tool_call_id" };
+  }
+  static isInstance(message) {
+    return super.isInstance(message) && message.type === "tool";
+  }
+  get _printableFields() {
+    return {
+      ...super._printableFields,
+      tool_call_id: this.tool_call_id,
+      artifact: this.artifact
+    };
+  }
+};
+var ToolMessageChunk = class extends BaseMessageChunk {
+  constructor(fields) {
+    super(fields);
+    __publicField(this, "type", "tool");
+    __publicField(this, "tool_call_id");
+    /**
+    * Status of the tool invocation.
+    * @version 0.2.19
+    */
+    __publicField(this, "status");
+    /**
+    * Artifact of the Tool execution which is not meant to be sent to the model.
+    *
+    * Should only be specified if it is different from the message content, e.g. if only
+    * a subset of the full tool output is being passed as message content but the full
+    * output is needed in other parts of the code.
+    */
+    __publicField(this, "artifact");
+    this.tool_call_id = fields.tool_call_id;
+    this.artifact = fields.artifact;
+    this.status = fields.status;
+  }
+  static lc_name() {
+    return "ToolMessageChunk";
+  }
+  concat(chunk) {
+    const Cls = this.constructor;
+    return new Cls({
+      content: mergeContent(this.content, chunk.content),
+      additional_kwargs: _mergeDicts(this.additional_kwargs, chunk.additional_kwargs),
+      response_metadata: _mergeDicts(this.response_metadata, chunk.response_metadata),
+      artifact: _mergeObj(this.artifact, chunk.artifact),
+      tool_call_id: this.tool_call_id,
+      id: this.id ?? chunk.id,
+      status: _mergeStatus(this.status, chunk.status)
+    });
+  }
+  get _printableFields() {
+    return {
+      ...super._printableFields,
+      tool_call_id: this.tool_call_id,
+      artifact: this.artifact
+    };
+  }
+};
+function defaultToolCallParser(rawToolCalls) {
+  const toolCalls = [];
+  const invalidToolCalls = [];
+  for (const toolCall of rawToolCalls) if (!toolCall.function) continue;
+  else {
+    const functionName = toolCall.function.name;
+    try {
+      const functionArgs = JSON.parse(toolCall.function.arguments);
+      toolCalls.push({
+        name: functionName || "",
+        args: functionArgs || {},
+        id: toolCall.id
+      });
+    } catch {
+      invalidToolCalls.push({
+        name: functionName,
+        args: toolCall.function.arguments,
+        id: toolCall.id,
+        error: "Malformed args."
+      });
+    }
+  }
+  return [toolCalls, invalidToolCalls];
+}
+function isToolMessage(x) {
+  return typeof x === "object" && x !== null && "getType" in x && typeof x.getType === "function" && x.getType() === "tool";
+}
+function isToolMessageChunk(x) {
+  return x._getType() === "tool";
+}
+function isClientToolRequest(value) {
+  return value && Array.isArray(value.clientToolCalls);
+}
 var ChatMessageTypeEnum = /* @__PURE__ */ ((ChatMessageTypeEnum2) => {
   ChatMessageTypeEnum2["MESSAGE"] = "message";
   ChatMessageTypeEnum2["EVENT"] = "event";
@@ -37,6 +832,7 @@ var ChatMessageStepCategory = /* @__PURE__ */ ((ChatMessageStepCategory2) => {
 export {
   ChatMessageEventTypeEnum,
   ChatMessageStepCategory,
-  ChatMessageTypeEnum
+  ChatMessageTypeEnum,
+  isClientToolRequest
 };
 //# sourceMappingURL=index.js.map