@langchain/openai 0.6.16 → 1.0.0-alpha.2

package/dist/utils/tools.js

@@ -1,133 +1,156 @@
-import { isLangChainTool } from "@langchain/core/utils/function_calling";
-import { formatToOpenAITool } from "./openai.js";
+import { isInteropZodSchema } from "@langchain/core/utils/types";
+import { toJsonSchema } from "@langchain/core/utils/json_schema";
+import { convertToOpenAITool, isLangChainTool } from "@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.
- */
-export function _convertToOpenAITool(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-tool, fields) {
-    let toolDef;
-    if (isLangChainTool(tool)) {
-        toolDef = 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 (isLangChainTool(tool)) toolDef = convertToOpenAITool(tool);
+	else toolDef = tool;
+	if (fields?.strict !== void 0) toolDef.function.strict = fields.strict;
+	return toolDef;
 }
-export function isBuiltInTool(tool) {
-    return "type" in tool && tool.type !== "function" && tool.type !== "custom";
+function isAnyOfProp(prop) {
+	return prop.anyOf !== void 0 && Array.isArray(prop.anyOf);
 }
-export function isBuiltInToolChoice(tool_choice) {
-    return (tool_choice != null &&
-        typeof tool_choice === "object" &&
-        "type" in tool_choice &&
-        tool_choice.type !== "function");
+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");
 }
-export 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);
+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");
 }
-export function isOpenAICustomTool(tool) {
-    return ("type" in tool &&
-        tool.type === "custom" &&
-        "custom" in tool &&
-        typeof tool.custom === "object" &&
-        tool.custom !== null);
+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 "";
+	}
 }
-export 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 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;
 }
-export function isCustomToolCall(toolCall) {
-    return (toolCall.type === "tool_call" &&
-        "isCustomTool" in toolCall &&
-        toolCall.isCustomTool === true);
+function isBuiltInTool(tool) {
+	return "type" in tool && tool.type !== "function";
 }
-export 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(),
-    };
+function isBuiltInToolChoice(tool_choice) {
+	return tool_choice != null && typeof tool_choice === "object" && "type" in tool_choice && tool_choice.type !== "function";
 }
-export 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(),
-        },
-    };
+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;
 }
+function isOpenAICustomTool(tool) {
+	return "type" in tool && tool.type === "custom" && "custom" in tool && typeof tool.custom === "object" && tool.custom !== null;
+}
+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;
+}
+function convertCompletionsCustomTool(tool) {
+	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 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
+export { _convertToOpenAITool, convertCompletionsCustomTool, convertResponsesCustomTool, formatFunctionDefinitions, formatToOpenAIToolChoice, isBuiltInTool, isBuiltInToolChoice, isCustomTool, isCustomToolCall, isOpenAICustomTool, parseCustomToolCall };
+//# sourceMappingURL=tools.js.map

package/dist/utils/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","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","formatToOpenAITool","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  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/package.json

@@ -1,70 +1,45 @@
 {
   "name": "@langchain/openai",
-  "version": "0.6.16",
+  "version": "1.0.0-alpha.2",
   "description": "OpenAI integrations for LangChain.js",
+  "author": "LangChain",
+  "license": "MIT",
   "type": "module",
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
-  "main": "./index.js",
-  "types": "./index.d.ts",
   "repository": {
     "type": "git",
     "url": "git@github.com:langchain-ai/langchainjs.git"
   },
-  "homepage": "https://github.com/langchain-ai/langchainjs/tree/main/libs/langchain-openai/",
-  "scripts": {
-    "build": "yarn turbo:command build:internal --filter=@langchain/openai",
-    "build:internal": "yarn lc_build --create-entrypoints --pre --tree-shaking",
-    "lint:eslint": "NODE_OPTIONS=--max-old-space-size=4096 eslint --cache --ext .ts,.js src/",
-    "lint:dpdm": "dpdm --skip-dynamic-imports circular --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts",
-    "lint": "yarn lint:eslint && yarn lint:dpdm",
-    "lint:fix": "yarn lint:eslint --fix && yarn lint:dpdm",
-    "clean": "rm -rf .turbo dist/",
-    "prepack": "yarn build",
-    "test": "NODE_OPTIONS=--experimental-vm-modules jest --testPathIgnorePatterns=\\.int\\.test.ts --testTimeout 30000 --maxWorkers=50%",
-    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch --testPathIgnorePatterns=\\.int\\.test.ts",
-    "test:single": "NODE_OPTIONS=--experimental-vm-modules yarn run jest --config jest.config.cjs --testTimeout 100000",
-    "test:int": "NODE_OPTIONS=--experimental-vm-modules jest --testPathPattern=\\.int\\.test.ts --testTimeout 100000 --maxWorkers=50%",
-    "test:standard:unit": "NODE_OPTIONS=--experimental-vm-modules jest --testPathPattern=\\.standard\\.test.ts --testTimeout 100000 --maxWorkers=50%",
-    "test:standard:int": "NODE_OPTIONS=--experimental-vm-modules jest --testPathPattern=\\.standard\\.int\\.test.ts --testTimeout 100000 --maxWorkers=50%",
-    "test:standard": "yarn test:standard:unit && yarn test:standard:int",
-    "format": "prettier --config .prettierrc --write \"src\"",
-    "format:check": "prettier --config .prettierrc --check \"src\""
-  },
-  "author": "LangChain",
-  "license": "MIT",
+  "homepage": "https://github.com/langchain-ai/langchainjs/tree/main/libs/providers/langchain-openai/",
   "dependencies": {
     "js-tiktoken": "^1.0.12",
-    "openai": "5.12.2",
-    "zod": "^3.25.32"
+    "openai": "^5.3.0",
+    "zod": "^3.25.76 || ^4"
   },
   "peerDependencies": {
-    "@langchain/core": ">=0.3.68 <0.4.0"
+    "@langchain/core": "^1.0.0-alpha.6"
   },
   "devDependencies": {
     "@azure/identity": "^4.2.1",
-    "@jest/globals": "^29.5.0",
-    "@langchain/core": "workspace:*",
-    "@langchain/scripts": ">=0.1.0 <0.2.0",
-    "@langchain/standard-tests": "0.0.0",
-    "@swc/core": "^1.3.90",
-    "@swc/jest": "^0.2.29",
+    "@cfworker/json-schema": "^4.1.1",
+    "@tsconfig/recommended": "^1.0.10",
+    "@vitest/coverage-v8": "^3.2.4",
+    "dotenv": "^17.2.1",
     "dpdm": "^3.14.0",
-    "eslint": "^8.33.0",
-    "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-prettier": "^8.6.0",
-    "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-jest": "^27.6.0",
-    "eslint-plugin-no-instanceof": "^1.0.1",
-    "eslint-plugin-prettier": "^4.2.1",
-    "jest": "^29.5.0",
-    "jest-environment-node": "^29.6.4",
+    "eslint": "^9.34.0",
     "prettier": "^2.8.3",
-    "release-it": "^18.1.2",
+    "release-it": "^19.0.4",
+    "release-it-pnpm": "^4.6.6",
     "rimraf": "^5.0.1",
-    "ts-jest": "^29.1.0",
-    "typescript": "~5.8.3"
+    "typescript": "~5.8.3",
+    "uuid": "^11.1.0",
+    "vitest": "^3.2.4",
+    "zod-to-json-schema": "^3.24.6",
+    "@langchain/standard-tests": "0.0.0",
+    "@langchain/eslint": "0.1.0",
+    "@langchain/core": "1.0.0-alpha.6"
   },
   "publishConfig": {
     "access": "public"
@@ -83,23 +58,39 @@
     "embeddings",
     "vectorstores"
   ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": {
-        "import": "./index.d.ts",
-        "require": "./index.d.cts",
-        "default": "./index.d.ts"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
       },
-      "import": "./index.js",
-      "require": "./index.cjs"
+      "input": "./src/index.ts"
     },
     "./package.json": "./package.json"
   },
   "files": [
-    "dist/",
-    "index.cjs",
-    "index.js",
-    "index.d.ts",
-    "index.d.cts"
-  ]
-}
+    "dist/"
+  ],
+  "scripts": {
+    "build": "pnpm --filter @langchain/build compile @langchain/openai",
+    "lint:eslint": "eslint --cache src/",
+    "lint:dpdm": "dpdm --skip-dynamic-imports circular --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts",
+    "lint": "pnpm lint:eslint && pnpm lint:dpdm",
+    "lint:fix": "pnpm lint:eslint --fix && pnpm lint:dpdm",
+    "clean": "rm -rf .turbo dist/",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:int": "vitest run --mode int",
+    "test:standard:unit": "vitest run --mode standard-unit",
+    "test:standard:int": "vitest run --mode standard-int",
+    "test:standard": "pnpm test:standard:unit && pnpm test:standard:int",
+    "format": "prettier --config .prettierrc --write \"src\"",
+    "format:check": "prettier --config .prettierrc --check \"src\""
+  }
+}

package/dist/tools/index.d.ts

@@ -1 +0,0 @@
-export * from "./dalle.js";

package/dist/types.cjs

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/errors.d.ts

@@ -1,2 +0,0 @@
-export type LangChainErrorCodes = "INVALID_PROMPT_INPUT" | "INVALID_TOOL_RESULTS" | "MESSAGE_COERCION_FAILURE" | "MODEL_AUTHENTICATION" | "MODEL_NOT_FOUND" | "MODEL_RATE_LIMIT" | "OUTPUT_PARSING_FAILURE";
-export declare function addLangChainErrorFields(error: any, lc_error_code: LangChainErrorCodes): any;

package/dist/utils/headers.cjs

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isHeaders = isHeaders;
-exports.normalizeHeaders = normalizeHeaders;
-const iife = (fn) => fn();
-function isHeaders(headers) {
-    return (typeof Headers !== "undefined" &&
-        headers !== null &&
-        typeof headers === "object" &&
-        Object.prototype.toString.call(headers) === "[object Headers]");
-}
-function normalizeHeaders(headers) {
-    const output = iife(() => {
-        // If headers is a Headers instance
-        if (isHeaders(headers)) {
-            return headers;
-        }
-        // If headers is an array of [key, value] pairs
-        else if (Array.isArray(headers)) {
-            return new Headers(headers);
-        }
-        // If headers is a NullableHeaders-like object (has 'values' property that is a Headers)
-        else if (typeof headers === "object" &&
-            headers !== null &&
-            "values" in headers &&
-            isHeaders(headers.values)) {
-            return headers.values;
-        }
-        // If headers is a plain object
-        else if (typeof headers === "object" && headers !== null) {
-            const entries = Object.entries(headers)
-                .filter(([, v]) => typeof v === "string")
-                .map(([k, v]) => [k, v]);
-            return new Headers(entries);
-        }
-        return new Headers();
-    });
-    return Object.fromEntries(output.entries());
-}

package/dist/utils/headers.d.ts

@@ -1,8 +0,0 @@
-type HeaderValue = string | undefined | null;
-export type HeadersLike = Headers | readonly HeaderValue[][] | Record<string, HeaderValue | readonly HeaderValue[]> | undefined | null | {
-    values: Headers;
-    [key: string]: unknown;
-};
-export declare function isHeaders(headers: unknown): headers is Headers;
-export declare function normalizeHeaders(headers: HeadersLike): Record<string, HeaderValue | readonly HeaderValue[]>;
-export {};

package/dist/utils/headers.js

@@ -1,35 +0,0 @@
-const iife = (fn) => fn();
-export function isHeaders(headers) {
-    return (typeof Headers !== "undefined" &&
-        headers !== null &&
-        typeof headers === "object" &&
-        Object.prototype.toString.call(headers) === "[object Headers]");
-}
-export function normalizeHeaders(headers) {
-    const output = iife(() => {
-        // If headers is a Headers instance
-        if (isHeaders(headers)) {
-            return headers;
-        }
-        // If headers is an array of [key, value] pairs
-        else if (Array.isArray(headers)) {
-            return new Headers(headers);
-        }
-        // If headers is a NullableHeaders-like object (has 'values' property that is a Headers)
-        else if (typeof headers === "object" &&
-            headers !== null &&
-            "values" in headers &&
-            isHeaders(headers.values)) {
-            return headers.values;
-        }
-        // If headers is a plain object
-        else if (typeof headers === "object" && headers !== null) {
-            const entries = Object.entries(headers)
-                .filter(([, v]) => typeof v === "string")
-                .map(([k, v]) => [k, v]);
-            return new Headers(entries);
-        }
-        return new Headers();
-    });
-    return Object.fromEntries(output.entries());
-}

package/dist/utils/openai-format-fndef.cjs

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatFunctionDefinitions = formatFunctionDefinitions;
-function isAnyOfProp(prop) {
-    return (prop.anyOf !== undefined &&
-        Array.isArray(prop.anyOf));
-}
-// When OpenAI use functions in the prompt, they format them as TypeScript definitions rather than OpenAPI JSON schemas.
-// This function converts the JSON schemas into TypeScript definitions.
-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");
-}
-// Format just the properties of an object (not including the surrounding braces)
-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");
-}
-// Format a single property type
-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 "";
-    }
-}