@langchain/openai 0.6.2 → 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,
@@ -817,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;
@@ -846,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)) {
@@ -925,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 } : {}),
@@ -953,6 +960,7 @@ class BaseChatOpenAI extends chat_models_1.BaseChatModel {
                         parameters: schema,
                     };
                 }
+                const asJsonSchema = (0, json_schema_1.toJsonSchema)(schema);
                 llm = this.withConfig({
                     tools: [
                         {
@@ -967,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 } : {}),
@@ -995,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.
  *
@@ -2609,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.
@@ -2633,11 +2642,8 @@ class ChatOpenAI extends BaseChatOpenAI {
             value: void 0
         });
         this.useResponsesApi = fields?.useResponsesApi ?? false;
-        this.responses = new ChatOpenAIResponses(fields);
-        this.completions = new ChatOpenAICompletions(fields);
-        // Override `_getClientOptions` so sub classes of ChatOpenAI use the same client config
-        this.responses._getClientOptions = this._getClientOptions;
-        this.completions._getClientOptions = this._getClientOptions;
+        this.responses = fields?.responses ?? new ChatOpenAIResponses(fields);
+        this.completions = fields?.completions ?? new ChatOpenAICompletions(fields);
     }
     _useResponsesApi(options) {
         const usesBuiltInTools = options?.tools?.some(isBuiltInTool);

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.
@@ -219,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;
@@ -236,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.
@@ -290,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">;
 /**
@@ -318,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.
@@ -857,14 +871,14 @@ 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;

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,
@@ -812,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;
@@ -841,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)) {
@@ -920,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 } : {}),
@@ -948,6 +955,7 @@ class BaseChatOpenAI extends BaseChatModel {
                         parameters: schema,
                     };
                 }
+                const asJsonSchema = toJsonSchema(schema);
                 llm = this.withConfig({
                     tools: [
                         {
@@ -962,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 } : {}),
@@ -2602,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.
@@ -2626,11 +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);
-        // Override `_getClientOptions` so sub classes of ChatOpenAI use the same client config
-        this.responses._getClientOptions = this._getClientOptions;
-        this.completions._getClientOptions = this._getClientOptions;
+        this.responses = fields?.responses ?? new ChatOpenAIResponses(fields);
+        this.completions = fields?.completions ?? new ChatOpenAICompletions(fields);
     }
     _useResponsesApi(options) {
         const usesBuiltInTools = options?.tools?.some(isBuiltInTool);

package/dist/types.d.ts

@@ -155,7 +155,7 @@ export interface OpenAIChatInput extends OpenAIBaseInput {
      */
     service_tier?: OpenAIClient.Responses.ResponseCreateParams["service_tier"];
 }
-export declare interface AzureOpenAIInput {
+export interface AzureOpenAIInput {
     /**
      * API version to use when making requests to Azure OpenAI.
      */
@@ -213,6 +213,12 @@ export declare interface AzureOpenAIInput {
      */
     azureADTokenProvider?: () => Promise<string>;
 }
+export interface AzureOpenAIChatInput extends OpenAIChatInput, AzureOpenAIInput {
+    openAIApiKey?: string;
+    openAIApiVersion?: string;
+    openAIBasePath?: string;
+    deploymentName?: string;
+}
 type ChatOpenAIResponseFormatJSONSchema = Omit<ResponseFormatJSONSchema, "json_schema"> & {
     json_schema: Omit<ResponseFormatJSONSchema["json_schema"], "schema"> & {
         /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/openai",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "OpenAI integrations for LangChain.js",
   "type": "module",
   "engines": {