@langchain/openai 0.6.1 → 0.6.3

package/dist/chat_models.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChatOpenAI = exports.ChatOpenAICompletions = exports.ChatOpenAIResponses = void 0;
+exports.ChatOpenAI = exports.ChatOpenAICompletions = exports.ChatOpenAIResponses = exports.BaseChatOpenAI = void 0;
 exports.messageToOpenAIRole = messageToOpenAIRole;
 exports._convertMessagesToOpenAIParams = _convertMessagesToOpenAIParams;
 const openai_1 = require("openai");
@@ -476,12 +476,14 @@ class BaseChatOpenAI extends chat_models_1.BaseChatModel {
             writable: true,
             value: void 0
         });
+        /** @internal */
         Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /** @internal */
         Object.defineProperty(this, "clientConfig", {
             enumerable: true,
             configurable: true,
@@ -543,6 +545,12 @@ class BaseChatOpenAI extends chat_models_1.BaseChatModel {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "defaultOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "lc_serializable", {
             enumerable: true,
             configurable: true,
@@ -637,6 +645,13 @@ class BaseChatOpenAI extends chat_models_1.BaseChatModel {
         }
         return resFormat;
     }
+    _combineCallOptions(additionalOptions) {
+        return {
+            ...this.defaultOptions,
+            ...(additionalOptions ?? {}),
+        };
+    }
+    /** @internal */
     _getClientOptions(options) {
         if (!this.client) {
             const openAIEndpointConfig = {
@@ -691,6 +706,12 @@ class BaseChatOpenAI extends chat_models_1.BaseChatModel {
             ...kwargs,
         });
     }
+    async stream(input, options) {
+        return super.stream(input, this._combineCallOptions(options));
+    }
+    async invoke(input, options) {
+        return super.invoke(input, this._combineCallOptions(options));
+    }
     /** @ignore */
     _combineLLMOutput(...llmOutputs) {
         return llmOutputs.reduce((acc, llmOutput) => {
@@ -798,13 +819,22 @@ class BaseChatOpenAI extends chat_models_1.BaseChatModel {
         }
         return tokens;
     }
+    /** @internal */
+    _getStructuredOutputMethod(config) {
+        const ensuredConfig = { ...config };
+        if (!this.model.startsWith("gpt-3") &&
+            !this.model.startsWith("gpt-4-") &&
+            this.model !== "gpt-4") {
+            if (ensuredConfig?.method === undefined) {
+                return "jsonSchema";
+            }
+        }
+        else if (ensuredConfig.method === "jsonSchema") {
+            console.warn(`[WARNING]: JSON Schema is not supported for model "${this.model}". Falling back to tool calling.`);
+        }
+        return ensuredConfig.method;
+    }
     withStructuredOutput(outputSchema, config) {
-        // ):
-        // | Runnable<BaseLanguageModelInput, RunOutput>
-        // | Runnable<
-        //     BaseLanguageModelInput,
-        //     { raw: BaseMessage; parsed: RunOutput }
-        //   > {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let schema;
         let name;
@@ -827,47 +857,43 @@ class BaseChatOpenAI extends chat_models_1.BaseChatModel {
         if (config?.strict !== undefined && method === "jsonMode") {
             throw new Error("Argument `strict` is only supported for `method` = 'function_calling'");
         }
-        if (!this.model.startsWith("gpt-3") &&
-            !this.model.startsWith("gpt-4-") &&
-            this.model !== "gpt-4") {
-            if (method === undefined) {
-                method = "jsonSchema";
-            }
-        }
-        else if (method === "jsonSchema") {
-            console.warn(`[WARNING]: JSON Schema is not supported for model "${this.model}". Falling back to tool calling.`);
-        }
+        method = this._getStructuredOutputMethod({ ...config, method });
         if (method === "jsonMode") {
-            let outputFormatSchema;
             if ((0, types_1.isInteropZodSchema)(schema)) {
                 outputParser = output_parsers_1.StructuredOutputParser.fromZodSchema(schema);
-                outputFormatSchema = (0, json_schema_1.toJsonSchema)(schema);
             }
             else {
                 outputParser = new output_parsers_1.JsonOutputParser();
             }
+            const asJsonSchema = (0, json_schema_1.toJsonSchema)(schema);
             llm = this.withConfig({
                 response_format: { type: "json_object" },
                 ls_structured_output_format: {
-                    kwargs: { method: "jsonMode" },
-                    schema: outputFormatSchema,
+                    kwargs: { method: "json_mode" },
+                    schema: { title: name ?? "extract", ...asJsonSchema },
                 },
             });
         }
         else if (method === "jsonSchema") {
+            const openaiJsonSchemaParams = {
+                name: name ?? "extract",
+                description: (0, types_1.getSchemaDescription)(schema),
+                schema,
+                strict: config?.strict,
+            };
+            const asJsonSchema = (0, json_schema_1.toJsonSchema)(openaiJsonSchemaParams.schema);
             llm = this.withConfig({
                 response_format: {
                     type: "json_schema",
-                    json_schema: {
-                        name: name ?? "extract",
-                        description: (0, types_1.getSchemaDescription)(schema),
-                        schema,
-                        strict: config?.strict,
-                    },
+                    json_schema: openaiJsonSchemaParams,
                 },
                 ls_structured_output_format: {
-                    kwargs: { method: "jsonSchema" },
-                    schema: (0, json_schema_1.toJsonSchema)(schema),
+                    kwargs: { method: "json_schema" },
+                    schema: {
+                        title: openaiJsonSchemaParams.name,
+                        description: openaiJsonSchemaParams.description,
+                        ...asJsonSchema,
+                    },
                 },
             });
             if ((0, types_1.isInteropZodSchema)(schema)) {
@@ -906,8 +932,8 @@ class BaseChatOpenAI extends chat_models_1.BaseChatModel {
                         },
                     },
                     ls_structured_output_format: {
-                        kwargs: { method: "functionCalling" },
-                        schema: asJsonSchema,
+                        kwargs: { method: "function_calling" },
+                        schema: { title: functionName, ...asJsonSchema },
                     },
                     // Do not pass `strict` argument to OpenAI if `config.strict` is undefined
                     ...(config?.strict !== undefined ? { strict: config.strict } : {}),
@@ -934,6 +960,7 @@ class BaseChatOpenAI extends chat_models_1.BaseChatModel {
                         parameters: schema,
                     };
                 }
+                const asJsonSchema = (0, json_schema_1.toJsonSchema)(schema);
                 llm = this.withConfig({
                     tools: [
                         {
@@ -948,8 +975,8 @@ class BaseChatOpenAI extends chat_models_1.BaseChatModel {
                         },
                     },
                     ls_structured_output_format: {
-                        kwargs: { method: "functionCalling" },
-                        schema: (0, json_schema_1.toJsonSchema)(schema),
+                        kwargs: { method: "function_calling" },
+                        schema: { title: functionName, ...asJsonSchema },
                     },
                     // Do not pass `strict` argument to OpenAI if `config.strict` is undefined
                     ...(config?.strict !== undefined ? { strict: config.strict } : {}),
@@ -976,6 +1003,7 @@ class BaseChatOpenAI extends chat_models_1.BaseChatModel {
         return runnables_1.RunnableSequence.from([{ raw: llm }, parsedWithFallback]);
     }
 }
+exports.BaseChatOpenAI = BaseChatOpenAI;
 /**
  * OpenAI Responses API implementation.
  *
@@ -2590,7 +2618,7 @@ class ChatOpenAI extends BaseChatOpenAI {
         return [...super.lc_serializable_keys, "useResponsesApi"];
     }
     constructor(fields) {
-        super(fields ?? {});
+        super(fields);
         /**
          * 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.
@@ -2614,8 +2642,8 @@ class ChatOpenAI extends BaseChatOpenAI {
             value: void 0
         });
         this.useResponsesApi = fields?.useResponsesApi ?? false;
-        this.responses = new ChatOpenAIResponses(fields);
-        this.completions = new ChatOpenAICompletions(fields);
+        this.responses = fields?.responses ?? new ChatOpenAIResponses(fields);
+        this.completions = fields?.completions ?? new ChatOpenAICompletions(fields);
     }
     _useResponsesApi(options) {
         const usesBuiltInTools = options?.tools?.some(isBuiltInTool);
@@ -2627,6 +2655,20 @@ class ChatOpenAI extends BaseChatOpenAI {
             this.reasoning?.summary != null;
         return this.useResponsesApi || usesBuiltInTools || hasResponsesOnlyKwargs;
     }
+    getLsParams(options) {
+        const optionsWithDefaults = this._combineCallOptions(options);
+        if (this._useResponsesApi(options)) {
+            return this.responses.getLsParams(optionsWithDefaults);
+        }
+        return this.completions.getLsParams(optionsWithDefaults);
+    }
+    invocationParams(options) {
+        const optionsWithDefaults = this._combineCallOptions(options);
+        if (this._useResponsesApi(options)) {
+            return this.responses.invocationParams(optionsWithDefaults);
+        }
+        return this.completions.invocationParams(optionsWithDefaults);
+    }
     /** @ignore */
     async _generate(messages, options, runManager) {
         if (this._useResponsesApi(options)) {
@@ -2636,33 +2678,14 @@ class ChatOpenAI extends BaseChatOpenAI {
     }
     async *_streamResponseChunks(messages, options, runManager) {
         if (this._useResponsesApi(options)) {
-            yield* this.responses._streamResponseChunks(messages, options);
+            yield* this.responses._streamResponseChunks(messages, this._combineCallOptions(options));
             return;
         }
-        yield* this.completions._streamResponseChunks(messages, options, runManager);
+        yield* this.completions._streamResponseChunks(messages, this._combineCallOptions(options), runManager);
     }
     withConfig(config) {
-        // FIXME: assigning additional config options to the inner chat classes this way
-        // is awkward, but it's the only way to preserve the original object identity
-        // and still thread config options, which is important since this class is a "proxy"
-        // for the inner chat classes. This will be fixed in a later version of langchain
-        // when the core runnable interface is improved (0.4) to support this out of the box.
-        const bindChatOpenAIConfig = (cls, config) => {
-            const oldGenerate = cls._generate;
-            const oldStreamResponseChunks = cls._streamResponseChunks;
-            return Object.assign(cls, {
-                _generate(messages, options, runManager) {
-                    return oldGenerate.call(cls, messages, { ...options, ...config }, runManager);
-                },
-                _streamResponseChunks(messages, options, runManager) {
-                    return oldStreamResponseChunks.call(cls, messages, { ...options, ...config }, runManager);
-                },
-            });
-        };
-        this.responses = bindChatOpenAIConfig(this.responses, config);
-        this.completions = bindChatOpenAIConfig(this.completions, config);
-        // Proxy chat class is also bound for `_useResponsesApi`,
-        return bindChatOpenAIConfig(this, config);
+        this.defaultOptions = { ...this.defaultOptions, ...config };
+        return this;
     }
 }
 exports.ChatOpenAI = ChatOpenAI;

package/dist/chat_models.d.ts

@@ -22,7 +22,7 @@ interface OpenAILLMOutput {
 export type { OpenAICallOptions, OpenAIChatInput };
 export declare function messageToOpenAIRole(message: BaseMessage): OpenAIClient.ChatCompletionRole;
 export declare function _convertMessagesToOpenAIParams(messages: BaseMessage[], model?: string): OpenAIClient.Chat.Completions.ChatCompletionMessageParam[];
-interface BaseChatOpenAICallOptions extends OpenAICallOptions, BaseFunctionCallOptions {
+export interface BaseChatOpenAICallOptions extends OpenAICallOptions, BaseFunctionCallOptions {
     /**
      * A list of tools that the model may use to generate responses.
      * Each tool can be a function, a built-in tool, or a custom tool definition.
@@ -120,7 +120,7 @@ export interface BaseChatOpenAIFields extends Partial<OpenAIChatInput>, BaseChat
     configuration?: ClientOptions;
 }
 /** @internal */
-declare abstract class BaseChatOpenAI<CallOptions extends BaseChatOpenAICallOptions> extends BaseChatModel<CallOptions, AIMessageChunk> implements Partial<OpenAIChatInput> {
+export declare abstract class BaseChatOpenAI<CallOptions extends BaseChatOpenAICallOptions> extends BaseChatModel<CallOptions, AIMessageChunk> implements Partial<OpenAIChatInput> {
     temperature?: number;
     topP?: number;
     frequencyPenalty?: number;
@@ -141,8 +141,10 @@ declare abstract class BaseChatOpenAI<CallOptions extends BaseChatOpenAICallOpti
     apiKey?: string;
     organization?: string;
     __includeRawResponse?: boolean;
-    protected client: OpenAIClient;
-    protected clientConfig: ClientOptions;
+    /** @internal */
+    client: OpenAIClient;
+    /** @internal */
+    clientConfig: ClientOptions;
     /**
      * Whether the model supports the `strict` argument when passing in tools.
      * If `undefined` the `strict` argument will not be passed to OpenAI.
@@ -168,6 +170,7 @@ declare abstract class BaseChatOpenAI<CallOptions extends BaseChatOpenAICallOpti
      * Specifies the service tier for prioritization and latency optimization.
      */
     service_tier?: OpenAIClient.Chat.ChatCompletionCreateParams["service_tier"];
+    protected defaultOptions: CallOptions;
     _llmType(): string;
     static lc_name(): string;
     get callKeys(): string[];
@@ -199,11 +202,15 @@ declare abstract class BaseChatOpenAI<CallOptions extends BaseChatOpenAICallOpti
      * @internal
      */
     protected _getResponseFormat(resFormat?: CallOptions["response_format"]): ResponseFormatText | ResponseFormatJSONObject | ResponseFormatJSONSchema | undefined;
-    protected _getClientOptions(options: OpenAICoreRequestOptions | undefined): OpenAICoreRequestOptions;
+    protected _combineCallOptions(additionalOptions?: this["ParsedCallOptions"]): this["ParsedCallOptions"];
+    /** @internal */
+    _getClientOptions(options: OpenAICoreRequestOptions | undefined): OpenAICoreRequestOptions;
     protected _convertChatOpenAIToolToCompletionsTool(tool: ChatOpenAIToolType, fields?: {
         strict?: boolean;
     }): OpenAIClient.ChatCompletionTool;
     bindTools(tools: ChatOpenAIToolType[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, CallOptions>;
+    stream(input: BaseLanguageModelInput, options?: CallOptions): Promise<import("@langchain/core/utils/stream").IterableReadableStream<AIMessageChunk>>;
+    invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<AIMessageChunk>;
     /** @ignore */
     _combineLLMOutput(...llmOutputs: OpenAILLMOutput[]): OpenAILLMOutput;
     getNumTokensFromMessages(messages: BaseMessage[]): Promise<{
@@ -214,6 +221,8 @@ declare abstract class BaseChatOpenAI<CallOptions extends BaseChatOpenAICallOpti
     protected _getNumTokensFromGenerations(generations: ChatGeneration[]): Promise<number>;
     /** @internal */
     protected _getEstimatedTokenCountFromPrompt(messages: BaseMessage[], functions?: OpenAIClient.Chat.ChatCompletionCreateParams.Function[], function_call?: "none" | "auto" | OpenAIClient.Chat.ChatCompletionFunctionCallOption): Promise<number>;
+    /** @internal */
+    protected _getStructuredOutputMethod(config: StructuredOutputMethodOptions<boolean>): string | undefined;
     withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
     withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;
@@ -231,7 +240,7 @@ type ResponsesCreate = OpenAIClient.Responses["create"];
 type ResponsesParse = OpenAIClient.Responses["parse"];
 type ResponsesCreateInvoke = ExcludeController<Awaited<ReturnType<ResponsesCreate>>>;
 type ResponsesParseInvoke = ExcludeController<Awaited<ReturnType<ResponsesParse>>>;
-interface ChatOpenAIResponsesCallOptions extends BaseChatOpenAICallOptions {
+export interface ChatOpenAIResponsesCallOptions extends BaseChatOpenAICallOptions {
     /**
      * Configuration options for a text response from the model. Can be plain text or
      * structured JSON data.
@@ -285,7 +294,7 @@ export declare class ChatOpenAIResponses<CallOptions extends ChatOpenAIResponses
         strict?: boolean;
     }): ResponsesTool[];
 }
-interface ChatOpenAICompletionsCallOptions extends BaseChatOpenAICallOptions {
+export interface ChatOpenAICompletionsCallOptions extends BaseChatOpenAICallOptions {
 }
 type ChatCompletionsInvocationParams = Omit<OpenAIClient.Chat.Completions.ChatCompletionCreateParams, "messages">;
 /**
@@ -313,6 +322,16 @@ export interface ChatOpenAIFields extends BaseChatOpenAIFields {
      * only when required in order to fulfill the request.
      */
     useResponsesApi?: boolean;
+    /**
+     * The completions chat instance
+     * @internal
+     */
+    completions?: ChatOpenAICompletions;
+    /**
+     * The responses chat instance
+     * @internal
+     */
+    responses?: ChatOpenAIResponses;
 }
 /**
  * OpenAI chat model integration.
@@ -852,17 +871,19 @@ export interface ChatOpenAIFields extends BaseChatOpenAIFields {
  *
  * <br />
  */
-export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = ChatOpenAICallOptions> extends BaseChatOpenAI<CallOptions> implements Partial<OpenAIChatInput> {
+export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = ChatOpenAICallOptions> extends BaseChatOpenAI<CallOptions> {
     /**
      * 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;
-    private responses;
-    private completions;
+    protected responses: ChatOpenAIResponses;
+    protected completions: ChatOpenAICompletions;
     get lc_serializable_keys(): string[];
     constructor(fields?: ChatOpenAIFields);
     protected _useResponsesApi(options: this["ParsedCallOptions"] | undefined): boolean;
+    getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
+    invocationParams(options?: this["ParsedCallOptions"]): ChatResponsesInvocationParams | ChatCompletionsInvocationParams;
     /** @ignore */
     _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
     _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;

package/dist/chat_models.js

@@ -8,7 +8,7 @@ import { RunnableLambda, RunnablePassthrough, RunnableSequence, } from "@langcha
 import { JsonOutputParser, StructuredOutputParser, } from "@langchain/core/output_parsers";
 import { JsonOutputKeyToolsParser, convertLangChainToolCallToOpenAI, makeInvalidToolCall, parseToolCall, } from "@langchain/core/output_parsers/openai_tools";
 import { getSchemaDescription, isInteropZodSchema, } from "@langchain/core/utils/types";
-import { toJsonSchema, } from "@langchain/core/utils/json_schema";
+import { toJsonSchema } from "@langchain/core/utils/json_schema";
 import { getEndpoint } from "./utils/azure.js";
 import { formatToOpenAIToolChoice, interopZodResponseFormat, wrapOpenAIClientError, } from "./utils/openai.js";
 import { formatFunctionDefinitions, } from "./utils/openai-format-fndef.js";
@@ -252,7 +252,7 @@ export function _convertMessagesToOpenAIParams(messages, model) {
     });
 }
 /** @internal */
-class BaseChatOpenAI extends BaseChatModel {
+export class BaseChatOpenAI extends BaseChatModel {
     _llmType() {
         return "openai";
     }
@@ -471,12 +471,14 @@ class BaseChatOpenAI extends BaseChatModel {
             writable: true,
             value: void 0
         });
+        /** @internal */
         Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /** @internal */
         Object.defineProperty(this, "clientConfig", {
             enumerable: true,
             configurable: true,
@@ -538,6 +540,12 @@ class BaseChatOpenAI extends BaseChatModel {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "defaultOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "lc_serializable", {
             enumerable: true,
             configurable: true,
@@ -632,6 +640,13 @@ class BaseChatOpenAI extends BaseChatModel {
         }
         return resFormat;
     }
+    _combineCallOptions(additionalOptions) {
+        return {
+            ...this.defaultOptions,
+            ...(additionalOptions ?? {}),
+        };
+    }
+    /** @internal */
     _getClientOptions(options) {
         if (!this.client) {
             const openAIEndpointConfig = {
@@ -686,6 +701,12 @@ class BaseChatOpenAI extends BaseChatModel {
             ...kwargs,
         });
     }
+    async stream(input, options) {
+        return super.stream(input, this._combineCallOptions(options));
+    }
+    async invoke(input, options) {
+        return super.invoke(input, this._combineCallOptions(options));
+    }
     /** @ignore */
     _combineLLMOutput(...llmOutputs) {
         return llmOutputs.reduce((acc, llmOutput) => {
@@ -793,13 +814,22 @@ class BaseChatOpenAI extends BaseChatModel {
         }
         return tokens;
     }
+    /** @internal */
+    _getStructuredOutputMethod(config) {
+        const ensuredConfig = { ...config };
+        if (!this.model.startsWith("gpt-3") &&
+            !this.model.startsWith("gpt-4-") &&
+            this.model !== "gpt-4") {
+            if (ensuredConfig?.method === undefined) {
+                return "jsonSchema";
+            }
+        }
+        else if (ensuredConfig.method === "jsonSchema") {
+            console.warn(`[WARNING]: JSON Schema is not supported for model "${this.model}". Falling back to tool calling.`);
+        }
+        return ensuredConfig.method;
+    }
     withStructuredOutput(outputSchema, config) {
-        // ):
-        // | Runnable<BaseLanguageModelInput, RunOutput>
-        // | Runnable<
-        //     BaseLanguageModelInput,
-        //     { raw: BaseMessage; parsed: RunOutput }
-        //   > {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let schema;
         let name;
@@ -822,47 +852,43 @@ class BaseChatOpenAI extends BaseChatModel {
         if (config?.strict !== undefined && method === "jsonMode") {
             throw new Error("Argument `strict` is only supported for `method` = 'function_calling'");
         }
-        if (!this.model.startsWith("gpt-3") &&
-            !this.model.startsWith("gpt-4-") &&
-            this.model !== "gpt-4") {
-            if (method === undefined) {
-                method = "jsonSchema";
-            }
-        }
-        else if (method === "jsonSchema") {
-            console.warn(`[WARNING]: JSON Schema is not supported for model "${this.model}". Falling back to tool calling.`);
-        }
+        method = this._getStructuredOutputMethod({ ...config, method });
         if (method === "jsonMode") {
-            let outputFormatSchema;
             if (isInteropZodSchema(schema)) {
                 outputParser = StructuredOutputParser.fromZodSchema(schema);
-                outputFormatSchema = toJsonSchema(schema);
             }
             else {
                 outputParser = new JsonOutputParser();
             }
+            const asJsonSchema = toJsonSchema(schema);
             llm = this.withConfig({
                 response_format: { type: "json_object" },
                 ls_structured_output_format: {
-                    kwargs: { method: "jsonMode" },
-                    schema: outputFormatSchema,
+                    kwargs: { method: "json_mode" },
+                    schema: { title: name ?? "extract", ...asJsonSchema },
                 },
             });
         }
         else if (method === "jsonSchema") {
+            const openaiJsonSchemaParams = {
+                name: name ?? "extract",
+                description: getSchemaDescription(schema),
+                schema,
+                strict: config?.strict,
+            };
+            const asJsonSchema = toJsonSchema(openaiJsonSchemaParams.schema);
             llm = this.withConfig({
                 response_format: {
                     type: "json_schema",
-                    json_schema: {
-                        name: name ?? "extract",
-                        description: getSchemaDescription(schema),
-                        schema,
-                        strict: config?.strict,
-                    },
+                    json_schema: openaiJsonSchemaParams,
                 },
                 ls_structured_output_format: {
-                    kwargs: { method: "jsonSchema" },
-                    schema: toJsonSchema(schema),
+                    kwargs: { method: "json_schema" },
+                    schema: {
+                        title: openaiJsonSchemaParams.name,
+                        description: openaiJsonSchemaParams.description,
+                        ...asJsonSchema,
+                    },
                 },
             });
             if (isInteropZodSchema(schema)) {
@@ -901,8 +927,8 @@ class BaseChatOpenAI extends BaseChatModel {
                         },
                     },
                     ls_structured_output_format: {
-                        kwargs: { method: "functionCalling" },
-                        schema: asJsonSchema,
+                        kwargs: { method: "function_calling" },
+                        schema: { title: functionName, ...asJsonSchema },
                     },
                     // Do not pass `strict` argument to OpenAI if `config.strict` is undefined
                     ...(config?.strict !== undefined ? { strict: config.strict } : {}),
@@ -929,6 +955,7 @@ class BaseChatOpenAI extends BaseChatModel {
                         parameters: schema,
                     };
                 }
+                const asJsonSchema = toJsonSchema(schema);
                 llm = this.withConfig({
                     tools: [
                         {
@@ -943,8 +970,8 @@ class BaseChatOpenAI extends BaseChatModel {
                         },
                     },
                     ls_structured_output_format: {
-                        kwargs: { method: "functionCalling" },
-                        schema: toJsonSchema(schema),
+                        kwargs: { method: "function_calling" },
+                        schema: { title: functionName, ...asJsonSchema },
                     },
                     // Do not pass `strict` argument to OpenAI if `config.strict` is undefined
                     ...(config?.strict !== undefined ? { strict: config.strict } : {}),
@@ -2583,7 +2610,7 @@ export class ChatOpenAI extends BaseChatOpenAI {
         return [...super.lc_serializable_keys, "useResponsesApi"];
     }
     constructor(fields) {
-        super(fields ?? {});
+        super(fields);
         /**
          * 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.
@@ -2607,8 +2634,8 @@ export class ChatOpenAI extends BaseChatOpenAI {
             value: void 0
         });
         this.useResponsesApi = fields?.useResponsesApi ?? false;
-        this.responses = new ChatOpenAIResponses(fields);
-        this.completions = new ChatOpenAICompletions(fields);
+        this.responses = fields?.responses ?? new ChatOpenAIResponses(fields);
+        this.completions = fields?.completions ?? new ChatOpenAICompletions(fields);
     }
     _useResponsesApi(options) {
         const usesBuiltInTools = options?.tools?.some(isBuiltInTool);
@@ -2620,6 +2647,20 @@ export class ChatOpenAI extends BaseChatOpenAI {
             this.reasoning?.summary != null;
         return this.useResponsesApi || usesBuiltInTools || hasResponsesOnlyKwargs;
     }
+    getLsParams(options) {
+        const optionsWithDefaults = this._combineCallOptions(options);
+        if (this._useResponsesApi(options)) {
+            return this.responses.getLsParams(optionsWithDefaults);
+        }
+        return this.completions.getLsParams(optionsWithDefaults);
+    }
+    invocationParams(options) {
+        const optionsWithDefaults = this._combineCallOptions(options);
+        if (this._useResponsesApi(options)) {
+            return this.responses.invocationParams(optionsWithDefaults);
+        }
+        return this.completions.invocationParams(optionsWithDefaults);
+    }
     /** @ignore */
     async _generate(messages, options, runManager) {
         if (this._useResponsesApi(options)) {
@@ -2629,32 +2670,13 @@ export class ChatOpenAI extends BaseChatOpenAI {
     }
     async *_streamResponseChunks(messages, options, runManager) {
         if (this._useResponsesApi(options)) {
-            yield* this.responses._streamResponseChunks(messages, options);
+            yield* this.responses._streamResponseChunks(messages, this._combineCallOptions(options));
             return;
         }
-        yield* this.completions._streamResponseChunks(messages, options, runManager);
+        yield* this.completions._streamResponseChunks(messages, this._combineCallOptions(options), runManager);
     }
     withConfig(config) {
-        // FIXME: assigning additional config options to the inner chat classes this way
-        // is awkward, but it's the only way to preserve the original object identity
-        // and still thread config options, which is important since this class is a "proxy"
-        // for the inner chat classes. This will be fixed in a later version of langchain
-        // when the core runnable interface is improved (0.4) to support this out of the box.
-        const bindChatOpenAIConfig = (cls, config) => {
-            const oldGenerate = cls._generate;
-            const oldStreamResponseChunks = cls._streamResponseChunks;
-            return Object.assign(cls, {
-                _generate(messages, options, runManager) {
-                    return oldGenerate.call(cls, messages, { ...options, ...config }, runManager);
-                },
-                _streamResponseChunks(messages, options, runManager) {
-                    return oldStreamResponseChunks.call(cls, messages, { ...options, ...config }, runManager);
-                },
-            });
-        };
-        this.responses = bindChatOpenAIConfig(this.responses, config);
-        this.completions = bindChatOpenAIConfig(this.completions, config);
-        // Proxy chat class is also bound for `_useResponsesApi`,
-        return bindChatOpenAIConfig(this, config);
+        this.defaultOptions = { ...this.defaultOptions, ...config };
+        return this;
     }
 }