@langchain/openai 0.5.12 → 0.5.14

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";
@@ -134,7 +136,7 @@ const completionsApiContentBlockConverter = {
             return {
                 type: "file",
                 file: {
-                    file_data: block.url,
+                    file_data: block.url, // formatted as base64 data URL
                     ...(block.metadata?.filename || block.metadata?.name
                         ? {
                             filename: (block.metadata?.filename ||
@@ -247,12 +249,8 @@ function _convertReasoningSummaryToOpenAIResponsesParams(reasoning) {
     };
 }
 function _convertMessagesToOpenAIResponsesParams(messages, model, zdrEnabled) {
-    const lastAIMessage = messages.filter((m) => isAIMessage(m)).pop();
-    const lastAIMessageId = lastAIMessage?.response_metadata?.id;
-    const newMessages = lastAIMessageId && lastAIMessageId.startsWith("resp_") && !zdrEnabled
-        ? messages.slice(messages.indexOf(lastAIMessage) + 1)
-        : messages;
-    return newMessages.flatMap((lcMsg) => {
+    return messages.flatMap((lcMsg) => {
+        const additional_kwargs = lcMsg.additional_kwargs;
         let role = messageToOpenAIRole(lcMsg);
         if (role === "system" && isReasoningModel(model))
             role = "developer";
@@ -262,7 +260,7 @@ function _convertMessagesToOpenAIResponsesParams(messages, model, zdrEnabled) {
         if (role === "tool") {
             const toolMessage = lcMsg;
             // Handle computer call output
-            if (toolMessage.additional_kwargs?.type === "computer_call_output") {
+            if (additional_kwargs?.type === "computer_call_output") {
                 const output = (() => {
                     if (typeof toolMessage.content === "string") {
                         return {
@@ -313,25 +311,19 @@ function _convertMessagesToOpenAIResponsesParams(messages, model, zdrEnabled) {
             // otherwise, try to reconstruct the response from what we have
             const input = [];
             // reasoning items
-            if (!zdrEnabled && lcMsg.additional_kwargs.reasoning != null) {
-                const isReasoningItem = (item) => typeof item === "object" &&
-                    item != null &&
-                    "type" in item &&
-                    item.type === "reasoning";
-                if (isReasoningItem(lcMsg.additional_kwargs.reasoning)) {
-                    const reasoningItem = _convertReasoningSummaryToOpenAIResponsesParams(lcMsg.additional_kwargs.reasoning);
-                    input.push(reasoningItem);
-                }
+            if (additional_kwargs?.reasoning && !zdrEnabled) {
+                const reasoningItem = _convertReasoningSummaryToOpenAIResponsesParams(additional_kwargs.reasoning);
+                input.push(reasoningItem);
             }
             // ai content
             let { content } = lcMsg;
-            if (lcMsg.additional_kwargs.refusal != null) {
+            if (additional_kwargs?.refusal) {
                 if (typeof content === "string") {
                     content = [{ type: "output_text", text: content, annotations: [] }];
                 }
                 content = [
                     ...content,
-                    { type: "refusal", refusal: lcMsg.additional_kwargs.refusal },
+                    { type: "refusal", refusal: additional_kwargs.refusal },
                 ];
             }
             input.push({
@@ -355,10 +347,7 @@ function _convertMessagesToOpenAIResponsesParams(messages, model, zdrEnabled) {
                         return [];
                     }),
             });
-            // function tool calls and computer use tool calls
-            const functionCallIds = 
-            // eslint-disable-next-line @typescript-eslint/no-use-before-define
-            lcMsg.additional_kwargs[_FUNCTION_CALL_IDS_MAP_KEY];
+            const functionCallIds = additional_kwargs?.[_FUNCTION_CALL_IDS_MAP_KEY];
             if (isAIMessage(lcMsg) && !!lcMsg.tool_calls?.length) {
                 input.push(...lcMsg.tool_calls.map((toolCall) => ({
                     type: "function_call",
@@ -368,44 +357,64 @@ function _convertMessagesToOpenAIResponsesParams(messages, model, zdrEnabled) {
                     ...(zdrEnabled ? { id: functionCallIds?.[toolCall.id] } : {}),
                 })));
             }
-            else if (lcMsg.additional_kwargs.tool_calls != null) {
-                input.push(...lcMsg.additional_kwargs.tool_calls.map((toolCall) => ({
+            else if (additional_kwargs?.tool_calls) {
+                input.push(...additional_kwargs.tool_calls.map((toolCall) => ({
                     type: "function_call",
                     name: toolCall.function.name,
                     call_id: toolCall.id,
-                    ...(zdrEnabled ? { id: functionCallIds?.[toolCall.id] } : {}),
                     arguments: toolCall.function.arguments,
+                    ...(zdrEnabled ? { id: functionCallIds?.[toolCall.id] } : {}),
                 })));
             }
             const toolOutputs = lcMsg.response_metadata.output?.length
                 ? lcMsg.response_metadata.output
-                : lcMsg.additional_kwargs.tool_outputs;
-            let computerCalls = [];
+                : additional_kwargs.tool_outputs;
+            const fallthroughCallTypes = [
+                "computer_call",
+                "mcp_call",
+                "code_interpreter_call",
+                "image_generation_call",
+            ];
             if (toolOutputs != null) {
                 const castToolOutputs = toolOutputs;
-                computerCalls = castToolOutputs?.filter((item) => item.type === "computer_call");
-                if (computerCalls.length > 0)
-                    input.push(...computerCalls);
+                const fallthroughCalls = castToolOutputs?.filter((item) => fallthroughCallTypes.includes(item.type));
+                if (fallthroughCalls.length > 0)
+                    input.push(...fallthroughCalls);
             }
             return input;
         }
-        const content = typeof lcMsg.content === "string"
-            ? lcMsg.content
-            : lcMsg.content.flatMap((item) => {
+        if (role === "user" || role === "system" || role === "developer") {
+            if (typeof lcMsg.content === "string") {
+                return { type: "message", role, content: lcMsg.content };
+            }
+            const messages = [];
+            const content = lcMsg.content.flatMap((item) => {
+                if (item.type === "mcp_approval_response") {
+                    messages.push({
+                        type: "mcp_approval_response",
+                        approval_request_id: item.approval_request_id,
+                        approve: item.approve,
+                    });
+                }
                 if (isDataContentBlock(item)) {
                     return convertToProviderContentBlock(item, completionsApiContentBlockConverter);
                 }
                 if (item.type === "text") {
-                    return { type: "input_text", text: item.text };
+                    return {
+                        type: "input_text",
+                        text: item.text,
+                    };
                 }
                 if (item.type === "image_url") {
-                    const image_url = typeof item.image_url === "string"
-                        ? item.image_url
-                        : item.image_url.url;
-                    const detail = typeof item.image_url === "string"
-                        ? "auto"
-                        : item.image_url.detail;
-                    return { type: "input_image", image_url, detail };
+                    return {
+                        type: "input_image",
+                        image_url: typeof item.image_url === "string"
+                            ? item.image_url
+                            : item.image_url.url,
+                        detail: typeof item.image_url === "string"
+                            ? "auto"
+                            : item.image_url.detail,
+                    };
                 }
                 if (item.type === "input_text" ||
                     item.type === "input_image" ||
@@ -414,8 +423,10 @@ function _convertMessagesToOpenAIResponsesParams(messages, model, zdrEnabled) {
                 }
                 return [];
             });
-        if (role === "user" || role === "system" || role === "developer") {
-            return { type: "message", role, content };
+            if (content.length > 0) {
+                messages.push({ type: "message", role, content });
+            }
+            return messages;
         }
         console.warn(`Unsupported role found when converting to OpenAI Responses API: ${role}`);
         return [];
@@ -522,7 +533,7 @@ function _convertOpenAIResponsesDeltaToBaseMessageChunk(chunk) {
             index: chunk.content_index,
         });
     }
-    else if (chunk.type === "response.output_text.annotation.added") {
+    else if (chunk.type === "response.output_text_annotation.added") {
         content.push({
             type: "text",
             text: "",
@@ -548,9 +559,16 @@ function _convertOpenAIResponsesDeltaToBaseMessageChunk(chunk) {
         };
     }
     else if (chunk.type === "response.output_item.done" &&
-        (chunk.item.type === "web_search_call" ||
-            chunk.item.type === "file_search_call" ||
-            chunk.item.type === "computer_call")) {
+        [
+            "web_search_call",
+            "file_search_call",
+            "computer_call",
+            "code_interpreter_call",
+            "mcp_call",
+            "mcp_list_tools",
+            "mcp_approval_request",
+            "image_generation_call",
+        ].includes(chunk.item.type)) {
         additional_kwargs.tool_outputs = [chunk.item];
     }
     else if (chunk.type === "response.created") {
@@ -622,6 +640,11 @@ function _convertOpenAIResponsesDeltaToBaseMessageChunk(chunk) {
             ],
         };
     }
+    else if (chunk.type === "response.image_generation_call.partial_image") {
+        // noop/fixme: retaining partial images in a message chunk means that _all_
+        // partial images get kept in history, so we don't do anything here.
+        return null;
+    }
     else {
         return null;
     }
@@ -648,6 +671,29 @@ function isBuiltInToolChoice(tool_choice) {
         "type" in tool_choice &&
         tool_choice.type !== "function");
 }
+function _reduceChatOpenAIToolsForResponses(tools, fields) {
+    const reducedTools = [];
+    for (const tool of tools) {
+        if (isBuiltInTool(tool)) {
+            if (tool.type === "image_generation" && fields?.stream) {
+                // OpenAI sends a 400 error if partial_images is not set and we want to stream.
+                // We also set it to 1 since we don't support partial images yet.
+                tool.partial_images = 1;
+            }
+            reducedTools.push(tool);
+        }
+        else if (isOpenAITool(tool)) {
+            reducedTools.push({
+                type: "function",
+                name: tool.function.name,
+                parameters: tool.function.parameters,
+                description: tool.function.description,
+                strict: fields?.strict ?? null,
+            });
+        }
+    }
+    return reducedTools;
+}
 function _convertChatOpenAIToolTypeToOpenAITool(tool, fields) {
     if (isOpenAITool(tool)) {
         if (fields?.strict !== undefined) {
@@ -1582,8 +1628,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,
             });
         }
@@ -1641,25 +1687,10 @@ export class ChatOpenAI extends BaseChatModel {
                 truncation: options?.truncation,
                 include: options?.include,
                 tools: options?.tools?.length
-                    ? options.tools
-                        .map((tool) => {
-                        if (isBuiltInTool(tool)) {
-                            return tool;
-                        }
-                        else if (isOpenAITool(tool)) {
-                            return {
-                                type: "function",
-                                name: tool.function.name,
-                                parameters: tool.function.parameters,
-                                description: tool.function.description,
-                                strict,
-                            };
-                        }
-                        else {
-                            return null;
-                        }
+                    ? _reduceChatOpenAIToolsForResponses(options.tools, {
+                        stream: this.streaming,
+                        strict,
                     })
-                        .filter((tool) => tool !== null)
                     : undefined,
                 tool_choice: isBuiltInToolChoice(options?.tool_choice)
                     ? options?.tool_choice
@@ -1902,17 +1933,10 @@ export class ChatOpenAI extends BaseChatModel {
     }
     async *_streamResponseChunks(messages, options, runManager) {
         if (this._useResponseApi(options)) {
-            const lastAIMessage = messages.filter((m) => isAIMessage(m)).pop();
-            const lastAIMessageId = lastAIMessage?.response_metadata?.id;
             const streamIterable = await this.responseApiWithRetry({
                 ...this.invocationParams(options, { streaming: true }),
                 input: _convertMessagesToOpenAIResponsesParams(messages, this.model, this.zdrEnabled),
                 stream: true,
-                ...(lastAIMessageId &&
-                    lastAIMessageId.startsWith("resp_") &&
-                    !this.zdrEnabled
-                    ? { previous_response_id: lastAIMessageId }
-                    : {}),
             }, options);
             for await (const data of streamIterable) {
                 const chunk = _convertOpenAIResponsesDeltaToBaseMessageChunk(data);
@@ -2046,17 +2070,10 @@ export class ChatOpenAI extends BaseChatModel {
                 },
             };
         }
-        const lastAIMessage = messages.filter((m) => isAIMessage(m)).pop();
-        const lastAIMessageId = lastAIMessage?.response_metadata?.id;
         const input = _convertMessagesToOpenAIResponsesParams(messages, this.model, this.zdrEnabled);
         const data = await this.responseApiWithRetry({
             input,
             ...invocationParams,
-            ...(lastAIMessageId &&
-                lastAIMessageId.startsWith("resp_") &&
-                !this.zdrEnabled
-                ? { previous_response_id: lastAIMessageId }
-                : {}),
         }, { signal: options?.signal, ...options?.options });
         return {
             generations: [
@@ -2366,7 +2383,7 @@ export class ChatOpenAI extends BaseChatModel {
         const requestOptions = this._getClientOptions(options);
         return this.caller.call(async () => {
             try {
-                const res = await this.client.beta.chat.completions.parse(request, requestOptions);
+                const res = await this.client.chat.completions.parse(request, requestOptions);
                 return res;
             }
             catch (e) {
@@ -2453,15 +2470,21 @@ export class ChatOpenAI extends BaseChatModel {
             console.warn(`[WARNING]: JSON Schema is not supported for model "${this.model}". Falling back to tool calling.`);
         }
         if (method === "jsonMode") {
-            llm = this.withConfig({
-                response_format: { type: "json_object" },
-            });
-            if (isZodSchema(schema)) {
+            let outputFormatSchema;
+            if (isInteropZodSchema(schema)) {
                 outputParser = StructuredOutputParser.fromZodSchema(schema);
+                outputFormatSchema = toJsonSchema(schema);
             }
             else {
                 outputParser = new JsonOutputParser();
             }
+            llm = this.withConfig({
+                response_format: { type: "json_object" },
+                ls_structured_output_format: {
+                    kwargs: { method: "jsonMode" },
+                    schema: outputFormatSchema,
+                },
+            });
         }
         else if (method === "jsonSchema") {
             llm = this.withConfig({
@@ -2469,13 +2492,17 @@ export class ChatOpenAI extends BaseChatModel {
                     type: "json_schema",
                     json_schema: {
                         name: name ?? "extract",
-                        description: schema.description,
+                        description: getSchemaDescription(schema),
                         schema,
                         strict: config?.strict,
                     },
                 },
+                ls_structured_output_format: {
+                    kwargs: { method: "jsonSchema" },
+                    schema: toJsonSchema(schema),
+                },
             });
-            if (isZodSchema(schema)) {
+            if (isInteropZodSchema(schema)) {
                 const altParser = StructuredOutputParser.fromZodSchema(schema);
                 outputParser = RunnableLambda.from((aiMessage) => {
                     if ("parsed" in aiMessage.additional_kwargs) {
@@ -2491,8 +2518,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: [
                         {
@@ -2510,6 +2537,10 @@ export class ChatOpenAI extends BaseChatModel {
                             name: functionName,
                         },
                     },
+                    ls_structured_output_format: {
+                        kwargs: { method: "functionCalling" },
+                        schema: asJsonSchema,
+                    },
                     // Do not pass `strict` argument to OpenAI if `config.strict` is undefined
                     ...(config?.strict !== undefined ? { strict: config.strict } : {}),
                 });
@@ -2548,6 +2579,10 @@ export class ChatOpenAI extends BaseChatModel {
                             name: functionName,
                         },
                     },
+                    ls_structured_output_format: {
+                        kwargs: { method: "functionCalling" },
+                        schema: toJsonSchema(schema),
+                    },
                     // Do not pass `strict` argument to OpenAI if `config.strict` is undefined
                     ...(config?.strict !== undefined ? { strict: config.strict } : {}),
                 });
@@ -2573,12 +2608,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 +2616,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", // equivalent to nameStrategy: 'duplicate-ref'
+                    reused: "ref", // equivalent to $refStrategy: 'extract-to-root'
+                    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/embeddings.d.ts

@@ -1,5 +1,9 @@
 import { type ClientOptions, OpenAI as OpenAIClient } from "openai";
 import { Embeddings, type EmbeddingsParams } from "@langchain/core/embeddings";
+/**
+ * @see https://platform.openai.com/docs/guides/embeddings#embedding-models
+ */
+export type OpenAIEmbeddingModelId = OpenAIClient.EmbeddingModel | (string & NonNullable<unknown>);
 /**
  * Interface for OpenAIEmbeddings parameters. Extends EmbeddingsParams and
  * defines additional parameters specific to the OpenAIEmbeddings class.
@@ -10,9 +14,9 @@ export interface OpenAIEmbeddingsParams extends EmbeddingsParams {
      * Alias for `model`
      * @deprecated Use "model" instead.
      */
-    modelName: string;
+    modelName: OpenAIEmbeddingModelId;
     /** Model name to use */
-    model: string;
+    model: OpenAIEmbeddingModelId;
     /**
      * The number of dimensions the resulting output embeddings should have.
      * Only supported in `text-embedding-3` and later models.
@@ -99,6 +103,6 @@ export declare class OpenAIEmbeddings extends Embeddings implements Partial<Open
      * @returns Promise that resolves to the response from the API.
      */
     protected embeddingWithRetry(request: OpenAIClient.EmbeddingCreateParams): Promise<OpenAIClient.Embeddings.CreateEmbeddingResponse & {
-        _request_id?: string | null | undefined;
+        _request_id?: string | null;
     }>;
 }

package/dist/tools/dalle.d.ts

@@ -1,6 +1,10 @@
 import { OpenAI as OpenAIClient } from "openai";
 import { Tool, ToolParams } from "@langchain/core/tools";
 import { MessageContentComplex } from "@langchain/core/messages";
+/**
+ * @see https://platform.openai.com/docs/api-reference/images/create
+ */
+export type OpenAIImageModelId = OpenAIClient.ImageModel | (string & NonNullable<unknown>);
 /**
  * An interface for the Dall-E API Wrapper.
  */
@@ -19,14 +23,15 @@ export interface DallEAPIWrapperParams extends ToolParams {
      * Alias for `model`
      * @params "dall-e-2" | "dall-e-3"
      * @default "dall-e-3"
+     * @deprecated Use `model` instead.
      */
-    modelName?: string;
+    modelName?: OpenAIImageModelId;
     /**
      * The model to use.
      * @params "dall-e-2" | "dall-e-3"
      * @default "dall-e-3"
      */
-    model?: string;
+    model?: OpenAIImageModelId;
     /**
      * The style of the generated images. Must be one of vivid or natural.
      * Vivid causes the model to lean towards generating hyper-real and dramatic images.

package/dist/types.d.ts

@@ -1,10 +1,13 @@
 import type { OpenAI as OpenAIClient } from "openai";
-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 };
+/**
+ * @see https://platform.openai.com/docs/models
+ */
+export type OpenAIChatModelId = OpenAIClient.ChatModel | (string & NonNullable<unknown>);
 export declare interface OpenAIBaseInput {
     /** Sampling temperature to use */
     temperature: number;
@@ -45,7 +48,7 @@ export declare interface OpenAIBaseInput {
      */
     modelName: string;
     /** Model name to use */
-    model: string;
+    model: OpenAIChatModelId;
     /** Holds any additional parameters that are valid to pass to {@link
      * https://platform.openai.com/docs/api-reference/completions/create |
      * `openai.createCompletion`} that are not explicitly specified on this class.
@@ -74,7 +77,7 @@ export declare interface OpenAIBaseInput {
      */
     apiKey?: string;
 }
-export type OpenAICoreRequestOptions<Req = Record<string, unknown>> = _OpenAICoreRequestOptions<Req>;
+export type OpenAICoreRequestOptions = OpenAIClient.RequestOptions;
 export interface OpenAICallOptions extends BaseLanguageModelCallOptions {
     /**
      * Additional options to pass to the underlying axios request.
@@ -218,7 +221,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/azure.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEndpoint = void 0;
+exports.getEndpoint = getEndpoint;
 /**
  * This function generates an endpoint URL for (Azure) OpenAI
  * based on the configuration parameters provided.
@@ -48,4 +48,3 @@ function getEndpoint(config) {
     }
     return baseURL;
 }
-exports.getEndpoint = getEndpoint;

package/dist/utils/errors.cjs

@@ -2,10 +2,9 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable no-param-reassign */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addLangChainErrorFields = void 0;
+exports.addLangChainErrorFields = addLangChainErrorFields;
 function addLangChainErrorFields(error, lc_error_code) {
     error.lc_error_code = lc_error_code;
     error.message = `${error.message}\n\nTroubleshooting URL: https://js.langchain.com/docs/troubleshooting/errors/${lc_error_code}/\n`;
     return error;
 }
-exports.addLangChainErrorFields = addLangChainErrorFields;

package/dist/utils/headers.cjs

@@ -0,0 +1,39 @@
+"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

@@ -0,0 +1,8 @@
+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 {};