@langchain/openai 0.5.7 → 0.5.8

package/dist/chat_models.cjs

@@ -232,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";
@@ -283,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
@@ -308,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) => {
@@ -335,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) {
@@ -343,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);
             }
@@ -561,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;
     }
@@ -603,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.
@@ -1213,6 +1275,9 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
             "tags",
             "metadata",
             "disableStreaming",
+            "useResponsesApi",
+            "zdrEnabled",
+            "reasoning",
         ];
     }
     constructor(fields) {
@@ -1390,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 ??
@@ -1429,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;
@@ -1452,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);
@@ -1490,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
      */
@@ -1566,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;
@@ -1617,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 =
@@ -1773,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);
@@ -1910,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: [
                 {
@@ -1931,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>;

package/dist/chat_models.js

@@ -227,8 +227,32 @@ export function _convertMessagesToOpenAIParams(messages, model) {
     });
 }
 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) => 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";
@@ -278,15 +302,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
@@ -303,6 +337,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) => {
@@ -330,7 +365,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) {
@@ -338,21 +373,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);
             }
@@ -556,6 +587,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;
     }
@@ -598,9 +662,7 @@ function _convertChatOpenAIToolTypeToOpenAITool(tool, fields) {
     return _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.
@@ -1208,6 +1270,9 @@ export class ChatOpenAI extends BaseChatModel {
             "tags",
             "metadata",
             "disableStreaming",
+            "useResponsesApi",
+            "zdrEnabled",
+            "reasoning",
         ];
     }
     constructor(fields) {
@@ -1385,18 +1450,51 @@ export class ChatOpenAI extends 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 ??
@@ -1424,7 +1522,12 @@ export class ChatOpenAI extends 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;
@@ -1447,6 +1550,7 @@ export class ChatOpenAI extends BaseChatModel {
         if (fields?.supportsStrictToolCalling !== undefined) {
             this.supportsStrictToolCalling = fields.supportsStrictToolCalling;
         }
+        this.zdrEnabled = fields?.zdrEnabled ?? false;
     }
     getLsParams(options) {
         const params = this.invocationParams(options);
@@ -1485,6 +1589,35 @@ export class ChatOpenAI extends 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
      */
@@ -1561,11 +1694,12 @@ export class ChatOpenAI extends 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;
@@ -1612,9 +1746,9 @@ export class ChatOpenAI extends 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 =
@@ -1768,10 +1902,17 @@ 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),
+                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);
@@ -1905,8 +2046,18 @@ export class ChatOpenAI extends BaseChatModel {
                 },
             };
         }
-        const input = _convertMessagesToOpenAIResponsesParams(messages, this.model);
-        const data = await this.responseApiWithRetry({ input, ...invocationParams }, { signal: options?.signal, ...options?.options });
+        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: [
                 {
@@ -1926,12 +2077,23 @@ export class ChatOpenAI extends 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/tools/dalle.cjs

@@ -115,7 +115,7 @@ class DallEAPIWrapper extends tools_1.Tool {
         if (this.dallEResponseFormat === "url") {
             return response.flatMap((res) => {
                 const imageUrlContent = res.data
-                    .flatMap((item) => {
+                    ?.flatMap((item) => {
                     if (!item.url)
                         return [];
                     return {
@@ -126,14 +126,14 @@ class DallEAPIWrapper extends tools_1.Tool {
                     .filter((item) => item !== undefined &&
                     item.type === "image_url" &&
                     typeof item.image_url === "string" &&
-                    item.image_url !== undefined);
+                    item.image_url !== undefined) ?? [];
                 return imageUrlContent;
             });
         }
         else {
             return response.flatMap((res) => {
                 const b64Content = res.data
-                    .flatMap((item) => {
+                    ?.flatMap((item) => {
                     if (!item.b64_json)
                         return [];
                     return {
@@ -148,7 +148,7 @@ class DallEAPIWrapper extends tools_1.Tool {
                     typeof item.image_url === "object" &&
                     "url" in item.image_url &&
                     typeof item.image_url.url === "string" &&
-                    item.image_url.url !== undefined);
+                    item.image_url.url !== undefined) ?? [];
                 return b64Content;
             });
         }
@@ -172,14 +172,17 @@ class DallEAPIWrapper extends tools_1.Tool {
         const response = await this.client.images.generate(generateImageFields);
         let data = "";
         if (this.dallEResponseFormat === "url") {
-            [data] = response.data
-                .map((item) => item.url)
-                .filter((url) => url !== "undefined");
+            [data] =
+                response.data
+                    ?.map((item) => item.url)
+                    .filter((url) => url !== "undefined") ?? [];
         }
         else {
-            [data] = response.data
-                .map((item) => item.b64_json)
-                .filter((b64_json) => b64_json !== "undefined");
+            [data] =
+                response.data
+                    ?.map((item) => item.b64_json)
+                    .filter((b64_json) => b64_json !== "undefined") ??
+                    [];
         }
         return data;
     }

package/dist/tools/dalle.js

@@ -112,7 +112,7 @@ export class DallEAPIWrapper extends Tool {
         if (this.dallEResponseFormat === "url") {
             return response.flatMap((res) => {
                 const imageUrlContent = res.data
-                    .flatMap((item) => {
+                    ?.flatMap((item) => {
                     if (!item.url)
                         return [];
                     return {
@@ -123,14 +123,14 @@ export class DallEAPIWrapper extends Tool {
                     .filter((item) => item !== undefined &&
                     item.type === "image_url" &&
                     typeof item.image_url === "string" &&
-                    item.image_url !== undefined);
+                    item.image_url !== undefined) ?? [];
                 return imageUrlContent;
             });
         }
         else {
             return response.flatMap((res) => {
                 const b64Content = res.data
-                    .flatMap((item) => {
+                    ?.flatMap((item) => {
                     if (!item.b64_json)
                         return [];
                     return {
@@ -145,7 +145,7 @@ export class DallEAPIWrapper extends Tool {
                     typeof item.image_url === "object" &&
                     "url" in item.image_url &&
                     typeof item.image_url.url === "string" &&
-                    item.image_url.url !== undefined);
+                    item.image_url.url !== undefined) ?? [];
                 return b64Content;
             });
         }
@@ -169,14 +169,17 @@ export class DallEAPIWrapper extends Tool {
         const response = await this.client.images.generate(generateImageFields);
         let data = "";
         if (this.dallEResponseFormat === "url") {
-            [data] = response.data
-                .map((item) => item.url)
-                .filter((url) => url !== "undefined");
+            [data] =
+                response.data
+                    ?.map((item) => item.url)
+                    .filter((url) => url !== "undefined") ?? [];
         }
         else {
-            [data] = response.data
-                .map((item) => item.b64_json)
-                .filter((b64_json) => b64_json !== "undefined");
+            [data] =
+                response.data
+                    ?.map((item) => item.b64_json)
+                    .filter((b64_json) => b64_json !== "undefined") ??
+                    [];
         }
         return data;
     }

package/dist/types.d.ts

@@ -135,8 +135,24 @@ export interface OpenAIChatInput extends OpenAIBaseInput {
     /**
      * 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 the {@link reasoning} object instead.
      */
     reasoningEffort?: OpenAIClient.Chat.ChatCompletionReasoningEffort;
+    /**
+     * Options for reasoning models.
+     *
+     * Note that some options, like reasoning summaries, are only available when using the responses
+     * API. This option is ignored when not using a reasoning model.
+     */
+    reasoning?: OpenAIClient.Reasoning;
+    /**
+     * Should be set to `true` in tenancies with Zero Data Retention
+     * @see https://platform.openai.com/docs/guides/your-data
+     *
+     * @default false
+     */
+    zdrEnabled?: boolean;
 }
 export declare interface AzureOpenAIInput {
     /**
@@ -205,4 +221,17 @@ type ChatOpenAIResponseFormatJSONSchema = Omit<ResponseFormatJSONSchema, "json_s
         schema: Record<string, any> | z.ZodObject<any, any, any, any>;
     };
 };
+/**
+ * The summary of a model's reasoning step.
+ */
+export type ChatOpenAIReasoningSummary = Omit<OpenAIClient.Responses.ResponseReasoningItem, "summary"> & {
+    /**
+     * The summary of the reasoning step. The index field will be populated if the response was
+     * streamed. This allows LangChain to recompose the reasoning summary output correctly when the
+     * AIMessage is used as an input for future generation requests.
+     */
+    summary: Array<OpenAIClient.Responses.ResponseReasoningItem.Summary & {
+        index?: number;
+    }>;
+};
 export type ChatOpenAIResponseFormat = ResponseFormatText | ResponseFormatJSONObject | ChatOpenAIResponseFormatJSONSchema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/openai",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "description": "OpenAI integrations for LangChain.js",
   "type": "module",
   "engines": {
@@ -36,7 +36,7 @@
   "license": "MIT",
   "dependencies": {
     "js-tiktoken": "^1.0.12",
-    "openai": "^4.93.0",
+    "openai": "^4.96.0",
     "zod": "^3.22.4",
     "zod-to-json-schema": "^3.22.3"
   },