@langchain/openai 0.5.6 → 0.5.8

package/dist/chat_models.cjs

@@ -50,6 +50,132 @@ function messageToOpenAIRole(message) {
     }
 }
 exports.messageToOpenAIRole = messageToOpenAIRole;
+const completionsApiContentBlockConverter = {
+    providerName: "ChatOpenAI",
+    fromStandardTextBlock(block) {
+        return { type: "text", text: block.text };
+    },
+    fromStandardImageBlock(block) {
+        if (block.source_type === "url") {
+            return {
+                type: "image_url",
+                image_url: {
+                    url: block.url,
+                    ...(block.metadata?.detail
+                        ? { detail: block.metadata.detail }
+                        : {}),
+                },
+            };
+        }
+        if (block.source_type === "base64") {
+            const url = `data:${block.mime_type ?? ""};base64,${block.data}`;
+            return {
+                type: "image_url",
+                image_url: {
+                    url,
+                    ...(block.metadata?.detail
+                        ? { detail: block.metadata.detail }
+                        : {}),
+                },
+            };
+        }
+        throw new Error(`Image content blocks with source_type ${block.source_type} are not supported for ChatOpenAI`);
+    },
+    fromStandardAudioBlock(block) {
+        if (block.source_type === "url") {
+            const data = (0, messages_1.parseBase64DataUrl)({ dataUrl: block.url });
+            if (!data) {
+                throw new Error(`URL audio blocks with source_type ${block.source_type} must be formatted as a data URL for ChatOpenAI`);
+            }
+            const rawMimeType = data.mime_type || block.mime_type || "";
+            let mimeType;
+            try {
+                mimeType = (0, messages_1.parseMimeType)(rawMimeType);
+            }
+            catch {
+                throw new Error(`Audio blocks with source_type ${block.source_type} must have mime type of audio/wav or audio/mp3`);
+            }
+            if (mimeType.type !== "audio" ||
+                (mimeType.subtype !== "wav" && mimeType.subtype !== "mp3")) {
+                throw new Error(`Audio blocks with source_type ${block.source_type} must have mime type of audio/wav or audio/mp3`);
+            }
+            return {
+                type: "input_audio",
+                input_audio: {
+                    format: mimeType.subtype,
+                    data: data.data,
+                },
+            };
+        }
+        if (block.source_type === "base64") {
+            let mimeType;
+            try {
+                mimeType = (0, messages_1.parseMimeType)(block.mime_type ?? "");
+            }
+            catch {
+                throw new Error(`Audio blocks with source_type ${block.source_type} must have mime type of audio/wav or audio/mp3`);
+            }
+            if (mimeType.type !== "audio" ||
+                (mimeType.subtype !== "wav" && mimeType.subtype !== "mp3")) {
+                throw new Error(`Audio blocks with source_type ${block.source_type} must have mime type of audio/wav or audio/mp3`);
+            }
+            return {
+                type: "input_audio",
+                input_audio: {
+                    format: mimeType.subtype,
+                    data: block.data,
+                },
+            };
+        }
+        throw new Error(`Audio content blocks with source_type ${block.source_type} are not supported for ChatOpenAI`);
+    },
+    fromStandardFileBlock(block) {
+        if (block.source_type === "url") {
+            const data = (0, messages_1.parseBase64DataUrl)({ dataUrl: block.url });
+            if (!data) {
+                throw new Error(`URL file blocks with source_type ${block.source_type} must be formatted as a data URL for ChatOpenAI`);
+            }
+            return {
+                type: "file",
+                file: {
+                    file_data: block.url,
+                    ...(block.metadata?.filename || block.metadata?.name
+                        ? {
+                            filename: (block.metadata?.filename ||
+                                block.metadata?.name),
+                        }
+                        : {}),
+                },
+            };
+        }
+        if (block.source_type === "base64") {
+            return {
+                type: "file",
+                file: {
+                    file_data: `data:${block.mime_type ?? ""};base64,${block.data}`,
+                    ...(block.metadata?.filename ||
+                        block.metadata?.name ||
+                        block.metadata?.title
+                        ? {
+                            filename: (block.metadata?.filename ||
+                                block.metadata?.name ||
+                                block.metadata?.title),
+                        }
+                        : {}),
+                },
+            };
+        }
+        if (block.source_type === "id") {
+            return {
+                type: "file",
+                file: {
+                    file_id: block.id,
+                },
+            };
+        }
+        throw new Error(`File content blocks with source_type ${block.source_type} are not supported for ChatOpenAI`);
+    },
+};
 // Used in LangSmith, export is important here
 function _convertMessagesToOpenAIParams(messages, model) {
     // TODO: Function messages do not support array content, fix cast
@@ -58,10 +184,18 @@ function _convertMessagesToOpenAIParams(messages, model) {
         if (role === "system" && isReasoningModel(model)) {
             role = "developer";
         }
+        const content = typeof message.content === "string"
+            ? message.content
+            : message.content.map((m) => {
+                if ((0, messages_1.isDataContentBlock)(m)) {
+                    return (0, messages_1.convertToProviderContentBlock)(m, completionsApiContentBlockConverter);
+                }
+                return m;
+            });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const completionParam = {
             role,
-            content: message.content,
+            content,
         };
         if (message.name != null) {
             completionParam.name = message.name;
@@ -98,8 +232,32 @@ function _convertMessagesToOpenAIParams(messages, model) {
 }
 exports._convertMessagesToOpenAIParams = _convertMessagesToOpenAIParams;
 const _FUNCTION_CALL_IDS_MAP_KEY = "__openai_function_call_ids__";
-function _convertMessagesToOpenAIResponsesParams(messages, model) {
-    return messages.flatMap((lcMsg) => {
+function _convertReasoningSummaryToOpenAIResponsesParams(reasoning) {
+    // combine summary parts that have the the same index and then remove the indexes
+    const summary = (reasoning.summary.length > 1
+        ? reasoning.summary.reduce((acc, curr) => {
+            const last = acc.at(-1);
+            if (last.index === curr.index) {
+                last.text += curr.text;
+            }
+            else {
+                acc.push(curr);
+            }
+            return acc;
+        }, [{ ...reasoning.summary[0] }])
+        : reasoning.summary).map((s) => Object.fromEntries(Object.entries(s).filter(([k]) => k !== "index")));
+    return {
+        ...reasoning,
+        summary,
+    };
+}
+function _convertMessagesToOpenAIResponsesParams(messages, model, zdrEnabled) {
+    const lastAIMessage = messages.filter((m) => (0, messages_1.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) => {
         let role = messageToOpenAIRole(lcMsg);
         if (role === "system" && isReasoningModel(model))
             role = "developer";
@@ -149,15 +307,25 @@ function _convertMessagesToOpenAIResponsesParams(messages, model) {
             };
         }
         if (role === "assistant") {
+            // if we have the original response items, just reuse them
+            if (!zdrEnabled &&
+                lcMsg.response_metadata.output != null &&
+                Array.isArray(lcMsg.response_metadata.output) &&
+                lcMsg.response_metadata.output.length > 0 &&
+                lcMsg.response_metadata.output.every((item) => "type" in item)) {
+                return lcMsg.response_metadata.output;
+            }
+            // otherwise, try to reconstruct the response from what we have
             const input = [];
             // reasoning items
-            if (lcMsg.additional_kwargs.reasoning != null) {
+            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)) {
-                    input.push(lcMsg.additional_kwargs.reasoning);
+                    const reasoningItem = _convertReasoningSummaryToOpenAIResponsesParams(lcMsg.additional_kwargs.reasoning);
+                    input.push(reasoningItem);
                 }
             }
             // ai content
@@ -174,6 +342,7 @@ function _convertMessagesToOpenAIResponsesParams(messages, model) {
             input.push({
                 type: "message",
                 role: "assistant",
+                ...(lcMsg.id && !zdrEnabled ? { id: lcMsg.id } : {}),
                 content: typeof content === "string"
                     ? content
                     : content.flatMap((item) => {
@@ -201,7 +370,7 @@ function _convertMessagesToOpenAIResponsesParams(messages, model) {
                     name: toolCall.name,
                     arguments: JSON.stringify(toolCall.args),
                     call_id: toolCall.id,
-                    id: functionCallIds?.[toolCall.id],
+                    ...(zdrEnabled ? { id: functionCallIds?.[toolCall.id] } : {}),
                 })));
             }
             else if (lcMsg.additional_kwargs.tool_calls != null) {
@@ -209,21 +378,17 @@ function _convertMessagesToOpenAIResponsesParams(messages, model) {
                     type: "function_call",
                     name: toolCall.function.name,
                     call_id: toolCall.id,
-                    id: functionCallIds?.[toolCall.id],
+                    ...(zdrEnabled ? { id: functionCallIds?.[toolCall.id] } : {}),
                     arguments: toolCall.function.arguments,
                 })));
             }
             const toolOutputs = lcMsg.response_metadata.output?.length
                 ? lcMsg.response_metadata.output
                 : lcMsg.additional_kwargs.tool_outputs;
+            let computerCalls = [];
             if (toolOutputs != null) {
                 const castToolOutputs = toolOutputs;
-                const reasoningCalls = castToolOutputs?.filter((item) => item.type === "reasoning");
-                const computerCalls = castToolOutputs?.filter((item) => item.type === "computer_call");
-                // NOTE: Reasoning outputs must be passed to the model BEFORE computer calls.
-                if (reasoningCalls.length > 0 && computerCalls.length > 0) {
-                    input.push(...reasoningCalls);
-                }
+                computerCalls = castToolOutputs?.filter((item) => item.type === "computer_call");
                 if (computerCalls.length > 0)
                     input.push(...computerCalls);
             }
@@ -232,6 +397,9 @@ function _convertMessagesToOpenAIResponsesParams(messages, model) {
         const content = typeof lcMsg.content === "string"
             ? lcMsg.content
             : lcMsg.content.flatMap((item) => {
+                if ((0, messages_1.isDataContentBlock)(item)) {
+                    return (0, messages_1.convertToProviderContentBlock)(item, completionsApiContentBlockConverter);
+                }
                 if (item.type === "text") {
                     return { type: "input_text", text: item.text };
                 }
@@ -424,6 +592,39 @@ function _convertOpenAIResponsesDeltaToBaseMessageChunk(chunk) {
     else if (chunk.type === "response.refusal.done") {
         additional_kwargs.refusal = chunk.refusal;
     }
+    else if (chunk.type === "response.output_item.added" &&
+        "item" in chunk &&
+        chunk.item.type === "reasoning") {
+        const summary = chunk
+            .item.summary
+            ? chunk.item.summary.map((s, index) => ({
+                ...s,
+                index,
+            }))
+            : undefined;
+        additional_kwargs.reasoning = {
+            // We only capture ID in the first chunk or else the concatenated result of all chunks will
+            // have an ID field that is repeated once per chunk. There is special handling for the `type`
+            // field that prevents this, however.
+            id: chunk.item.id,
+            type: chunk.item.type,
+            ...(summary ? { summary } : {}),
+        };
+    }
+    else if (chunk.type === "response.reasoning_summary_part.added") {
+        additional_kwargs.reasoning = {
+            type: "reasoning",
+            summary: [{ ...chunk.part, index: chunk.summary_index }],
+        };
+    }
+    else if (chunk.type === "response.reasoning_summary_text.delta") {
+        additional_kwargs.reasoning = {
+            type: "reasoning",
+            summary: [
+                { text: chunk.delta, type: "summary_text", index: chunk.summary_index },
+            ],
+        };
+    }
     else {
         return null;
     }
@@ -466,9 +667,7 @@ function _convertChatOpenAIToolTypeToOpenAITool(tool, fields) {
     return (0, tools_js_1._convertToOpenAITool)(tool, fields);
 }
 function isReasoningModel(model) {
-    return (model?.startsWith("o1") ||
-        model?.startsWith("o3") ||
-        model?.startsWith("o4"));
+    return model && /^o\d/.test(model);
 }
 /**
  * OpenAI chat model integration.
@@ -1076,6 +1275,9 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
             "tags",
             "metadata",
             "disableStreaming",
+            "useResponsesApi",
+            "zdrEnabled",
+            "reasoning",
         ];
     }
     constructor(fields) {
@@ -1253,18 +1455,51 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
             writable: true,
             value: void 0
         });
+        /**
+         * @deprecated Use {@link reasoning} object instead.
+         */
         Object.defineProperty(this, "reasoningEffort", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * Options for reasoning models.
+         */
+        Object.defineProperty(this, "reasoning", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Whether to use the responses API for all requests. If `false` the responses API will be used
+         * only when required in order to fulfill the request.
+         */
         Object.defineProperty(this, "useResponsesApi", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: false
         });
+        /**
+         * Must be set to `true` in tenancies with Zero Data Retention. Setting to `true` will disable
+         * output storage in the Responses API, but this DOES NOT enable Zero Data Retention in your
+         * OpenAI organization or project. This must be configured directly with OpenAI.
+         *
+         * See:
+         * https://help.openai.com/en/articles/10503543-data-residency-for-the-openai-api
+         * https://platform.openai.com/docs/api-reference/responses/create#responses-create-store
+         *
+         * @default false
+         */
+        Object.defineProperty(this, "zdrEnabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.openAIApiKey =
             fields?.apiKey ??
                 fields?.openAIApiKey ??
@@ -1292,7 +1527,12 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
         this.__includeRawResponse = fields?.__includeRawResponse;
         this.audio = fields?.audio;
         this.modalities = fields?.modalities;
-        this.reasoningEffort = fields?.reasoningEffort;
+        this.reasoningEffort = fields?.reasoningEffort ?? fields?.reasoning?.effort;
+        this.reasoning =
+            fields?.reasoning ??
+                (fields?.reasoningEffort
+                    ? { effort: fields.reasoningEffort }
+                    : undefined);
         this.maxTokens = fields?.maxCompletionTokens ?? fields?.maxTokens;
         this.useResponsesApi = fields?.useResponsesApi ?? this.useResponsesApi;
         this.disableStreaming = fields?.disableStreaming ?? this.disableStreaming;
@@ -1315,6 +1555,7 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
         if (fields?.supportsStrictToolCalling !== undefined) {
             this.supportsStrictToolCalling = fields.supportsStrictToolCalling;
         }
+        this.zdrEnabled = fields?.zdrEnabled ?? false;
     }
     getLsParams(options) {
         const params = this.invocationParams(options);
@@ -1353,6 +1594,35 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
         }
         return resFormat;
     }
+    getReasoningParams(options) {
+        if (!isReasoningModel(this.model)) {
+            return;
+        }
+        let reasoning;
+        // apply reasoning options in reverse order of priority without else blocks so that highest priority overrides lowest priority
+        if (this.reasoningEffort !== undefined) {
+            reasoning = { effort: this.reasoningEffort };
+        }
+        if (this.reasoning !== undefined) {
+            reasoning = {
+                ...reasoning,
+                ...this.reasoning,
+            };
+        }
+        if (options?.reasoning_effort !== undefined) {
+            reasoning = {
+                ...reasoning,
+                effort: options.reasoning_effort,
+            };
+        }
+        if (options?.reasoning !== undefined) {
+            reasoning = {
+                ...reasoning,
+                ...options.reasoning,
+            };
+        }
+        return reasoning;
+    }
     /**
      * Get the parameters used to invoke the model
      */
@@ -1429,11 +1699,12 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
                 })(),
                 parallel_tool_calls: options?.parallel_tool_calls,
                 max_output_tokens: this.maxTokens === -1 ? undefined : this.maxTokens,
+                ...(this.zdrEnabled ? { store: false } : {}),
                 ...this.modelKwargs,
             };
-            const reasoningEffort = options?.reasoning_effort ?? this.reasoningEffort;
-            if (reasoningEffort !== undefined) {
-                params.reasoning = { effort: reasoningEffort };
+            const reasoning = this.getReasoningParams(options);
+            if (reasoning !== undefined) {
+                params.reasoning = reasoning;
             }
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             return params;
@@ -1480,9 +1751,9 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
         if (options?.prediction !== undefined) {
             params.prediction = options.prediction;
         }
-        const reasoningEffort = options?.reasoning_effort ?? this.reasoningEffort;
-        if (reasoningEffort !== undefined) {
-            params.reasoning_effort = reasoningEffort;
+        const reasoning = this.getReasoningParams(options);
+        if (reasoning !== undefined && reasoning.effort !== undefined) {
+            params.reasoning_effort = reasoning.effort;
         }
         if (isReasoningModel(params.model)) {
             params.max_completion_tokens =
@@ -1636,10 +1907,17 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
     }
     async *_streamResponseChunks(messages, options, runManager) {
         if (this._useResponseApi(options)) {
+            const lastAIMessage = messages.filter((m) => (0, messages_1.isAIMessage)(m)).pop();
+            const lastAIMessageId = lastAIMessage?.response_metadata?.id;
             const streamIterable = await this.responseApiWithRetry({
                 ...this.invocationParams(options, { streaming: true }),
-                input: _convertMessagesToOpenAIResponsesParams(messages, this.model),
+                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);
@@ -1773,8 +2051,18 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
                 },
             };
         }
-        const input = _convertMessagesToOpenAIResponsesParams(messages, this.model);
-        const data = await this.responseApiWithRetry({ input, ...invocationParams }, { signal: options?.signal, ...options?.options });
+        const lastAIMessage = messages.filter((m) => (0, messages_1.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: [
                 {
@@ -1794,12 +2082,23 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
             },
         };
     }
+    /**
+     * Determines whether the responses API should be used for the given request.
+     *
+     * @internal
+     *
+     * @param options The parsed call options for the request.
+     * @returns `true` if the responses API should be used, either because it is explicitly enabled,
+     * or because the request requires it.
+     */
     _useResponseApi(options) {
         const usesBuiltInTools = options?.tools?.some(isBuiltInTool);
         const hasResponsesOnlyKwargs = options?.previous_response_id != null ||
             options?.text != null ||
             options?.truncation != null ||
-            options?.include != null;
+            options?.include != null ||
+            options?.reasoning?.summary != null ||
+            this.reasoning?.summary != null;
         return this.useResponsesApi || usesBuiltInTools || hasResponsesOnlyKwargs;
     }
     /** @ignore */

package/dist/chat_models.d.ts

@@ -6,7 +6,7 @@ import { BaseChatModel, type BindToolsInput, type LangSmithParams, type BaseChat
 import { type BaseFunctionCallOptions, type BaseLanguageModelInput, type StructuredOutputMethodOptions } from "@langchain/core/language_models/base";
 import { z } from "zod";
 import { Runnable } from "@langchain/core/runnables";
-import type { OpenAICallOptions, OpenAIChatInput, OpenAICoreRequestOptions, ChatOpenAIResponseFormat } from "./types.js";
+import { type OpenAICallOptions, type OpenAIChatInput, type OpenAICoreRequestOptions, type ChatOpenAIResponseFormat } from "./types.js";
 import { OpenAIToolChoice } from "./utils/openai.js";
 export type { OpenAICallOptions, OpenAIChatInput };
 interface TokenUsage {
@@ -117,29 +117,54 @@ export interface ChatOpenAICallOptions extends OpenAICallOptions, BaseFunctionCa
     /**
      * Constrains effort on reasoning for reasoning models. Currently supported values are low, medium, and high.
      * Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+     *
+     * @deprecated Use {@link reasoning} object instead.
      */
     reasoning_effort?: OpenAIClient.Chat.ChatCompletionReasoningEffort;
+    /**
+     * Options for reasoning models.
+     *
+     * Note that some options, like reasoning summaries, are only available when using the responses
+     * API. If these options are set, the responses API will be used to fulfill the request.
+     *
+     * These options will be ignored when not using a reasoning model.
+     */
+    reasoning?: OpenAIClient.Reasoning;
     /**
      * Configuration options for a text response from the model. Can be plain text or
      * structured JSON data.
+     *
+     * If set, the Responses API will be used to fulfill the request.
      */
     text?: ResponsesCreateParams["text"];
     /**
      * The truncation strategy to use for the model response.
+     *
+     * If set, the Responses API will be used to fulfill the request.
      */
     truncation?: ResponsesCreateParams["truncation"];
     /**
      * Specify additional output data to include in the model response.
+     *
+     * If set, the Responses API will be used to fulfill the request.
      */
     include?: ResponsesCreateParams["include"];
     /**
-     * The unique ID of the previous response to the model. Use this to create
-     * multi-turn conversations.
+     * The unique ID of the previous response to the model. Use this to create multi-turn
+     * conversations. Will be set automatically if {@link ChatOpenAI.zdrEnabled} is `false`, provided
+     * that AIMessages included in the request have a `response_metadata.id` property. Ignored unless
+     * {@link ChatOpenAI.useResponsesApi} is `true`.
+     *
+     * If set, the Responses API will be used to fulfill the request.
      */
     previous_response_id?: ResponsesCreateParams["previous_response_id"];
 }
 export interface ChatOpenAIFields extends Partial<OpenAIChatInput>, BaseChatModelParams {
     configuration?: ClientOptions;
+    /**
+     * Whether to use the responses API for all requests. If `false` the responses API will be used
+     * only when required in order to fulfill the request.
+     */
     useResponsesApi?: boolean;
 }
 /**
@@ -721,12 +746,36 @@ export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = Chat
     supportsStrictToolCalling?: boolean;
     audio?: OpenAIClient.Chat.ChatCompletionAudioParam;
     modalities?: Array<OpenAIClient.Chat.ChatCompletionModality>;
+    /**
+     * @deprecated Use {@link reasoning} object instead.
+     */
     reasoningEffort?: OpenAIClient.Chat.ChatCompletionReasoningEffort;
+    /**
+     * Options for reasoning models.
+     */
+    reasoning?: OpenAIClient.Reasoning;
+    /**
+     * Whether to use the responses API for all requests. If `false` the responses API will be used
+     * only when required in order to fulfill the request.
+     */
     useResponsesApi: boolean;
+    /**
+     * Must be set to `true` in tenancies with Zero Data Retention. Setting to `true` will disable
+     * output storage in the Responses API, but this DOES NOT enable Zero Data Retention in your
+     * OpenAI organization or project. This must be configured directly with OpenAI.
+     *
+     * See:
+     * https://help.openai.com/en/articles/10503543-data-residency-for-the-openai-api
+     * https://platform.openai.com/docs/api-reference/responses/create#responses-create-store
+     *
+     * @default false
+     */
+    zdrEnabled?: boolean | undefined;
     constructor(fields?: ChatOpenAIFields);
     getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
     bindTools(tools: ChatOpenAIToolType[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, CallOptions>;
     private createResponseFormat;
+    private getReasoningParams;
     /**
      * Get the parameters used to invoke the model
      */
@@ -749,6 +798,15 @@ export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = Chat
     } & ClientOptions;
     /** @ignore */
     _responseApiGenerate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    /**
+     * Determines whether the responses API should be used for the given request.
+     *
+     * @internal
+     *
+     * @param options The parsed call options for the request.
+     * @returns `true` if the responses API should be used, either because it is explicitly enabled,
+     * or because the request requires it.
+     */
     protected _useResponseApi(options: this["ParsedCallOptions"] | undefined): boolean;
     /** @ignore */
     _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;