@langchain/openai 0.5.11 → 0.5.13

package/dist/azure/chat_models.d.ts

@@ -3,7 +3,7 @@ import { LangSmithParams, type BaseChatModelParams } from "@langchain/core/langu
 import { BaseLanguageModelInput } from "@langchain/core/language_models/base";
 import { BaseMessage } from "@langchain/core/messages";
 import { Runnable } from "@langchain/core/runnables";
-import { z } from "zod";
+import { InteropZodType } from "@langchain/core/utils/types";
 import { ChatOpenAI, ChatOpenAIStructuredOutputMethodOptions } from "../chat_models.js";
 import { AzureOpenAIInput, OpenAIChatInput, OpenAICoreRequestOptions } from "../types.js";
 export type { AzureOpenAIInput };
@@ -444,12 +444,12 @@ export declare class AzureChatOpenAI extends ChatOpenAI {
     getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
     protected _getClientOptions(options: OpenAICoreRequestOptions | undefined): OpenAICoreRequestOptions;
     toJSON(): any;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;
         parsed: RunOutput;
     }>;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<boolean>): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<boolean>): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;
         parsed: RunOutput;
     }>;

package/dist/chat_models.cjs

@@ -1,6 +1,30 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatOpenAI = exports._convertMessagesToOpenAIParams = exports.messageToOpenAIRole = void 0;
+const z4 = __importStar(require("zod/v4/core"));
 const openai_1 = require("openai");
 const messages_1 = require("@langchain/core/messages");
 const outputs_1 = require("@langchain/core/outputs");
@@ -10,8 +34,9 @@ const base_1 = require("@langchain/core/language_models/base");
 const runnables_1 = require("@langchain/core/runnables");
 const output_parsers_1 = require("@langchain/core/output_parsers");
 const openai_tools_1 = require("@langchain/core/output_parsers/openai_tools");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
 const zod_1 = require("openai/helpers/zod");
+const types_1 = require("@langchain/core/utils/types");
+const json_schema_1 = require("@langchain/core/utils/json_schema");
 const azure_js_1 = require("./utils/azure.cjs");
 const openai_js_1 = require("./utils/openai.cjs");
 const openai_format_fndef_js_1 = require("./utils/openai-format-fndef.cjs");
@@ -300,7 +325,7 @@ function _convertMessagesToOpenAIResponsesParams(messages, model, zdrEnabled) {
             return {
                 type: "function_call_output",
                 call_id: toolMessage.tool_call_id,
-                id: toolMessage.id,
+                id: toolMessage.id?.startsWith("fc_") ? toolMessage.id : undefined,
                 output: typeof toolMessage.content !== "string"
                     ? JSON.stringify(toolMessage.content)
                     : toolMessage.content,
@@ -1587,8 +1612,8 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
         if (resFormat &&
             resFormat.type === "json_schema" &&
             resFormat.json_schema.schema &&
-            isZodSchema(resFormat.json_schema.schema)) {
-            return (0, zod_1.zodResponseFormat)(resFormat.json_schema.schema, resFormat.json_schema.name, {
+            (0, types_1.isInteropZodSchema)(resFormat.json_schema.schema)) {
+            return interopZodResponseFormat(resFormat.json_schema.schema, resFormat.json_schema.name, {
                 description: resFormat.json_schema.description,
             });
         }
@@ -2461,7 +2486,7 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
             llm = this.withConfig({
                 response_format: { type: "json_object" },
             });
-            if (isZodSchema(schema)) {
+            if ((0, types_1.isInteropZodSchema)(schema)) {
                 outputParser = output_parsers_1.StructuredOutputParser.fromZodSchema(schema);
             }
             else {
@@ -2474,13 +2499,13 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
                     type: "json_schema",
                     json_schema: {
                         name: name ?? "extract",
-                        description: schema.description,
+                        description: (0, types_1.getSchemaDescription)(schema),
                         schema,
                         strict: config?.strict,
                     },
                 },
             });
-            if (isZodSchema(schema)) {
+            if ((0, types_1.isInteropZodSchema)(schema)) {
                 const altParser = output_parsers_1.StructuredOutputParser.fromZodSchema(schema);
                 outputParser = runnables_1.RunnableLambda.from((aiMessage) => {
                     if ("parsed" in aiMessage.additional_kwargs) {
@@ -2496,8 +2521,8 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
         else {
             let functionName = name ?? "extract";
             // Is function calling
-            if (isZodSchema(schema)) {
-                const asJsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(schema);
+            if ((0, types_1.isInteropZodSchema)(schema)) {
+                const asJsonSchema = (0, json_schema_1.toJsonSchema)(schema);
                 llm = this.withConfig({
                     tools: [
                         {
@@ -2579,12 +2604,6 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
     }
 }
 exports.ChatOpenAI = ChatOpenAI;
-function isZodSchema(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-input) {
-    // Check for a characteristic method of Zod schemas
-    return typeof input?.parse === "function";
-}
 function isStructuredOutputMethodParams(x
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) {
@@ -2593,3 +2612,49 @@ function isStructuredOutputMethodParams(x
         typeof x.schema ===
             "object");
 }
+// inlined from openai/lib/parser.ts
+function makeParseableResponseFormat(response_format, parser) {
+    const obj = { ...response_format };
+    Object.defineProperties(obj, {
+        $brand: {
+            value: "auto-parseable-response-format",
+            enumerable: false,
+        },
+        $parseRaw: {
+            value: parser,
+            enumerable: false,
+        },
+    });
+    return obj;
+}
+function interopZodResponseFormat(zodSchema, name, props) {
+    if ((0, types_1.isZodSchemaV3)(zodSchema)) {
+        return (0, zod_1.zodResponseFormat)(zodSchema, name, props);
+    }
+    if ((0, types_1.isZodSchemaV4)(zodSchema)) {
+        return makeParseableResponseFormat({
+            type: "json_schema",
+            json_schema: {
+                ...props,
+                name,
+                strict: true,
+                schema: z4.toJSONSchema(zodSchema, {
+                    cycles: "ref",
+                    reused: "ref",
+                    override(ctx) {
+                        ctx.jsonSchema.title = name; // equivalent to `name` property
+                        // TODO: implement `nullableStrategy` patch-fix (zod doesn't support openApi3 json schema target)
+                        // TODO: implement `openaiStrictMode` patch-fix (where optional properties without `nullable` are not supported)
+                    },
+                    /// property equivalents from native `zodResponseFormat` fn
+                    // openaiStrictMode: true,
+                    // name,
+                    // nameStrategy: 'duplicate-ref',
+                    // $refStrategy: 'extract-to-root',
+                    // nullableStrategy: 'property',
+                }),
+            },
+        }, (content) => z4.parse(zodSchema, JSON.parse(content)));
+    }
+    throw new Error("Unsupported schema response format");
+}

package/dist/chat_models.d.ts

@@ -4,8 +4,8 @@ import { AIMessageChunk, type BaseMessage, ChatMessageChunk, FunctionMessageChun
 import { ChatGenerationChunk, type ChatResult } from "@langchain/core/outputs";
 import { BaseChatModel, type BindToolsInput, type LangSmithParams, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
 import { type BaseFunctionCallOptions, type BaseLanguageModelInput, type StructuredOutputMethodOptions } from "@langchain/core/language_models/base";
-import { z } from "zod";
 import { Runnable } from "@langchain/core/runnables";
+import { InteropZodType } from "@langchain/core/utils/types";
 import { type OpenAICallOptions, type OpenAIChatInput, type OpenAICoreRequestOptions, type ChatOpenAIResponseFormat } from "./types.js";
 import { OpenAIToolChoice } from "./utils/openai.js";
 export type { OpenAICallOptions, OpenAIChatInput };
@@ -846,12 +846,12 @@ export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = Chat
     _llmType(): string;
     /** @ignore */
     _combineLLMOutput(...llmOutputs: OpenAILLMOutput[]): OpenAILLMOutput;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;
         parsed: RunOutput;
     }>;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<boolean>): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<boolean>): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;
         parsed: RunOutput;
     }>;

package/dist/chat_models.js

@@ -1,3 +1,4 @@
+import * as z4 from "zod/v4/core";
 import { OpenAI as OpenAIClient } from "openai";
 import { AIMessage, AIMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessageChunk, HumanMessageChunk, SystemMessageChunk, ToolMessageChunk, isAIMessage, parseBase64DataUrl, parseMimeType, convertToProviderContentBlock, isDataContentBlock, } from "@langchain/core/messages";
 import { ChatGenerationChunk, } from "@langchain/core/outputs";
@@ -7,8 +8,9 @@ import { isOpenAITool, } from "@langchain/core/language_models/base";
 import { RunnableLambda, RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnables";
 import { JsonOutputParser, StructuredOutputParser, } from "@langchain/core/output_parsers";
 import { JsonOutputKeyToolsParser, convertLangChainToolCallToOpenAI, makeInvalidToolCall, parseToolCall, } from "@langchain/core/output_parsers/openai_tools";
-import { zodToJsonSchema } from "zod-to-json-schema";
 import { zodResponseFormat } from "openai/helpers/zod";
+import { getSchemaDescription, isInteropZodSchema, isZodSchemaV3, isZodSchemaV4, } from "@langchain/core/utils/types";
+import { toJsonSchema } from "@langchain/core/utils/json_schema";
 import { getEndpoint } from "./utils/azure.js";
 import { formatToOpenAIToolChoice, wrapOpenAIClientError, } from "./utils/openai.js";
 import { formatFunctionDefinitions, } from "./utils/openai-format-fndef.js";
@@ -295,7 +297,7 @@ function _convertMessagesToOpenAIResponsesParams(messages, model, zdrEnabled) {
             return {
                 type: "function_call_output",
                 call_id: toolMessage.tool_call_id,
-                id: toolMessage.id,
+                id: toolMessage.id?.startsWith("fc_") ? toolMessage.id : undefined,
                 output: typeof toolMessage.content !== "string"
                     ? JSON.stringify(toolMessage.content)
                     : toolMessage.content,
@@ -1582,8 +1584,8 @@ export class ChatOpenAI extends BaseChatModel {
         if (resFormat &&
             resFormat.type === "json_schema" &&
             resFormat.json_schema.schema &&
-            isZodSchema(resFormat.json_schema.schema)) {
-            return zodResponseFormat(resFormat.json_schema.schema, resFormat.json_schema.name, {
+            isInteropZodSchema(resFormat.json_schema.schema)) {
+            return interopZodResponseFormat(resFormat.json_schema.schema, resFormat.json_schema.name, {
                 description: resFormat.json_schema.description,
             });
         }
@@ -2456,7 +2458,7 @@ export class ChatOpenAI extends BaseChatModel {
             llm = this.withConfig({
                 response_format: { type: "json_object" },
             });
-            if (isZodSchema(schema)) {
+            if (isInteropZodSchema(schema)) {
                 outputParser = StructuredOutputParser.fromZodSchema(schema);
             }
             else {
@@ -2469,13 +2471,13 @@ export class ChatOpenAI extends BaseChatModel {
                     type: "json_schema",
                     json_schema: {
                         name: name ?? "extract",
-                        description: schema.description,
+                        description: getSchemaDescription(schema),
                         schema,
                         strict: config?.strict,
                     },
                 },
             });
-            if (isZodSchema(schema)) {
+            if (isInteropZodSchema(schema)) {
                 const altParser = StructuredOutputParser.fromZodSchema(schema);
                 outputParser = RunnableLambda.from((aiMessage) => {
                     if ("parsed" in aiMessage.additional_kwargs) {
@@ -2491,8 +2493,8 @@ export class ChatOpenAI extends BaseChatModel {
         else {
             let functionName = name ?? "extract";
             // Is function calling
-            if (isZodSchema(schema)) {
-                const asJsonSchema = zodToJsonSchema(schema);
+            if (isInteropZodSchema(schema)) {
+                const asJsonSchema = toJsonSchema(schema);
                 llm = this.withConfig({
                     tools: [
                         {
@@ -2573,12 +2575,6 @@ export class ChatOpenAI extends BaseChatModel {
         return RunnableSequence.from([{ raw: llm }, parsedWithFallback]);
     }
 }
-function isZodSchema(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-input) {
-    // Check for a characteristic method of Zod schemas
-    return typeof input?.parse === "function";
-}
 function isStructuredOutputMethodParams(x
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) {
@@ -2587,3 +2583,49 @@ function isStructuredOutputMethodParams(x
         typeof x.schema ===
             "object");
 }
+// inlined from openai/lib/parser.ts
+function makeParseableResponseFormat(response_format, parser) {
+    const obj = { ...response_format };
+    Object.defineProperties(obj, {
+        $brand: {
+            value: "auto-parseable-response-format",
+            enumerable: false,
+        },
+        $parseRaw: {
+            value: parser,
+            enumerable: false,
+        },
+    });
+    return obj;
+}
+function interopZodResponseFormat(zodSchema, name, props) {
+    if (isZodSchemaV3(zodSchema)) {
+        return zodResponseFormat(zodSchema, name, props);
+    }
+    if (isZodSchemaV4(zodSchema)) {
+        return makeParseableResponseFormat({
+            type: "json_schema",
+            json_schema: {
+                ...props,
+                name,
+                strict: true,
+                schema: z4.toJSONSchema(zodSchema, {
+                    cycles: "ref",
+                    reused: "ref",
+                    override(ctx) {
+                        ctx.jsonSchema.title = name; // equivalent to `name` property
+                        // TODO: implement `nullableStrategy` patch-fix (zod doesn't support openApi3 json schema target)
+                        // TODO: implement `openaiStrictMode` patch-fix (where optional properties without `nullable` are not supported)
+                    },
+                    /// property equivalents from native `zodResponseFormat` fn
+                    // openaiStrictMode: true,
+                    // name,
+                    // nameStrategy: 'duplicate-ref',
+                    // $refStrategy: 'extract-to-root',
+                    // nullableStrategy: 'property',
+                }),
+            },
+        }, (content) => z4.parse(zodSchema, JSON.parse(content)));
+    }
+    throw new Error("Unsupported schema response format");
+}

package/dist/types.d.ts

@@ -3,7 +3,7 @@ import type { RequestOptions as _OpenAICoreRequestOptions } from "openai/core";
 import type { ResponseFormatText, ResponseFormatJSONObject, ResponseFormatJSONSchema } from "openai/resources/shared";
 import { TiktokenModel } from "js-tiktoken/lite";
 import type { BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
-import type { z } from "zod";
+import { InteropZodObject } from "@langchain/core/utils/types";
 export type { TiktokenModel };
 export declare interface OpenAIBaseInput {
     /** Sampling temperature to use */
@@ -218,7 +218,7 @@ type ChatOpenAIResponseFormatJSONSchema = Omit<ResponseFormatJSONSchema, "json_s
          * The schema for the response format, described as a JSON Schema object
          * or a Zod object.
          */
-        schema: Record<string, any> | z.ZodObject<any, any, any, any>;
+        schema: Record<string, any> | InteropZodObject;
     };
 };
 /**

package/dist/utils/openai.cjs

@@ -5,8 +5,8 @@ const openai_1 = require("openai");
 const function_calling_1 = require("@langchain/core/utils/function_calling");
 Object.defineProperty(exports, "formatToOpenAIFunction", { enumerable: true, get: function () { return function_calling_1.convertToOpenAIFunction; } });
 Object.defineProperty(exports, "formatToOpenAITool", { enumerable: true, get: function () { return function_calling_1.convertToOpenAITool; } });
-const zod_to_json_schema_1 = require("zod-to-json-schema");
 const types_1 = require("@langchain/core/utils/types");
+const json_schema_1 = require("@langchain/core/utils/json_schema");
 const errors_js_1 = require("./errors.cjs");
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function wrapOpenAIClientError(e) {
@@ -43,8 +43,8 @@ function formatToOpenAIAssistantTool(tool) {
         function: {
             name: tool.name,
             description: tool.description,
-            parameters: (0, types_1.isZodSchema)(tool.schema)
-                ? (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema)
+            parameters: (0, types_1.isInteropZodSchema)(tool.schema)
+                ? (0, json_schema_1.toJsonSchema)(tool.schema)
                 : tool.schema,
         },
     };

package/dist/utils/openai.js

@@ -1,7 +1,7 @@
 import { APIConnectionTimeoutError, APIUserAbortError, } from "openai";
 import { convertToOpenAIFunction, convertToOpenAITool, } from "@langchain/core/utils/function_calling";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { isZodSchema } from "@langchain/core/utils/types";
+import { isInteropZodSchema } from "@langchain/core/utils/types";
+import { toJsonSchema } from "@langchain/core/utils/json_schema";
 import { addLangChainErrorFields } from "./errors.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function wrapOpenAIClientError(e) {
@@ -38,8 +38,8 @@ export function formatToOpenAIAssistantTool(tool) {
         function: {
             name: tool.name,
             description: tool.description,
-            parameters: isZodSchema(tool.schema)
-                ? zodToJsonSchema(tool.schema)
+            parameters: isInteropZodSchema(tool.schema)
+                ? toJsonSchema(tool.schema)
                 : tool.schema,
         },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/openai",
-  "version": "0.5.11",
+  "version": "0.5.13",
   "description": "OpenAI integrations for LangChain.js",
   "type": "module",
   "engines": {
@@ -37,11 +37,10 @@
   "dependencies": {
     "js-tiktoken": "^1.0.12",
     "openai": "^4.96.0",
-    "zod": "^3.22.4",
-    "zod-to-json-schema": "^3.22.3"
+    "zod": "3.25.32"
   },
   "peerDependencies": {
-    "@langchain/core": ">=0.3.48 <0.4.0"
+    "@langchain/core": ">=0.3.58 <0.4.0"
   },
   "devDependencies": {
     "@azure/identity": "^4.2.1",
@@ -55,7 +54,7 @@
     "eslint": "^8.33.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^8.6.0",
-    "eslint-plugin-import": "^2.27.5",
+    "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",