@langchain/openai 0.6.8 → 1.0.0-alpha.1

package/dist/utils/tools.cjs

@@ -1,144 +1,167 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._convertToOpenAITool = _convertToOpenAITool;
-exports.isBuiltInTool = isBuiltInTool;
-exports.isBuiltInToolChoice = isBuiltInToolChoice;
-exports.isCustomTool = isCustomTool;
-exports.isOpenAICustomTool = isOpenAICustomTool;
-exports.parseCustomToolCall = parseCustomToolCall;
-exports.isCustomToolCall = isCustomToolCall;
-exports.convertCompletionsCustomTool = convertCompletionsCustomTool;
-exports.convertResponsesCustomTool = convertResponsesCustomTool;
-const function_calling_1 = require("@langchain/core/utils/function_calling");
-const openai_js_1 = require("./openai.cjs");
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const __langchain_core_utils_types = require_rolldown_runtime.__toESM(require("@langchain/core/utils/types"));
+const __langchain_core_utils_json_schema = require_rolldown_runtime.__toESM(require("@langchain/core/utils/json_schema"));
+const __langchain_core_utils_function_calling = require_rolldown_runtime.__toESM(require("@langchain/core/utils/function_calling"));
+
+//#region src/utils/tools.ts
 /**
- * Formats a tool in either OpenAI format, or LangChain structured tool format
- * into an OpenAI tool format. If the tool is already in OpenAI format, return without
- * any changes. If it is in LangChain structured tool format, convert it to OpenAI tool format
- * using OpenAI's `zodFunction` util, falling back to `convertToOpenAIFunction` if the parameters
- * returned from the `zodFunction` util are not defined.
- *
- * @param {BindToolsInput} tool The tool to convert to an OpenAI tool.
- * @param {Object} [fields] Additional fields to add to the OpenAI tool.
- * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
- */
-function _convertToOpenAITool(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-tool, fields) {
-    let toolDef;
-    if ((0, function_calling_1.isLangChainTool)(tool)) {
-        toolDef = (0, openai_js_1.formatToOpenAITool)(tool);
-    }
-    else {
-        toolDef = tool;
-    }
-    if (toolDef.type === "function" && fields?.strict !== undefined) {
-        toolDef.function.strict = fields.strict;
-    }
-    return toolDef;
+* Formats a tool in either OpenAI format, or LangChain structured tool format
+* into an OpenAI tool format. If the tool is already in OpenAI format, return without
+* any changes. If it is in LangChain structured tool format, convert it to OpenAI tool format
+* using OpenAI's `zodFunction` util, falling back to `convertToOpenAIFunction` if the parameters
+* returned from the `zodFunction` util are not defined.
+*
+* @param {BindToolsInput} tool The tool to convert to an OpenAI tool.
+* @param {Object} [fields] Additional fields to add to the OpenAI tool.
+* @returns {ToolDefinition} The inputted tool in OpenAI tool format.
+*/
+function _convertToOpenAITool(tool, fields) {
+	let toolDef;
+	if ((0, __langchain_core_utils_function_calling.isLangChainTool)(tool)) toolDef = (0, __langchain_core_utils_function_calling.convertToOpenAITool)(tool);
+	else toolDef = tool;
+	if (fields?.strict !== void 0) toolDef.function.strict = fields.strict;
+	return toolDef;
+}
+function isAnyOfProp(prop) {
+	return prop.anyOf !== void 0 && Array.isArray(prop.anyOf);
+}
+function formatFunctionDefinitions(functions) {
+	const lines = ["namespace functions {", ""];
+	for (const f of functions) {
+		if (f.description) lines.push(`// ${f.description}`);
+		if (Object.keys(f.parameters.properties ?? {}).length > 0) {
+			lines.push(`type ${f.name} = (_: {`);
+			lines.push(formatObjectProperties(f.parameters, 0));
+			lines.push("}) => any;");
+		} else lines.push(`type ${f.name} = () => any;`);
+		lines.push("");
+	}
+	lines.push("} // namespace functions");
+	return lines.join("\n");
+}
+function formatObjectProperties(obj, indent) {
+	const lines = [];
+	for (const [name, param] of Object.entries(obj.properties ?? {})) {
+		if (param.description && indent < 2) lines.push(`// ${param.description}`);
+		if (obj.required?.includes(name)) lines.push(`${name}: ${formatType(param, indent)},`);
+		else lines.push(`${name}?: ${formatType(param, indent)},`);
+	}
+	return lines.map((line) => " ".repeat(indent) + line).join("\n");
+}
+function formatType(param, indent) {
+	if (isAnyOfProp(param)) return param.anyOf.map((v) => formatType(v, indent)).join(" | ");
+	switch (param.type) {
+		case "string":
+			if (param.enum) return param.enum.map((v) => `"${v}"`).join(" | ");
+			return "string";
+		case "number":
+			if (param.enum) return param.enum.map((v) => `${v}`).join(" | ");
+			return "number";
+		case "integer":
+			if (param.enum) return param.enum.map((v) => `${v}`).join(" | ");
+			return "number";
+		case "boolean": return "boolean";
+		case "null": return "null";
+		case "object": return [
+			"{",
+			formatObjectProperties(param, indent + 2),
+			"}"
+		].join("\n");
+		case "array":
+			if (param.items) return `${formatType(param.items, indent)}[]`;
+			return "any[]";
+		default: return "";
+	}
+}
+function formatToOpenAIToolChoice(toolChoice) {
+	if (!toolChoice) return void 0;
+	else if (toolChoice === "any" || toolChoice === "required") return "required";
+	else if (toolChoice === "auto") return "auto";
+	else if (toolChoice === "none") return "none";
+	else if (typeof toolChoice === "string") return {
+		type: "function",
+		function: { name: toolChoice }
+	};
+	else return toolChoice;
 }
 function isBuiltInTool(tool) {
-    return "type" in tool && tool.type !== "function" && tool.type !== "custom";
+	return "type" in tool && tool.type !== "function";
 }
 function isBuiltInToolChoice(tool_choice) {
-    return (tool_choice != null &&
-        typeof tool_choice === "object" &&
-        "type" in tool_choice &&
-        tool_choice.type !== "function");
+	return tool_choice != null && typeof tool_choice === "object" && "type" in tool_choice && tool_choice.type !== "function";
 }
 function isCustomTool(tool) {
-    return (typeof tool === "object" &&
-        tool !== null &&
-        "metadata" in tool &&
-        typeof tool.metadata === "object" &&
-        tool.metadata !== null &&
-        "customTool" in tool.metadata &&
-        typeof tool.metadata.customTool === "object" &&
-        tool.metadata.customTool !== null);
+	return typeof tool === "object" && tool !== null && "metadata" in tool && typeof tool.metadata === "object" && tool.metadata !== null && "customTool" in tool.metadata && typeof tool.metadata.customTool === "object" && tool.metadata.customTool !== null;
 }
 function isOpenAICustomTool(tool) {
-    return ("type" in tool &&
-        tool.type === "custom" &&
-        "custom" in tool &&
-        typeof tool.custom === "object" &&
-        tool.custom !== null);
+	return "type" in tool && tool.type === "custom" && "custom" in tool && typeof tool.custom === "object" && tool.custom !== null;
 }
-function parseCustomToolCall(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-rawToolCall) {
-    if (rawToolCall.type !== "custom_tool_call") {
-        return undefined;
-    }
-    return {
-        ...rawToolCall,
-        type: "tool_call",
-        call_id: rawToolCall.id,
-        id: rawToolCall.call_id,
-        name: rawToolCall.name,
-        isCustomTool: true,
-        args: {
-            input: rawToolCall.input,
-        },
-    };
+function parseCustomToolCall(rawToolCall) {
+	if (rawToolCall.type !== "custom_tool_call") return void 0;
+	return {
+		...rawToolCall,
+		type: "tool_call",
+		call_id: rawToolCall.id,
+		id: rawToolCall.call_id,
+		name: rawToolCall.name,
+		isCustomTool: true,
+		args: { input: rawToolCall.input }
+	};
 }
 function isCustomToolCall(toolCall) {
-    return (toolCall.type === "tool_call" &&
-        "isCustomTool" in toolCall &&
-        toolCall.isCustomTool === true);
+	return toolCall.type === "tool_call" && "isCustomTool" in toolCall && toolCall.isCustomTool === true;
 }
 function convertCompletionsCustomTool(tool) {
-    const getFormat = () => {
-        if (!tool.custom.format) {
-            return undefined;
-        }
-        if (tool.custom.format.type === "grammar") {
-            return {
-                type: "grammar",
-                definition: tool.custom.format.grammar.definition,
-                syntax: tool.custom.format.grammar.syntax,
-            };
-        }
-        if (tool.custom.format.type === "text") {
-            return {
-                type: "text",
-            };
-        }
-        return undefined;
-    };
-    return {
-        type: "custom",
-        name: tool.custom.name,
-        description: tool.custom.description,
-        format: getFormat(),
-    };
+	const getFormat = () => {
+		if (!tool.custom.format) return void 0;
+		if (tool.custom.format.type === "grammar") return {
+			type: "grammar",
+			definition: tool.custom.format.grammar.definition,
+			syntax: tool.custom.format.grammar.syntax
+		};
+		if (tool.custom.format.type === "text") return { type: "text" };
+		return void 0;
+	};
+	return {
+		type: "custom",
+		name: tool.custom.name,
+		description: tool.custom.description,
+		format: getFormat()
+	};
 }
 function convertResponsesCustomTool(tool) {
-    const getFormat = () => {
-        if (!tool.format) {
-            return undefined;
-        }
-        if (tool.format.type === "grammar") {
-            return {
-                type: "grammar",
-                grammar: {
-                    definition: tool.format.definition,
-                    syntax: tool.format.syntax,
-                },
-            };
-        }
-        if (tool.format.type === "text") {
-            return {
-                type: "text",
-            };
-        }
-        return undefined;
-    };
-    return {
-        type: "custom",
-        custom: {
-            name: tool.name,
-            description: tool.description,
-            format: getFormat(),
-        },
-    };
+	const getFormat = () => {
+		if (!tool.format) return void 0;
+		if (tool.format.type === "grammar") return {
+			type: "grammar",
+			grammar: {
+				definition: tool.format.definition,
+				syntax: tool.format.syntax
+			}
+		};
+		if (tool.format.type === "text") return { type: "text" };
+		return void 0;
+	};
+	return {
+		type: "custom",
+		custom: {
+			name: tool.name,
+			description: tool.description,
+			format: getFormat()
+		}
+	};
 }
+
+//#endregion
+exports._convertToOpenAITool = _convertToOpenAITool;
+exports.convertCompletionsCustomTool = convertCompletionsCustomTool;
+exports.convertResponsesCustomTool = convertResponsesCustomTool;
+exports.formatFunctionDefinitions = formatFunctionDefinitions;
+exports.formatToOpenAIToolChoice = formatToOpenAIToolChoice;
+exports.isBuiltInTool = isBuiltInTool;
+exports.isBuiltInToolChoice = isBuiltInToolChoice;
+exports.isCustomTool = isCustomTool;
+exports.isCustomToolCall = isCustomToolCall;
+exports.isOpenAICustomTool = isOpenAICustomTool;
+exports.parseCustomToolCall = parseCustomToolCall;
+//# sourceMappingURL=tools.cjs.map

package/dist/utils/tools.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.cjs","names":["tool: BindToolsInput","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  }","toolDef: OpenAIClient.ChatCompletionTool | undefined","prop: Prop","functions: FunctionDef[]","obj: ObjectProp","indent: number","lines: string[]","param: Prop","toolChoice?: OpenAIToolChoice","tool: ChatOpenAIToolType","tool_choice: OpenAIToolChoice | ResponsesToolChoice | undefined","tool: unknown","rawToolCall: Record<string, any>","toolCall: ToolCall","tool: OpenAIClient.Chat.ChatCompletionCustomTool","tool: OpenAIClient.Responses.CustomTool"],"sources":["../../src/utils/tools.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\n\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { BindToolsInput } from \"@langchain/core/language_models/chat_models\";\nimport {\n  convertToOpenAITool as formatToOpenAITool,\n  isLangChainTool,\n} from \"@langchain/core/utils/function_calling\";\nimport { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport { isInteropZodSchema } from \"@langchain/core/utils/types\";\nimport { toJsonSchema } from \"@langchain/core/utils/json_schema\";\nimport { ToolCall } from \"@langchain/core/messages/tool\";\n\n/**\n * Formats a tool in either OpenAI format, or LangChain structured tool format\n * into an OpenAI tool format. If the tool is already in OpenAI format, return without\n * any changes. If it is in LangChain structured tool format, convert it to OpenAI tool format\n * using OpenAI's `zodFunction` util, falling back to `convertToOpenAIFunction` if the parameters\n * returned from the `zodFunction` util are not defined.\n *\n * @param {BindToolsInput} tool The tool to convert to an OpenAI tool.\n * @param {Object} [fields] Additional fields to add to the 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: BindToolsInput,\n  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  }\n): OpenAIClient.ChatCompletionTool {\n  let toolDef: OpenAIClient.ChatCompletionTool | undefined;\n\n  if (isLangChainTool(tool)) {\n    toolDef = formatToOpenAITool(tool);\n  } else {\n    toolDef = tool as ToolDefinition;\n  }\n\n  if (fields?.strict !== undefined) {\n    toolDef.function.strict = fields.strict;\n  }\n\n  return toolDef;\n}\n\ntype OpenAIFunction = OpenAIClient.Chat.ChatCompletionCreateParams.Function;\n\n// Types representing the OpenAI function definitions. While the OpenAI client library\n// does have types for function definitions, the properties are just Record<string, unknown>,\n// which isn't very useful for type checking this formatting code.\nexport interface FunctionDef extends Omit<OpenAIFunction, \"parameters\"> {\n  name: string;\n  description?: string;\n  parameters: ObjectProp;\n}\n\ninterface ObjectProp {\n  type: \"object\";\n  properties?: {\n    [key: string]: Prop;\n  };\n  required?: string[];\n}\n\ninterface AnyOfProp {\n  anyOf: Prop[];\n}\n\ntype Prop = {\n  description?: string;\n} & (\n  | AnyOfProp\n  | ObjectProp\n  | {\n      type: \"string\";\n      enum?: string[];\n    }\n  | {\n      type: \"number\" | \"integer\";\n      minimum?: number;\n      maximum?: number;\n      enum?: number[];\n    }\n  | { type: \"boolean\" }\n  | { type: \"null\" }\n  | {\n      type: \"array\";\n      items?: Prop;\n    }\n);\n\nfunction isAnyOfProp(prop: Prop): prop is AnyOfProp {\n  return (\n    (prop as AnyOfProp).anyOf !== undefined &&\n    Array.isArray((prop as AnyOfProp).anyOf)\n  );\n}\n\n// When OpenAI use functions in the prompt, they format them as TypeScript definitions rather than OpenAPI JSON schemas.\n// This function converts the JSON schemas into TypeScript definitions.\nexport function formatFunctionDefinitions(functions: FunctionDef[]) {\n  const lines = [\"namespace functions {\", \"\"];\n  for (const f of functions) {\n    if (f.description) {\n      lines.push(`// ${f.description}`);\n    }\n    if (Object.keys(f.parameters.properties ?? {}).length > 0) {\n      lines.push(`type ${f.name} = (_: {`);\n      lines.push(formatObjectProperties(f.parameters, 0));\n      lines.push(\"}) => any;\");\n    } else {\n      lines.push(`type ${f.name} = () => any;`);\n    }\n    lines.push(\"\");\n  }\n  lines.push(\"} // namespace functions\");\n  return lines.join(\"\\n\");\n}\n\n// Format just the properties of an object (not including the surrounding braces)\nfunction formatObjectProperties(obj: ObjectProp, indent: number): string {\n  const lines: string[] = [];\n  for (const [name, param] of Object.entries(obj.properties ?? {})) {\n    if (param.description && indent < 2) {\n      lines.push(`// ${param.description}`);\n    }\n    if (obj.required?.includes(name)) {\n      lines.push(`${name}: ${formatType(param, indent)},`);\n    } else {\n      lines.push(`${name}?: ${formatType(param, indent)},`);\n    }\n  }\n  return lines.map((line) => \" \".repeat(indent) + line).join(\"\\n\");\n}\n\n// Format a single property type\nfunction formatType(param: Prop, indent: number): string {\n  if (isAnyOfProp(param)) {\n    return param.anyOf.map((v) => formatType(v, indent)).join(\" | \");\n  }\n  switch (param.type) {\n    case \"string\":\n      if (param.enum) {\n        return param.enum.map((v) => `\"${v}\"`).join(\" | \");\n      }\n      return \"string\";\n    case \"number\":\n      if (param.enum) {\n        return param.enum.map((v) => `${v}`).join(\" | \");\n      }\n      return \"number\";\n    case \"integer\":\n      if (param.enum) {\n        return param.enum.map((v) => `${v}`).join(\" | \");\n      }\n      return \"number\";\n    case \"boolean\":\n      return \"boolean\";\n    case \"null\":\n      return \"null\";\n    case \"object\":\n      return [\"{\", formatObjectProperties(param, indent + 2), \"}\"].join(\"\\n\");\n    case \"array\":\n      if (param.items) {\n        return `${formatType(param.items, indent)}[]`;\n      }\n      return \"any[]\";\n    default:\n      return \"\";\n  }\n}\n\nexport function formatToOpenAIAssistantTool(\n  tool: StructuredToolInterface\n): ToolDefinition {\n  return {\n    type: \"function\",\n    function: {\n      name: tool.name,\n      description: tool.description,\n      parameters: isInteropZodSchema(tool.schema)\n        ? toJsonSchema(tool.schema)\n        : tool.schema,\n    },\n  };\n}\n\nexport type OpenAIToolChoice =\n  | OpenAIClient.ChatCompletionToolChoiceOption\n  | \"any\"\n  | string;\n\nexport type ResponsesToolChoice = NonNullable<\n  OpenAIClient.Responses.ResponseCreateParams[\"tool_choice\"]\n>;\n\nexport type ChatOpenAIToolType =\n  | BindToolsInput\n  | OpenAIClient.Chat.ChatCompletionTool\n  | ResponsesTool;\n\nexport type ResponsesTool = NonNullable<\n  OpenAIClient.Responses.ResponseCreateParams[\"tools\"]\n>[number];\n\nexport function formatToOpenAIToolChoice(\n  toolChoice?: OpenAIToolChoice\n): OpenAIClient.ChatCompletionToolChoiceOption | undefined {\n  if (!toolChoice) {\n    return undefined;\n  } else if (toolChoice === \"any\" || toolChoice === \"required\") {\n    return \"required\";\n  } else if (toolChoice === \"auto\") {\n    return \"auto\";\n  } else if (toolChoice === \"none\") {\n    return \"none\";\n  } else if (typeof toolChoice === \"string\") {\n    return {\n      type: \"function\",\n      function: {\n        name: toolChoice,\n      },\n    };\n  } else {\n    return toolChoice;\n  }\n}\n\nexport function isBuiltInTool(tool: ChatOpenAIToolType): tool is ResponsesTool {\n  return \"type\" in tool && tool.type !== \"function\";\n}\n\nexport function isBuiltInToolChoice(\n  tool_choice: OpenAIToolChoice | ResponsesToolChoice | undefined\n): tool_choice is ResponsesToolChoice {\n  return (\n    tool_choice != null &&\n    typeof tool_choice === \"object\" &&\n    \"type\" in tool_choice &&\n    tool_choice.type !== \"function\"\n  );\n}\n\nexport type CustomToolCall = ToolCall & {\n  call_id: string;\n  isCustomTool: true;\n};\n\ntype LangchainCustomTool = DynamicTool<string> & {\n  metadata: {\n    customTool: OpenAIClient.Responses.CustomTool;\n  };\n};\n\nexport function isCustomTool(tool: unknown): tool is LangchainCustomTool {\n  return (\n    typeof tool === \"object\" &&\n    tool !== null &&\n    \"metadata\" in tool &&\n    typeof tool.metadata === \"object\" &&\n    tool.metadata !== null &&\n    \"customTool\" in tool.metadata &&\n    typeof tool.metadata.customTool === \"object\" &&\n    tool.metadata.customTool !== null\n  );\n}\n\nexport function isOpenAICustomTool(\n  tool: ChatOpenAIToolType\n): tool is OpenAIClient.Chat.ChatCompletionCustomTool {\n  return (\n    \"type\" in tool &&\n    tool.type === \"custom\" &&\n    \"custom\" in tool &&\n    typeof tool.custom === \"object\" &&\n    tool.custom !== null\n  );\n}\n\nexport function parseCustomToolCall(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  rawToolCall: Record<string, any>\n): CustomToolCall | undefined {\n  if (rawToolCall.type !== \"custom_tool_call\") {\n    return undefined;\n  }\n  return {\n    ...rawToolCall,\n    type: \"tool_call\",\n    call_id: rawToolCall.id,\n    id: rawToolCall.call_id,\n    name: rawToolCall.name,\n    isCustomTool: true,\n    args: {\n      input: rawToolCall.input,\n    },\n  };\n}\n\nexport function isCustomToolCall(\n  toolCall: ToolCall\n): toolCall is CustomToolCall {\n  return (\n    toolCall.type === \"tool_call\" &&\n    \"isCustomTool\" in toolCall &&\n    toolCall.isCustomTool === true\n  );\n}\n\nexport function convertCompletionsCustomTool(\n  tool: OpenAIClient.Chat.ChatCompletionCustomTool\n): OpenAIClient.Responses.CustomTool {\n  const getFormat = () => {\n    if (!tool.custom.format) {\n      return undefined;\n    }\n    if (tool.custom.format.type === \"grammar\") {\n      return {\n        type: \"grammar\" as const,\n        definition: tool.custom.format.grammar.definition,\n        syntax: tool.custom.format.grammar.syntax,\n      };\n    }\n    if (tool.custom.format.type === \"text\") {\n      return {\n        type: \"text\" as const,\n      };\n    }\n    return undefined;\n  };\n  return {\n    type: \"custom\",\n    name: tool.custom.name,\n    description: tool.custom.description,\n    format: getFormat(),\n  };\n}\n\nexport function convertResponsesCustomTool(\n  tool: OpenAIClient.Responses.CustomTool\n): OpenAIClient.Chat.ChatCompletionCustomTool {\n  const getFormat = () => {\n    if (!tool.format) {\n      return undefined;\n    }\n    if (tool.format.type === \"grammar\") {\n      return {\n        type: \"grammar\" as const,\n        grammar: {\n          definition: tool.format.definition,\n          syntax: tool.format.syntax,\n        },\n      };\n    }\n    if (tool.format.type === \"text\") {\n      return {\n        type: \"text\" as const,\n      };\n    }\n    return undefined;\n  };\n  return {\n    type: \"custom\",\n    custom: {\n      name: tool.name,\n      description: tool.description,\n      format: getFormat(),\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/utils/tools.d.cts

@@ -0,0 +1,13 @@
+import { OpenAI as OpenAI$1 } from "openai";
+import { BindToolsInput } from "@langchain/core/language_models/chat_models";
+import { DynamicTool } from "@langchain/core/tools";
+
+//#region src/utils/tools.d.ts
+
+type OpenAIToolChoice = OpenAI$1.ChatCompletionToolChoiceOption | "any" | string;
+type ResponsesToolChoice = NonNullable<OpenAI$1.Responses.ResponseCreateParams["tool_choice"]>;
+type ChatOpenAIToolType = BindToolsInput | OpenAI$1.Chat.ChatCompletionTool | ResponsesTool;
+type ResponsesTool = NonNullable<OpenAI$1.Responses.ResponseCreateParams["tools"]>[number];
+//#endregion
+export { ChatOpenAIToolType, OpenAIToolChoice, ResponsesTool, ResponsesToolChoice };
+//# sourceMappingURL=tools.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.cts","names":["OpenAI","OpenAIClient","ToolDefinition","BindToolsInput","DynamicTool","StructuredToolInterface","ToolCall","_convertToOpenAITool","ChatCompletionTool","OpenAIFunction","Chat","ChatCompletionCreateParams","Function","FunctionDef","ObjectProp","Omit","Prop","AnyOfProp","formatFunctionDefinitions","formatToOpenAIAssistantTool","OpenAIToolChoice","ChatCompletionToolChoiceOption","ResponsesToolChoice","Responses","ResponseCreateParams","NonNullable","ChatOpenAIToolType","ResponsesTool","formatToOpenAIToolChoice","isBuiltInTool","isBuiltInToolChoice","CustomToolCall","LangchainCustomTool","CustomTool","isCustomTool","isOpenAICustomTool","ChatCompletionCustomTool","parseCustomToolCall","Record","isCustomToolCall","convertCompletionsCustomTool","convertResponsesCustomTool"],"sources":["../../src/utils/tools.d.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { BindToolsInput } from \"@langchain/core/language_models/chat_models\";\nimport { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport { ToolCall } from \"@langchain/core/messages/tool\";\n/**\n * Formats a tool in either OpenAI format, or LangChain structured tool format\n * into an OpenAI tool format. If the tool is already in OpenAI format, return without\n * any changes. If it is in LangChain structured tool format, convert it to OpenAI tool format\n * using OpenAI's `zodFunction` util, falling back to `convertToOpenAIFunction` if the parameters\n * returned from the `zodFunction` util are not defined.\n *\n * @param {BindToolsInput} tool The tool to convert to an OpenAI tool.\n * @param {Object} [fields] Additional fields to add to the 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: BindToolsInput, 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}): OpenAIClient.ChatCompletionTool;\ntype OpenAIFunction = OpenAIClient.Chat.ChatCompletionCreateParams.Function;\n// Types representing the OpenAI function definitions. While the OpenAI client library\n// does have types for function definitions, the properties are just Record<string, unknown>,\n// which isn't very useful for type checking this formatting code.\nexport interface FunctionDef extends Omit<OpenAIFunction, \"parameters\"> {\n    name: string;\n    description?: string;\n    parameters: ObjectProp;\n}\ninterface ObjectProp {\n    type: \"object\";\n    properties?: {\n        [key: string]: Prop;\n    };\n    required?: string[];\n}\ninterface AnyOfProp {\n    anyOf: Prop[];\n}\ntype Prop = {\n    description?: string;\n} & (AnyOfProp | ObjectProp | {\n    type: \"string\";\n    enum?: string[];\n} | {\n    type: \"number\" | \"integer\";\n    minimum?: number;\n    maximum?: number;\n    enum?: number[];\n} | {\n    type: \"boolean\";\n} | {\n    type: \"null\";\n} | {\n    type: \"array\";\n    items?: Prop;\n});\n// When OpenAI use functions in the prompt, they format them as TypeScript definitions rather than OpenAPI JSON schemas.\n// This function converts the JSON schemas into TypeScript definitions.\nexport declare function formatFunctionDefinitions(functions: FunctionDef[]): string;\nexport declare function formatToOpenAIAssistantTool(tool: StructuredToolInterface): ToolDefinition;\nexport type OpenAIToolChoice = OpenAIClient.ChatCompletionToolChoiceOption | \"any\" | string;\nexport type ResponsesToolChoice = NonNullable<OpenAIClient.Responses.ResponseCreateParams[\"tool_choice\"]>;\nexport type ChatOpenAIToolType = BindToolsInput | OpenAIClient.Chat.ChatCompletionTool | ResponsesTool;\nexport type ResponsesTool = NonNullable<OpenAIClient.Responses.ResponseCreateParams[\"tools\"]>[number];\nexport declare function formatToOpenAIToolChoice(toolChoice?: OpenAIToolChoice): OpenAIClient.ChatCompletionToolChoiceOption | undefined;\nexport declare function isBuiltInTool(tool: ChatOpenAIToolType): tool is ResponsesTool;\nexport declare function isBuiltInToolChoice(tool_choice: OpenAIToolChoice | ResponsesToolChoice | undefined): tool_choice is ResponsesToolChoice;\nexport type CustomToolCall = ToolCall & {\n    call_id: string;\n    isCustomTool: true;\n};\ntype LangchainCustomTool = DynamicTool<string> & {\n    metadata: {\n        customTool: OpenAIClient.Responses.CustomTool;\n    };\n};\nexport declare function isCustomTool(tool: unknown): tool is LangchainCustomTool;\nexport declare function isOpenAICustomTool(tool: ChatOpenAIToolType): tool is OpenAIClient.Chat.ChatCompletionCustomTool;\nexport declare function parseCustomToolCall(\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nrawToolCall: Record<string, any>): CustomToolCall | undefined;\nexport declare function isCustomToolCall(toolCall: ToolCall): toolCall is CustomToolCall;\nexport declare function convertCompletionsCustomTool(tool: OpenAIClient.Chat.ChatCompletionCustomTool): OpenAIClient.Responses.CustomTool;\nexport declare function convertResponsesCustomTool(tool: OpenAIClient.Responses.CustomTool): OpenAIClient.Chat.ChatCompletionCustomTool;\nexport {};\n"],"mappings":";;;;;;KAkEYoB,gBAAAA,GAAmBnB,QAAAA,CAAaoB;KAChCC,mBAAAA,GAAsBG,YAAYxB,QAAAA,CAAasB,SAAAA,CAAUC;KACzDE,kBAAAA,GAAqBvB,iBAAiBF,QAAAA,CAAaS,IAAAA,CAAKF,qBAAqBmB;KAC7EA,aAAAA,GAAgBF,YAAYxB,QAAAA,CAAasB,SAAAA,CAAUC"}

package/dist/utils/tools.d.ts

@@ -1,44 +1,14 @@
-import { OpenAI as OpenAIClient } from "openai";
-import { ToolCall } from "@langchain/core/messages/tool";
+import { OpenAI as OpenAI$1 } from "openai";
 import { BindToolsInput } from "@langchain/core/language_models/chat_models";
+import "@langchain/core/language_models/base";
 import { DynamicTool } from "@langchain/core/tools";
-import { OpenAIToolChoice } from "./openai.js";
-export type ResponsesTool = NonNullable<OpenAIClient.Responses.ResponseCreateParams["tools"]>[number];
-export type ResponsesToolChoice = NonNullable<OpenAIClient.Responses.ResponseCreateParams["tool_choice"]>;
-export type ChatOpenAIToolType = BindToolsInput | OpenAIClient.Chat.ChatCompletionTool | ResponsesTool;
-/**
- * Formats a tool in either OpenAI format, or LangChain structured tool format
- * into an OpenAI tool format. If the tool is already in OpenAI format, return without
- * any changes. If it is in LangChain structured tool format, convert it to OpenAI tool format
- * using OpenAI's `zodFunction` util, falling back to `convertToOpenAIFunction` if the parameters
- * returned from the `zodFunction` util are not defined.
- *
- * @param {BindToolsInput} tool The tool to convert to an OpenAI tool.
- * @param {Object} [fields] Additional fields to add to the OpenAI tool.
- * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
- */
-export declare function _convertToOpenAITool(tool: BindToolsInput, fields?: {
-    /**
-     * If `true`, model output is guaranteed to exactly match the JSON Schema
-     * provided in the function definition.
-     */
-    strict?: boolean;
-}): OpenAIClient.ChatCompletionTool;
-export declare function isBuiltInTool(tool: ChatOpenAIToolType): tool is ResponsesTool;
-export declare function isBuiltInToolChoice(tool_choice: OpenAIToolChoice | ResponsesToolChoice | undefined): tool_choice is ResponsesToolChoice;
-export type CustomToolCall = ToolCall & {
-    call_id: string;
-    isCustomTool: true;
-};
-type LangchainCustomTool = DynamicTool<string> & {
-    metadata: {
-        customTool: OpenAIClient.Responses.CustomTool;
-    };
-};
-export declare function isCustomTool(tool: unknown): tool is LangchainCustomTool;
-export declare function isOpenAICustomTool(tool: ChatOpenAIToolType): tool is OpenAIClient.Chat.ChatCompletionCustomTool;
-export declare function parseCustomToolCall(rawToolCall: Record<string, any>): CustomToolCall | undefined;
-export declare function isCustomToolCall(toolCall: ToolCall): toolCall is CustomToolCall;
-export declare function convertCompletionsCustomTool(tool: OpenAIClient.Chat.ChatCompletionCustomTool): OpenAIClient.Responses.CustomTool;
-export declare function convertResponsesCustomTool(tool: OpenAIClient.Responses.CustomTool): OpenAIClient.Chat.ChatCompletionCustomTool;
-export {};
+
+//#region src/utils/tools.d.ts
+
+type OpenAIToolChoice = OpenAI$1.ChatCompletionToolChoiceOption | "any" | string;
+type ResponsesToolChoice = NonNullable<OpenAI$1.Responses.ResponseCreateParams["tool_choice"]>;
+type ChatOpenAIToolType = BindToolsInput | OpenAI$1.Chat.ChatCompletionTool | ResponsesTool;
+type ResponsesTool = NonNullable<OpenAI$1.Responses.ResponseCreateParams["tools"]>[number];
+//#endregion
+export { ChatOpenAIToolType, OpenAIToolChoice, ResponsesTool, ResponsesToolChoice };
+//# sourceMappingURL=tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","names":["OpenAI","OpenAIClient","ToolDefinition","BindToolsInput","DynamicTool","StructuredToolInterface","ToolCall","_convertToOpenAITool","ChatCompletionTool","OpenAIFunction","Chat","ChatCompletionCreateParams","Function","FunctionDef","ObjectProp","Omit","Prop","AnyOfProp","formatFunctionDefinitions","formatToOpenAIAssistantTool","OpenAIToolChoice","ChatCompletionToolChoiceOption","ResponsesToolChoice","Responses","ResponseCreateParams","NonNullable","ChatOpenAIToolType","ResponsesTool","formatToOpenAIToolChoice","isBuiltInTool","isBuiltInToolChoice","CustomToolCall","LangchainCustomTool","CustomTool","isCustomTool","isOpenAICustomTool","ChatCompletionCustomTool","parseCustomToolCall","Record","isCustomToolCall","convertCompletionsCustomTool","convertResponsesCustomTool"],"sources":["../../src/utils/tools.d.ts"],"sourcesContent":["import { OpenAI as OpenAIClient } from \"openai\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { BindToolsInput } from \"@langchain/core/language_models/chat_models\";\nimport { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport { ToolCall } from \"@langchain/core/messages/tool\";\n/**\n * Formats a tool in either OpenAI format, or LangChain structured tool format\n * into an OpenAI tool format. If the tool is already in OpenAI format, return without\n * any changes. If it is in LangChain structured tool format, convert it to OpenAI tool format\n * using OpenAI's `zodFunction` util, falling back to `convertToOpenAIFunction` if the parameters\n * returned from the `zodFunction` util are not defined.\n *\n * @param {BindToolsInput} tool The tool to convert to an OpenAI tool.\n * @param {Object} [fields] Additional fields to add to the 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: BindToolsInput, 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}): OpenAIClient.ChatCompletionTool;\ntype OpenAIFunction = OpenAIClient.Chat.ChatCompletionCreateParams.Function;\n// Types representing the OpenAI function definitions. While the OpenAI client library\n// does have types for function definitions, the properties are just Record<string, unknown>,\n// which isn't very useful for type checking this formatting code.\nexport interface FunctionDef extends Omit<OpenAIFunction, \"parameters\"> {\n    name: string;\n    description?: string;\n    parameters: ObjectProp;\n}\ninterface ObjectProp {\n    type: \"object\";\n    properties?: {\n        [key: string]: Prop;\n    };\n    required?: string[];\n}\ninterface AnyOfProp {\n    anyOf: Prop[];\n}\ntype Prop = {\n    description?: string;\n} & (AnyOfProp | ObjectProp | {\n    type: \"string\";\n    enum?: string[];\n} | {\n    type: \"number\" | \"integer\";\n    minimum?: number;\n    maximum?: number;\n    enum?: number[];\n} | {\n    type: \"boolean\";\n} | {\n    type: \"null\";\n} | {\n    type: \"array\";\n    items?: Prop;\n});\n// When OpenAI use functions in the prompt, they format them as TypeScript definitions rather than OpenAPI JSON schemas.\n// This function converts the JSON schemas into TypeScript definitions.\nexport declare function formatFunctionDefinitions(functions: FunctionDef[]): string;\nexport declare function formatToOpenAIAssistantTool(tool: StructuredToolInterface): ToolDefinition;\nexport type OpenAIToolChoice = OpenAIClient.ChatCompletionToolChoiceOption | \"any\" | string;\nexport type ResponsesToolChoice = NonNullable<OpenAIClient.Responses.ResponseCreateParams[\"tool_choice\"]>;\nexport type ChatOpenAIToolType = BindToolsInput | OpenAIClient.Chat.ChatCompletionTool | ResponsesTool;\nexport type ResponsesTool = NonNullable<OpenAIClient.Responses.ResponseCreateParams[\"tools\"]>[number];\nexport declare function formatToOpenAIToolChoice(toolChoice?: OpenAIToolChoice): OpenAIClient.ChatCompletionToolChoiceOption | undefined;\nexport declare function isBuiltInTool(tool: ChatOpenAIToolType): tool is ResponsesTool;\nexport declare function isBuiltInToolChoice(tool_choice: OpenAIToolChoice | ResponsesToolChoice | undefined): tool_choice is ResponsesToolChoice;\nexport type CustomToolCall = ToolCall & {\n    call_id: string;\n    isCustomTool: true;\n};\ntype LangchainCustomTool = DynamicTool<string> & {\n    metadata: {\n        customTool: OpenAIClient.Responses.CustomTool;\n    };\n};\nexport declare function isCustomTool(tool: unknown): tool is LangchainCustomTool;\nexport declare function isOpenAICustomTool(tool: ChatOpenAIToolType): tool is OpenAIClient.Chat.ChatCompletionCustomTool;\nexport declare function parseCustomToolCall(\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nrawToolCall: Record<string, any>): CustomToolCall | undefined;\nexport declare function isCustomToolCall(toolCall: ToolCall): toolCall is CustomToolCall;\nexport declare function convertCompletionsCustomTool(tool: OpenAIClient.Chat.ChatCompletionCustomTool): OpenAIClient.Responses.CustomTool;\nexport declare function convertResponsesCustomTool(tool: OpenAIClient.Responses.CustomTool): OpenAIClient.Chat.ChatCompletionCustomTool;\nexport {};\n"],"mappings":";;;;;;;KAkEYoB,gBAAAA,GAAmBnB,QAAAA,CAAaoB;KAChCC,mBAAAA,GAAsBG,YAAYxB,QAAAA,CAAasB,SAAAA,CAAUC;KACzDE,kBAAAA,GAAqBvB,iBAAiBF,QAAAA,CAAaS,IAAAA,CAAKF,qBAAqBmB;KAC7EA,aAAAA,GAAgBF,YAAYxB,QAAAA,CAAasB,SAAAA,CAAUC"}