@langchain/core 0.3.72 → 1.0.0-alpha.2

package/dist/utils/fast-json-patch/src/helpers.js

@@ -1,181 +1,114 @@
-// @ts-nocheck
-// Inlined because of ESM import issues
+//#region src/utils/fast-json-patch/src/helpers.ts
 /*!
- * https://github.com/Starcounter-Jack/JSON-Patch
- * (c) 2017-2022 Joachim Wester
- * MIT licensed
- */
+* https://github.com/Starcounter-Jack/JSON-Patch
+* (c) 2017-2022 Joachim Wester
+* MIT licensed
+*/
 const _hasOwnProperty = Object.prototype.hasOwnProperty;
-export function hasOwnProperty(obj, key) {
-    return _hasOwnProperty.call(obj, key);
+function hasOwnProperty(obj, key) {
+	return _hasOwnProperty.call(obj, key);
 }
-export function _objectKeys(obj) {
-    if (Array.isArray(obj)) {
-        const keys = new Array(obj.length);
-        for (let k = 0; k < keys.length; k++) {
-            keys[k] = "" + k;
-        }
-        return keys;
-    }
-    if (Object.keys) {
-        return Object.keys(obj);
-    }
-    let keys = [];
-    for (let i in obj) {
-        if (hasOwnProperty(obj, i)) {
-            keys.push(i);
-        }
-    }
-    return keys;
+function _objectKeys(obj) {
+	if (Array.isArray(obj)) {
+		const keys$1 = new Array(obj.length);
+		for (let k = 0; k < keys$1.length; k++) keys$1[k] = "" + k;
+		return keys$1;
+	}
+	if (Object.keys) return Object.keys(obj);
+	let keys = [];
+	for (let i in obj) if (hasOwnProperty(obj, i)) keys.push(i);
+	return keys;
 }
 /**
- * Deeply clone the object.
- * https://jsperf.com/deep-copy-vs-json-stringify-json-parse/25 (recursiveDeepCopy)
- * @param  {any} obj value to clone
- * @return {any} cloned obj
- */
-export function _deepClone(obj) {
-    switch (typeof obj) {
-        case "object":
-            return JSON.parse(JSON.stringify(obj)); //Faster than ES5 clone - http://jsperf.com/deep-cloning-of-objects/5
-        case "undefined":
-            return null; //this is how JSON.stringify behaves for array items
-        default:
-            return obj; //no need to clone primitives
-    }
+* Deeply clone the object.
+* https://jsperf.com/deep-copy-vs-json-stringify-json-parse/25 (recursiveDeepCopy)
+* @param  {any} obj value to clone
+* @return {any} cloned obj
+*/
+function _deepClone(obj) {
+	switch (typeof obj) {
+		case "object": return JSON.parse(JSON.stringify(obj));
+		case "undefined": return null;
+		default: return obj;
+	}
 }
-//3x faster than cached /^\d+$/.test(str)
-export function isInteger(str) {
-    let i = 0;
-    const len = str.length;
-    let charCode;
-    while (i < len) {
-        charCode = str.charCodeAt(i);
-        if (charCode >= 48 && charCode <= 57) {
-            i++;
-            continue;
-        }
-        return false;
-    }
-    return true;
+function isInteger(str) {
+	let i = 0;
+	const len = str.length;
+	let charCode;
+	while (i < len) {
+		charCode = str.charCodeAt(i);
+		if (charCode >= 48 && charCode <= 57) {
+			i++;
+			continue;
+		}
+		return false;
+	}
+	return true;
 }
 /**
- * Escapes a json pointer path
- * @param path The raw pointer
- * @return the Escaped path
- */
-export function escapePathComponent(path) {
-    if (path.indexOf("/") === -1 && path.indexOf("~") === -1)
-        return path;
-    return path.replace(/~/g, "~0").replace(/\//g, "~1");
+* Escapes a json pointer path
+* @param path The raw pointer
+* @return the Escaped path
+*/
+function escapePathComponent(path) {
+	if (path.indexOf("/") === -1 && path.indexOf("~") === -1) return path;
+	return path.replace(/~/g, "~0").replace(/\//g, "~1");
 }
 /**
- * Unescapes a json pointer path
- * @param path The escaped pointer
- * @return The unescaped path
- */
-export function unescapePathComponent(path) {
-    return path.replace(/~1/g, "/").replace(/~0/g, "~");
-}
-export function _getPathRecursive(root, obj) {
-    let found;
-    for (let key in root) {
-        if (hasOwnProperty(root, key)) {
-            if (root[key] === obj) {
-                return escapePathComponent(key) + "/";
-            }
-            else if (typeof root[key] === "object") {
-                found = _getPathRecursive(root[key], obj);
-                if (found != "") {
-                    return escapePathComponent(key) + "/" + found;
-                }
-            }
-        }
-    }
-    return "";
-}
-export function getPath(root, obj) {
-    if (root === obj) {
-        return "/";
-    }
-    const path = _getPathRecursive(root, obj);
-    if (path === "") {
-        throw new Error("Object not found in root");
-    }
-    return `/${path}`;
+* Unescapes a json pointer path
+* @param path The escaped pointer
+* @return The unescaped path
+*/
+function unescapePathComponent(path) {
+	return path.replace(/~1/g, "/").replace(/~0/g, "~");
 }
 /**
- * Recursively checks whether an object has any undefined values inside.
- */
-export function hasUndefined(obj) {
-    if (obj === undefined) {
-        return true;
-    }
-    if (obj) {
-        if (Array.isArray(obj)) {
-            for (let i = 0, len = obj.length; i < len; i++) {
-                if (hasUndefined(obj[i])) {
-                    return true;
-                }
-            }
-        }
-        else if (typeof obj === "object") {
-            const objKeys = _objectKeys(obj);
-            const objKeysLength = objKeys.length;
-            for (var i = 0; i < objKeysLength; i++) {
-                if (hasUndefined(obj[objKeys[i]])) {
-                    return true;
-                }
-            }
-        }
-    }
-    return false;
+* Recursively checks whether an object has any undefined values inside.
+*/
+function hasUndefined(obj) {
+	if (obj === void 0) return true;
+	if (obj) {
+		if (Array.isArray(obj)) {
+			for (let i$1 = 0, len = obj.length; i$1 < len; i$1++) if (hasUndefined(obj[i$1])) return true;
+		} else if (typeof obj === "object") {
+			const objKeys = _objectKeys(obj);
+			const objKeysLength = objKeys.length;
+			for (var i = 0; i < objKeysLength; i++) if (hasUndefined(obj[objKeys[i]])) return true;
+		}
+	}
+	return false;
 }
 function patchErrorMessageFormatter(message, args) {
-    const messageParts = [message];
-    for (const key in args) {
-        const value = typeof args[key] === "object"
-            ? JSON.stringify(args[key], null, 2)
-            : args[key]; // pretty print
-        if (typeof value !== "undefined") {
-            messageParts.push(`${key}: ${value}`);
-        }
-    }
-    return messageParts.join("\n");
-}
-export class PatchError extends Error {
-    constructor(message, name, index, operation, tree) {
-        super(patchErrorMessageFormatter(message, { name, index, operation, tree }));
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: name
-        });
-        Object.defineProperty(this, "index", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: index
-        });
-        Object.defineProperty(this, "operation", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: operation
-        });
-        Object.defineProperty(this, "tree", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: tree
-        });
-        Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain, see https://stackoverflow.com/a/48342359
-        this.message = patchErrorMessageFormatter(message, {
-            name,
-            index,
-            operation,
-            tree,
-        });
-    }
+	const messageParts = [message];
+	for (const key in args) {
+		const value = typeof args[key] === "object" ? JSON.stringify(args[key], null, 2) : args[key];
+		if (typeof value !== "undefined") messageParts.push(`${key}: ${value}`);
+	}
+	return messageParts.join("\n");
 }
+var PatchError = class extends Error {
+	constructor(message, name, index, operation, tree) {
+		super(patchErrorMessageFormatter(message, {
+			name,
+			index,
+			operation,
+			tree
+		}));
+		this.name = name;
+		this.index = index;
+		this.operation = operation;
+		this.tree = tree;
+		Object.setPrototypeOf(this, new.target.prototype);
+		this.message = patchErrorMessageFormatter(message, {
+			name,
+			index,
+			operation,
+			tree
+		});
+	}
+};
+
+//#endregion
+export { PatchError, _deepClone, _objectKeys, escapePathComponent, hasOwnProperty, hasUndefined, isInteger, unescapePathComponent };
+//# sourceMappingURL=helpers.js.map

package/dist/utils/fast-json-patch/src/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","names":["keys","str: string","path: string","obj: any","i","message: String","args: Object","message: string","name: JsonPatchErrorName","index?: number","operation?: any","tree?: any"],"sources":["../../../../src/utils/fast-json-patch/src/helpers.ts"],"sourcesContent":["// @ts-nocheck\n\n// Inlined because of ESM import issues\n\n/*!\n * https://github.com/Starcounter-Jack/JSON-Patch\n * (c) 2017-2022 Joachim Wester\n * MIT licensed\n */\n\nconst _hasOwnProperty = Object.prototype.hasOwnProperty;\nexport function hasOwnProperty(obj, key) {\n  return _hasOwnProperty.call(obj, key);\n}\nexport function _objectKeys(obj) {\n  if (Array.isArray(obj)) {\n    const keys = new Array(obj.length);\n    for (let k = 0; k < keys.length; k++) {\n      keys[k] = \"\" + k;\n    }\n    return keys;\n  }\n  if (Object.keys) {\n    return Object.keys(obj);\n  }\n  let keys = [];\n  for (let i in obj) {\n    if (hasOwnProperty(obj, i)) {\n      keys.push(i);\n    }\n  }\n  return keys;\n}\n/**\n * Deeply clone the object.\n * https://jsperf.com/deep-copy-vs-json-stringify-json-parse/25 (recursiveDeepCopy)\n * @param  {any} obj value to clone\n * @return {any} cloned obj\n */\nexport function _deepClone(obj) {\n  switch (typeof obj) {\n    case \"object\":\n      return JSON.parse(JSON.stringify(obj)); //Faster than ES5 clone - http://jsperf.com/deep-cloning-of-objects/5\n    case \"undefined\":\n      return null; //this is how JSON.stringify behaves for array items\n    default:\n      return obj; //no need to clone primitives\n  }\n}\n//3x faster than cached /^\\d+$/.test(str)\nexport function isInteger(str: string): boolean {\n  let i = 0;\n  const len = str.length;\n  let charCode;\n  while (i < len) {\n    charCode = str.charCodeAt(i);\n    if (charCode >= 48 && charCode <= 57) {\n      i++;\n      continue;\n    }\n    return false;\n  }\n  return true;\n}\n/**\n * Escapes a json pointer path\n * @param path The raw pointer\n * @return the Escaped path\n */\nexport function escapePathComponent(path: string): string {\n  if (path.indexOf(\"/\") === -1 && path.indexOf(\"~\") === -1) return path;\n  return path.replace(/~/g, \"~0\").replace(/\\//g, \"~1\");\n}\n/**\n * Unescapes a json pointer path\n * @param path The escaped pointer\n * @return The unescaped path\n */\nexport function unescapePathComponent(path: string): string {\n  return path.replace(/~1/g, \"/\").replace(/~0/g, \"~\");\n}\n\nexport function _getPathRecursive(root: Object, obj: Object): string {\n  let found;\n  for (let key in root) {\n    if (hasOwnProperty(root, key)) {\n      if (root[key] === obj) {\n        return escapePathComponent(key) + \"/\";\n      } else if (typeof root[key] === \"object\") {\n        found = _getPathRecursive(root[key], obj);\n        if (found != \"\") {\n          return escapePathComponent(key) + \"/\" + found;\n        }\n      }\n    }\n  }\n  return \"\";\n}\n\nexport function getPath(root: Object, obj: Object): string {\n  if (root === obj) {\n    return \"/\";\n  }\n  const path = _getPathRecursive(root, obj);\n  if (path === \"\") {\n    throw new Error(\"Object not found in root\");\n  }\n  return `/${path}`;\n}\n/**\n * Recursively checks whether an object has any undefined values inside.\n */\nexport function hasUndefined(obj: any): boolean {\n  if (obj === undefined) {\n    return true;\n  }\n  if (obj) {\n    if (Array.isArray(obj)) {\n      for (let i = 0, len = obj.length; i < len; i++) {\n        if (hasUndefined(obj[i])) {\n          return true;\n        }\n      }\n    } else if (typeof obj === \"object\") {\n      const objKeys = _objectKeys(obj);\n      const objKeysLength = objKeys.length;\n      for (var i = 0; i < objKeysLength; i++) {\n        if (hasUndefined(obj[objKeys[i]])) {\n          return true;\n        }\n      }\n    }\n  }\n  return false;\n}\n\nexport type JsonPatchErrorName =\n  | \"SEQUENCE_NOT_AN_ARRAY\"\n  | \"OPERATION_NOT_AN_OBJECT\"\n  | \"OPERATION_OP_INVALID\"\n  | \"OPERATION_PATH_INVALID\"\n  | \"OPERATION_FROM_REQUIRED\"\n  | \"OPERATION_VALUE_REQUIRED\"\n  | \"OPERATION_VALUE_CANNOT_CONTAIN_UNDEFINED\"\n  | \"OPERATION_PATH_CANNOT_ADD\"\n  | \"OPERATION_PATH_UNRESOLVABLE\"\n  | \"OPERATION_FROM_UNRESOLVABLE\"\n  | \"OPERATION_PATH_ILLEGAL_ARRAY_INDEX\"\n  | \"OPERATION_VALUE_OUT_OF_BOUNDS\"\n  | \"TEST_OPERATION_FAILED\";\n\nfunction patchErrorMessageFormatter(message: String, args: Object): string {\n  const messageParts = [message];\n  for (const key in args) {\n    const value =\n      typeof args[key] === \"object\"\n        ? JSON.stringify(args[key], null, 2)\n        : args[key]; // pretty print\n    if (typeof value !== \"undefined\") {\n      messageParts.push(`${key}: ${value}`);\n    }\n  }\n  return messageParts.join(\"\\n\");\n}\nexport class PatchError extends Error {\n  constructor(\n    message: string,\n    public name: JsonPatchErrorName,\n    public index?: number,\n    public operation?: any,\n    public tree?: any\n  ) {\n    super(\n      patchErrorMessageFormatter(message, { name, index, operation, tree })\n    );\n    Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain, see https://stackoverflow.com/a/48342359\n    this.message = patchErrorMessageFormatter(message, {\n      name,\n      index,\n      operation,\n      tree,\n    });\n  }\n}\n"],"mappings":";;;;;;AAUA,MAAM,kBAAkB,OAAO,UAAU;AACzC,SAAgB,eAAe,KAAK,KAAK;AACvC,QAAO,gBAAgB,KAAK,KAAK,IAAI;AACtC;AACD,SAAgB,YAAY,KAAK;AAC/B,KAAI,MAAM,QAAQ,IAAI,EAAE;EACtB,MAAMA,SAAO,IAAI,MAAM,IAAI;AAC3B,OAAK,IAAI,IAAI,GAAG,IAAIA,OAAK,QAAQ,KAC/BA,OAAK,KAAK,KAAK;AAEjB,SAAOA;CACR;AACD,KAAI,OAAO,KACT,QAAO,OAAO,KAAK,IAAI;CAEzB,IAAI,OAAO,CAAE;AACb,MAAK,IAAI,KAAK,IACZ,KAAI,eAAe,KAAK,EAAE,EACxB,KAAK,KAAK,EAAE;AAGhB,QAAO;AACR;;;;;;;AAOD,SAAgB,WAAW,KAAK;AAC9B,SAAQ,OAAO,KAAf;EACE,KAAK,SACH,QAAO,KAAK,MAAM,KAAK,UAAU,IAAI,CAAC;EACxC,KAAK,YACH,QAAO;EACT,QACE,QAAO;CACV;AACF;AAED,SAAgB,UAAUC,KAAsB;CAC9C,IAAI,IAAI;CACR,MAAM,MAAM,IAAI;CAChB,IAAI;AACJ,QAAO,IAAI,KAAK;EACd,WAAW,IAAI,WAAW,EAAE;AAC5B,MAAI,YAAY,MAAM,YAAY,IAAI;GACpC;AACA;EACD;AACD,SAAO;CACR;AACD,QAAO;AACR;;;;;;AAMD,SAAgB,oBAAoBC,MAAsB;AACxD,KAAI,KAAK,QAAQ,IAAI,KAAK,MAAM,KAAK,QAAQ,IAAI,KAAK,GAAI,QAAO;AACjE,QAAO,KAAK,QAAQ,MAAM,KAAK,CAAC,QAAQ,OAAO,KAAK;AACrD;;;;;;AAMD,SAAgB,sBAAsBA,MAAsB;AAC1D,QAAO,KAAK,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,IAAI;AACpD;;;;AAgCD,SAAgB,aAAaC,KAAmB;AAC9C,KAAI,QAAQ,OACV,QAAO;AAET,KAAI,KACF;MAAI,MAAM,QAAQ,IAAI,EACpB;QAAK,IAAIC,MAAI,GAAG,MAAM,IAAI,QAAQA,MAAI,KAAKA,MACzC,KAAI,aAAa,IAAIA,KAAG,CACtB,QAAO;EAEV,WACQ,OAAO,QAAQ,UAAU;GAClC,MAAM,UAAU,YAAY,IAAI;GAChC,MAAM,gBAAgB,QAAQ;AAC9B,QAAK,IAAI,IAAI,GAAG,IAAI,eAAe,IACjC,KAAI,aAAa,IAAI,QAAQ,IAAI,CAC/B,QAAO;EAGZ;;AAEH,QAAO;AACR;AAiBD,SAAS,2BAA2BC,SAAiBC,MAAsB;CACzE,MAAM,eAAe,CAAC,OAAQ;AAC9B,MAAK,MAAM,OAAO,MAAM;EACtB,MAAM,QACJ,OAAO,KAAK,SAAS,WACjB,KAAK,UAAU,KAAK,MAAM,MAAM,EAAE,GAClC,KAAK;AACX,MAAI,OAAO,UAAU,aACnB,aAAa,KAAK,GAAG,IAAI,EAAE,EAAE,OAAO,CAAC;CAExC;AACD,QAAO,aAAa,KAAK,KAAK;AAC/B;AACD,IAAa,aAAb,cAAgC,MAAM;CACpC,YACEC,SACOC,MACAC,OACAC,WACAC,MACP;EACA,MACE,2BAA2B,SAAS;GAAE;GAAM;GAAO;GAAW;EAAM,EAAC,CACtE;EAPM;EACA;EACA;EACA;EAKP,OAAO,eAAe,MAAM,IAAI,OAAO,UAAU;EACjD,KAAK,UAAU,2BAA2B,SAAS;GACjD;GACA;GACA;GACA;EACD,EAAC;CACH;AACF"}

package/dist/utils/function_calling.cjs

@@ -1,64 +1,67 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isLangChainTool = exports.isRunnableToolLike = exports.isStructuredToolParams = exports.isStructuredTool = void 0;
-exports.convertToOpenAIFunction = convertToOpenAIFunction;
-exports.convertToOpenAITool = convertToOpenAITool;
-const types_js_1 = require("../tools/types.cjs");
-const json_schema_js_1 = require("./json_schema.cjs");
-// These utility functions were moved to a more appropriate location,
-// but we still export them here for backwards compatibility.
-var types_js_2 = require("../tools/types.cjs");
-Object.defineProperty(exports, "isStructuredTool", { enumerable: true, get: function () { return types_js_2.isStructuredTool; } });
-Object.defineProperty(exports, "isStructuredToolParams", { enumerable: true, get: function () { return types_js_2.isStructuredToolParams; } });
-Object.defineProperty(exports, "isRunnableToolLike", { enumerable: true, get: function () { return types_js_2.isRunnableToolLike; } });
-Object.defineProperty(exports, "isLangChainTool", { enumerable: true, get: function () { return types_js_2.isLangChainTool; } });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_utils_json_schema = require('./json_schema.cjs');
+const require_types = require('../tools/types.cjs');
+
+//#region src/utils/function_calling.ts
+var function_calling_exports = {};
+require_rolldown_runtime.__export(function_calling_exports, {
+	convertToOpenAIFunction: () => convertToOpenAIFunction,
+	convertToOpenAITool: () => convertToOpenAITool,
+	isLangChainTool: () => require_types.isLangChainTool,
+	isRunnableToolLike: () => require_types.isRunnableToolLike,
+	isStructuredTool: () => require_types.isStructuredTool,
+	isStructuredToolParams: () => require_types.isStructuredToolParams
+});
 /**
- * Formats a `StructuredTool` or `RunnableToolLike` instance into a format
- * that is compatible with OpenAI function calling. If `StructuredTool` or
- * `RunnableToolLike` has a zod schema, the output will be converted into a
- * JSON schema, which is then used as the parameters for the OpenAI tool.
- *
- * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.
- * @returns {FunctionDefinition} The inputted tool in OpenAI function format.
- */
+* Formats a `StructuredTool` or `RunnableToolLike` instance into a format
+* that is compatible with OpenAI function calling. If `StructuredTool` or
+* `RunnableToolLike` has a zod schema, the output will be converted into a
+* JSON schema, which is then used as the parameters for the OpenAI tool.
+*
+* @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.
+* @returns {FunctionDefinition} The inputted tool in OpenAI function format.
+*/
 function convertToOpenAIFunction(tool, fields) {
-    // @TODO 0.3.0 Remove the `number` typing
-    const fieldsCopy = typeof fields === "number" ? undefined : fields;
-    return {
-        name: tool.name,
-        description: tool.description,
-        parameters: (0, json_schema_js_1.toJsonSchema)(tool.schema),
-        // Do not include the `strict` field if it is `undefined`.
-        ...(fieldsCopy?.strict !== undefined ? { strict: fieldsCopy.strict } : {}),
-    };
+	const fieldsCopy = typeof fields === "number" ? void 0 : fields;
+	return {
+		name: tool.name,
+		description: tool.description,
+		parameters: require_utils_json_schema.toJsonSchema(tool.schema),
+		...fieldsCopy?.strict !== void 0 ? { strict: fieldsCopy.strict } : {}
+	};
 }
 /**
- * Formats a `StructuredTool` or `RunnableToolLike` instance into a
- * format that is compatible with OpenAI tool calling. If `StructuredTool` or
- * `RunnableToolLike` has a zod schema, the output will be converted into a
- * JSON schema, which is then used as the parameters for the OpenAI tool.
- *
- * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.
- * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
- */
-function convertToOpenAITool(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-tool, fields) {
-    // @TODO 0.3.0 Remove the `number` typing
-    const fieldsCopy = typeof fields === "number" ? undefined : fields;
-    let toolDef;
-    if ((0, types_js_1.isLangChainTool)(tool)) {
-        toolDef = {
-            type: "function",
-            function: convertToOpenAIFunction(tool),
-        };
-    }
-    else {
-        toolDef = tool;
-    }
-    if (fieldsCopy?.strict !== undefined) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        toolDef.function.strict = fieldsCopy.strict;
-    }
-    return toolDef;
+* Formats a `StructuredTool` or `RunnableToolLike` instance into a
+* format that is compatible with OpenAI tool calling. If `StructuredTool` or
+* `RunnableToolLike` has a zod schema, the output will be converted into a
+* JSON schema, which is then used as the parameters for the OpenAI tool.
+*
+* @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.
+* @returns {ToolDefinition} The inputted tool in OpenAI tool format.
+*/
+function convertToOpenAITool(tool, fields) {
+	const fieldsCopy = typeof fields === "number" ? void 0 : fields;
+	let toolDef;
+	if (require_types.isLangChainTool(tool)) toolDef = {
+		type: "function",
+		function: convertToOpenAIFunction(tool)
+	};
+	else toolDef = tool;
+	if (fieldsCopy?.strict !== void 0) toolDef.function.strict = fieldsCopy.strict;
+	return toolDef;
 }
+
+//#endregion
+exports.convertToOpenAIFunction = convertToOpenAIFunction;
+exports.convertToOpenAITool = convertToOpenAITool;
+Object.defineProperty(exports, 'function_calling_exports', {
+  enumerable: true,
+  get: function () {
+    return function_calling_exports;
+  }
+});
+exports.isLangChainTool = require_types.isLangChainTool;
+exports.isRunnableToolLike = require_types.isRunnableToolLike;
+exports.isStructuredTool = require_types.isStructuredTool;
+exports.isStructuredToolParams = require_types.isStructuredToolParams;
+//# sourceMappingURL=function_calling.cjs.map

package/dist/utils/function_calling.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"function_calling.cjs","names":["tool: StructuredToolInterface | RunnableToolLike | StructuredToolParams","fields?:\n    | {\n        /**\n         * If `true`, model output is guaranteed to exactly match the JSON Schema\n         * provided in the function definition.\n         */\n        strict?: boolean;\n      }\n    | number","toJsonSchema","tool: StructuredToolInterface | Record<string, any> | RunnableToolLike","toolDef: ToolDefinition | undefined","isLangChainTool"],"sources":["../../src/utils/function_calling.ts"],"sourcesContent":["import {\n  StructuredToolInterface,\n  StructuredToolParams,\n  isLangChainTool,\n} from \"../tools/types.js\";\nimport { FunctionDefinition, ToolDefinition } from \"../language_models/base.js\";\nimport { RunnableToolLike } from \"../runnables/base.js\";\nimport { toJsonSchema } from \"./json_schema.js\";\n\n// These utility functions were moved to a more appropriate location,\n// but we still export them here for backwards compatibility.\nexport {\n  isStructuredTool,\n  isStructuredToolParams,\n  isRunnableToolLike,\n  isLangChainTool,\n} from \"../tools/types.js\";\n\n/**\n * Formats a `StructuredTool` or `RunnableToolLike` instance into a format\n * that is compatible with OpenAI function calling. If `StructuredTool` or\n * `RunnableToolLike` has a zod schema, the output will be converted into a\n * JSON schema, which is then used as the parameters for the OpenAI tool.\n *\n * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.\n * @returns {FunctionDefinition} The inputted tool in OpenAI function format.\n */\nexport function convertToOpenAIFunction(\n  tool: StructuredToolInterface | RunnableToolLike | StructuredToolParams,\n  fields?:\n    | {\n        /**\n         * If `true`, model output is guaranteed to exactly match the JSON Schema\n         * provided in the function definition.\n         */\n        strict?: boolean;\n      }\n    | number\n): FunctionDefinition {\n  // @TODO 0.3.0 Remove the `number` typing\n  const fieldsCopy = typeof fields === \"number\" ? undefined : fields;\n\n  return {\n    name: tool.name,\n    description: tool.description,\n    parameters: toJsonSchema(tool.schema),\n    // Do not include the `strict` field if it is `undefined`.\n    ...(fieldsCopy?.strict !== undefined ? { strict: fieldsCopy.strict } : {}),\n  };\n}\n\n/**\n * Formats a `StructuredTool` or `RunnableToolLike` instance into a\n * format that is compatible with OpenAI tool calling. If `StructuredTool` or\n * `RunnableToolLike` has a zod schema, the output will be converted into a\n * JSON schema, which is then used as the parameters for the OpenAI tool.\n *\n * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.\n * @returns {ToolDefinition} The inputted tool in OpenAI tool format.\n */\nexport function convertToOpenAITool(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  tool: StructuredToolInterface | Record<string, any> | RunnableToolLike,\n  fields?:\n    | {\n        /**\n         * If `true`, model output is guaranteed to exactly match the JSON Schema\n         * provided in the function definition.\n         */\n        strict?: boolean;\n      }\n    | number\n): ToolDefinition {\n  // @TODO 0.3.0 Remove the `number` typing\n  const fieldsCopy = typeof fields === \"number\" ? undefined : fields;\n\n  let toolDef: ToolDefinition | undefined;\n  if (isLangChainTool(tool)) {\n    toolDef = {\n      type: \"function\",\n      function: convertToOpenAIFunction(tool),\n    };\n  } else {\n    toolDef = tool as ToolDefinition;\n  }\n\n  if (fieldsCopy?.strict !== undefined) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (toolDef.function as any).strict = fieldsCopy.strict;\n  }\n\n  return toolDef;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,wBACdA,MACAC,QASoB;CAEpB,MAAM,aAAa,OAAO,WAAW,WAAW,SAAY;AAE5D,QAAO;EACL,MAAM,KAAK;EACX,aAAa,KAAK;EAClB,YAAYC,uCAAa,KAAK,OAAO;EAErC,GAAI,YAAY,WAAW,SAAY,EAAE,QAAQ,WAAW,OAAQ,IAAG,CAAE;CAC1E;AACF;;;;;;;;;;AAWD,SAAgB,oBAEdC,MACAF,QASgB;CAEhB,MAAM,aAAa,OAAO,WAAW,WAAW,SAAY;CAE5D,IAAIG;AACJ,KAAIC,8BAAgB,KAAK,EACvB,UAAU;EACR,MAAM;EACN,UAAU,wBAAwB,KAAK;CACxC;MAED,UAAU;AAGZ,KAAI,YAAY,WAAW,QAExB,QAAQ,SAAiB,SAAS,WAAW;AAGhD,QAAO;AACR"}

package/dist/utils/function_calling.d.cts

@@ -0,0 +1,43 @@
+import { RunnableToolLike } from "../runnables/base.cjs";
+import { FunctionDefinition, ToolDefinition } from "../language_models/base.cjs";
+import { StructuredToolInterface, StructuredToolParams, isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams } from "../tools/types.cjs";
+
+//#region src/utils/function_calling.d.ts
+
+/**
+ * Formats a `StructuredTool` or `RunnableToolLike` instance into a format
+ * that is compatible with OpenAI function calling. If `StructuredTool` or
+ * `RunnableToolLike` has a zod schema, the output will be converted into a
+ * JSON schema, which is then used as the parameters for the OpenAI tool.
+ *
+ * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.
+ * @returns {FunctionDefinition} The inputted tool in OpenAI function format.
+ */
+declare function convertToOpenAIFunction(tool: StructuredToolInterface | RunnableToolLike | StructuredToolParams, fields?: {
+  /**
+   * If `true`, model output is guaranteed to exactly match the JSON Schema
+   * provided in the function definition.
+   */
+  strict?: boolean;
+} | number): FunctionDefinition;
+/**
+ * Formats a `StructuredTool` or `RunnableToolLike` instance into a
+ * format that is compatible with OpenAI tool calling. If `StructuredTool` or
+ * `RunnableToolLike` has a zod schema, the output will be converted into a
+ * JSON schema, which is then used as the parameters for the OpenAI tool.
+ *
+ * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.
+ * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
+ */
+declare function convertToOpenAITool(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+tool: StructuredToolInterface | Record<string, any> | RunnableToolLike, fields?: {
+  /**
+   * If `true`, model output is guaranteed to exactly match the JSON Schema
+   * provided in the function definition.
+   */
+  strict?: boolean;
+} | number): ToolDefinition;
+//#endregion
+export { convertToOpenAIFunction, convertToOpenAITool, isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams };
+//# sourceMappingURL=function_calling.d.cts.map

package/dist/utils/function_calling.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function_calling.d.cts","names":["StructuredToolInterface","StructuredToolParams","FunctionDefinition","ToolDefinition","RunnableToolLike","isStructuredTool","isStructuredToolParams","isRunnableToolLike","isLangChainTool","convertToOpenAIFunction","convertToOpenAITool","Record"],"sources":["../../src/utils/function_calling.d.ts"],"sourcesContent":["import { StructuredToolInterface, StructuredToolParams } from \"../tools/types.js\";\nimport { FunctionDefinition, ToolDefinition } from \"../language_models/base.js\";\nimport { RunnableToolLike } from \"../runnables/base.js\";\n// These utility functions were moved to a more appropriate location,\n// but we still export them here for backwards compatibility.\nexport { isStructuredTool, isStructuredToolParams, isRunnableToolLike, isLangChainTool, } from \"../tools/types.js\";\n/**\n * Formats a `StructuredTool` or `RunnableToolLike` instance into a format\n * that is compatible with OpenAI function calling. If `StructuredTool` or\n * `RunnableToolLike` has a zod schema, the output will be converted into a\n * JSON schema, which is then used as the parameters for the OpenAI tool.\n *\n * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.\n * @returns {FunctionDefinition} The inputted tool in OpenAI function format.\n */\nexport declare function convertToOpenAIFunction(tool: StructuredToolInterface | RunnableToolLike | StructuredToolParams, fields?: {\n    /**\n     * If `true`, model output is guaranteed to exactly match the JSON Schema\n     * provided in the function definition.\n     */\n    strict?: boolean;\n} | number): FunctionDefinition;\n/**\n * Formats a `StructuredTool` or `RunnableToolLike` instance into a\n * format that is compatible with OpenAI tool calling. If `StructuredTool` or\n * `RunnableToolLike` has a zod schema, the output will be converted into a\n * JSON schema, which is then used as the parameters for the OpenAI tool.\n *\n * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.\n * @returns {ToolDefinition} The inputted tool in OpenAI tool format.\n */\nexport declare function convertToOpenAITool(\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntool: StructuredToolInterface | Record<string, any> | RunnableToolLike, fields?: {\n    /**\n     * If `true`, model output is guaranteed to exactly match the JSON Schema\n     * provided in the function definition.\n     */\n    strict?: boolean;\n} | number): ToolDefinition;\n"],"mappings":";;;;;;;;;;;AAqB+B;AAU/B;;;AAEgCW,iBAlBRF,uBAAAA,CAkBQE,IAAAA,EAlBsBX,uBAkBtBW,GAlBgDP,gBAkBhDO,GAlBmEV,oBAkBnEU,EAAAA,OAAAA,EAAAA;EAAM;;AAMX;;;aAlBdT;;;;;;;;;;iBAUWQ,mBAAAA;;MAElBV,0BAA0BW,sBAAsBP;;;;;;aAMzCD"}

package/dist/utils/function_calling.d.ts

@@ -1,7 +1,9 @@
-import { StructuredToolInterface, StructuredToolParams } from "../tools/types.js";
-import { FunctionDefinition, ToolDefinition } from "../language_models/base.js";
 import { RunnableToolLike } from "../runnables/base.js";
-export { isStructuredTool, isStructuredToolParams, isRunnableToolLike, isLangChainTool, } from "../tools/types.js";
+import { FunctionDefinition, ToolDefinition } from "../language_models/base.js";
+import { StructuredToolInterface, StructuredToolParams, isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams } from "../tools/types.js";
+
+//#region src/utils/function_calling.d.ts
+
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a format
  * that is compatible with OpenAI function calling. If `StructuredTool` or
@@ -11,12 +13,12 @@ export { isStructuredTool, isStructuredToolParams, isRunnableToolLike, isLangCha
  * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.
  * @returns {FunctionDefinition} The inputted tool in OpenAI function format.
  */
-export declare function convertToOpenAIFunction(tool: StructuredToolInterface | RunnableToolLike | StructuredToolParams, fields?: {
-    /**
-     * If `true`, model output is guaranteed to exactly match the JSON Schema
-     * provided in the function definition.
-     */
-    strict?: boolean;
+declare function convertToOpenAIFunction(tool: StructuredToolInterface | RunnableToolLike | StructuredToolParams, fields?: {
+  /**
+   * If `true`, model output is guaranteed to exactly match the JSON Schema
+   * provided in the function definition.
+   */
+  strict?: boolean;
 } | number): FunctionDefinition;
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a
@@ -27,10 +29,15 @@ export declare function convertToOpenAIFunction(tool: StructuredToolInterface |
  * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.
  * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
  */
-export declare function convertToOpenAITool(tool: StructuredToolInterface | Record<string, any> | RunnableToolLike, fields?: {
-    /**
-     * If `true`, model output is guaranteed to exactly match the JSON Schema
-     * provided in the function definition.
-     */
-    strict?: boolean;
+declare function convertToOpenAITool(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+tool: StructuredToolInterface | Record<string, any> | RunnableToolLike, fields?: {
+  /**
+   * If `true`, model output is guaranteed to exactly match the JSON Schema
+   * provided in the function definition.
+   */
+  strict?: boolean;
 } | number): ToolDefinition;
+//#endregion
+export { convertToOpenAIFunction, convertToOpenAITool, isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams };
+//# sourceMappingURL=function_calling.d.ts.map

package/dist/utils/function_calling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function_calling.d.ts","names":["StructuredToolInterface","StructuredToolParams","FunctionDefinition","ToolDefinition","RunnableToolLike","isStructuredTool","isStructuredToolParams","isRunnableToolLike","isLangChainTool","convertToOpenAIFunction","convertToOpenAITool","Record"],"sources":["../../src/utils/function_calling.d.ts"],"sourcesContent":["import { StructuredToolInterface, StructuredToolParams } from \"../tools/types.js\";\nimport { FunctionDefinition, ToolDefinition } from \"../language_models/base.js\";\nimport { RunnableToolLike } from \"../runnables/base.js\";\n// These utility functions were moved to a more appropriate location,\n// but we still export them here for backwards compatibility.\nexport { isStructuredTool, isStructuredToolParams, isRunnableToolLike, isLangChainTool, } from \"../tools/types.js\";\n/**\n * Formats a `StructuredTool` or `RunnableToolLike` instance into a format\n * that is compatible with OpenAI function calling. If `StructuredTool` or\n * `RunnableToolLike` has a zod schema, the output will be converted into a\n * JSON schema, which is then used as the parameters for the OpenAI tool.\n *\n * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.\n * @returns {FunctionDefinition} The inputted tool in OpenAI function format.\n */\nexport declare function convertToOpenAIFunction(tool: StructuredToolInterface | RunnableToolLike | StructuredToolParams, fields?: {\n    /**\n     * If `true`, model output is guaranteed to exactly match the JSON Schema\n     * provided in the function definition.\n     */\n    strict?: boolean;\n} | number): FunctionDefinition;\n/**\n * Formats a `StructuredTool` or `RunnableToolLike` instance into a\n * format that is compatible with OpenAI tool calling. If `StructuredTool` or\n * `RunnableToolLike` has a zod schema, the output will be converted into a\n * JSON schema, which is then used as the parameters for the OpenAI tool.\n *\n * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.\n * @returns {ToolDefinition} The inputted tool in OpenAI tool format.\n */\nexport declare function convertToOpenAITool(\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntool: StructuredToolInterface | Record<string, any> | RunnableToolLike, fields?: {\n    /**\n     * If `true`, model output is guaranteed to exactly match the JSON Schema\n     * provided in the function definition.\n     */\n    strict?: boolean;\n} | number): ToolDefinition;\n"],"mappings":";;;;;;;;;;;AAqB+B;AAU/B;;;AAEgCW,iBAlBRF,uBAAAA,CAkBQE,IAAAA,EAlBsBX,uBAkBtBW,GAlBgDP,gBAkBhDO,GAlBmEV,oBAkBnEU,EAAAA,OAAAA,EAAAA;EAAM;;AAMX;;;aAlBdT;;;;;;;;;;iBAUWQ,mBAAAA;;MAElBV,0BAA0BW,sBAAsBP;;;;;;aAMzCD"}