@langchain/openai 0.2.5 → 0.2.6

package/dist/chat_models.cjs

@@ -6,6 +6,7 @@ const messages_1 = require("@langchain/core/messages");
 const outputs_1 = require("@langchain/core/outputs");
 const env_1 = require("@langchain/core/utils/env");
 const chat_models_1 = require("@langchain/core/language_models/chat_models");
+const base_1 = require("@langchain/core/language_models/base");
 const function_calling_1 = require("@langchain/core/utils/function_calling");
 const runnables_1 = require("@langchain/core/runnables");
 const output_parsers_1 = require("@langchain/core/output_parsers");
@@ -184,6 +185,21 @@ function convertMessagesToOpenAIParams(messages) {
         return completionParam;
     });
 }
+function _convertChatOpenAIToolTypeToOpenAITool(tool, fields) {
+    if ((0, base_1.isOpenAITool)(tool)) {
+        if (fields?.strict !== undefined) {
+            return {
+                ...tool,
+                function: {
+                    ...tool.function,
+                    strict: fields.strict,
+                },
+            };
+        }
+        return tool;
+    }
+    return (0, function_calling_1.convertToOpenAITool)(tool, fields);
+}
 /**
  * Wrapper around OpenAI large language models that use the Chat endpoint.
  *
@@ -443,6 +459,16 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
             writable: true,
             value: void 0
         });
+        /**
+         * Whether the model supports the `strict` argument when passing in tools.
+         * If `undefined` the `strict` argument will not be passed to OpenAI.
+         */
+        Object.defineProperty(this, "supportsStrictToolCalling", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.openAIApiKey =
             fields?.apiKey ??
                 fields?.openAIApiKey ??
@@ -515,6 +541,11 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
             ...configuration,
             ...fields?.configuration,
         };
+        // If `supportsStrictToolCalling` is explicitly set, use that value.
+        // Else leave undefined so it's not passed to OpenAI.
+        if (fields?.supportsStrictToolCalling !== undefined) {
+            this.supportsStrictToolCalling = fields.supportsStrictToolCalling;
+        }
     }
     getLsParams(options) {
         const params = this.invocationParams(options);
@@ -528,8 +559,15 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
         };
     }
     bindTools(tools, kwargs) {
+        let strict;
+        if (kwargs?.strict !== undefined) {
+            strict = kwargs.strict;
+        }
+        else if (this.supportsStrictToolCalling !== undefined) {
+            strict = this.supportsStrictToolCalling;
+        }
         return this.bind({
-            tools: tools.map(function_calling_1.convertToOpenAITool),
+            tools: tools.map((tool) => _convertChatOpenAIToolTypeToOpenAITool(tool, { strict })),
             ...kwargs,
         });
     }
@@ -537,9 +575,12 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
      * Get the parameters used to invoke the model
      */
     invocationParams(options, extra) {
-        function isStructuredToolArray(tools) {
-            return (tools !== undefined &&
-                tools.every((tool) => Array.isArray(tool.lc_namespace)));
+        let strict;
+        if (options?.strict !== undefined) {
+            strict = options.strict;
+        }
+        else if (this.supportsStrictToolCalling !== undefined) {
+            strict = this.supportsStrictToolCalling;
         }
         let streamOptionsConfig = {};
         if (options?.stream_options !== undefined) {
@@ -565,9 +606,9 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
             stream: this.streaming,
             functions: options?.functions,
             function_call: options?.function_call,
-            tools: isStructuredToolArray(options?.tools)
-                ? options?.tools.map(function_calling_1.convertToOpenAITool)
-                : options?.tools,
+            tools: options?.tools?.length
+                ? options.tools.map((tool) => _convertChatOpenAIToolTypeToOpenAITool(tool, { strict }))
+                : undefined,
             tool_choice: (0, openai_js_1.formatToOpenAIToolChoice)(options?.tool_choice),
             response_format: options?.response_format,
             seed: options?.seed,
@@ -928,6 +969,9 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
         }
         let llm;
         let outputParser;
+        if (config?.strict !== undefined && method === "jsonMode") {
+            throw new Error("Argument `strict` is only supported for `method` = 'function_calling'");
+        }
         if (method === "jsonMode") {
             llm = this.bind({
                 response_format: { type: "json_object" },
@@ -961,6 +1005,8 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
                             name: functionName,
                         },
                     },
+                    // Do not pass `strict` argument to OpenAI if `config.strict` is undefined
+                    ...(config?.strict !== undefined ? { strict: config.strict } : {}),
                 });
                 outputParser = new openai_tools_1.JsonOutputKeyToolsParser({
                     returnSingle: true,
@@ -997,6 +1043,8 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
                             name: functionName,
                         },
                     },
+                    // Do not pass `strict` argument to OpenAI if `config.strict` is undefined
+                    ...(config?.strict !== undefined ? { strict: config.strict } : {}),
                 });
                 outputParser = new openai_tools_1.JsonOutputKeyToolsParser({
                     returnSingle: true,

package/dist/chat_models.d.ts

@@ -2,11 +2,10 @@ import { type ClientOptions, OpenAI as OpenAIClient } from "openai";
 import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
 import { AIMessageChunk, type BaseMessage } from "@langchain/core/messages";
 import { ChatGenerationChunk, type ChatResult } from "@langchain/core/outputs";
-import { type StructuredToolInterface } from "@langchain/core/tools";
-import { BaseChatModel, LangSmithParams, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
-import type { BaseFunctionCallOptions, BaseLanguageModelInput, StructuredOutputMethodOptions, StructuredOutputMethodParams } from "@langchain/core/language_models/base";
+import { BaseChatModel, BindToolsInput, LangSmithParams, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
+import { type BaseFunctionCallOptions, type BaseLanguageModelInput, type StructuredOutputMethodOptions, type StructuredOutputMethodParams } from "@langchain/core/language_models/base";
 import { z } from "zod";
-import { Runnable, RunnableToolLike } from "@langchain/core/runnables";
+import { Runnable } from "@langchain/core/runnables";
 import type { AzureOpenAIInput, OpenAICallOptions, OpenAIChatInput, OpenAICoreRequestOptions, LegacyOpenAIInput } from "./types.js";
 import { OpenAIToolChoice } from "./utils/openai.js";
 export type { AzureOpenAIInput, OpenAICallOptions, OpenAIChatInput };
@@ -20,8 +19,26 @@ interface OpenAILLMOutput {
 }
 type OpenAIRoleEnum = "system" | "assistant" | "user" | "function" | "tool";
 export declare function messageToOpenAIRole(message: BaseMessage): OpenAIRoleEnum;
+type ChatOpenAIToolType = BindToolsInput | OpenAIClient.ChatCompletionTool;
+export interface ChatOpenAIStructuredOutputMethodOptions<IncludeRaw extends boolean> extends StructuredOutputMethodOptions<IncludeRaw> {
+    /**
+     * strict: If `true` and `method` = "function_calling", model output is
+     * guaranteed to exactly match the schema. If `true`, the input schema
+     * will also be validated according to
+     * https://platform.openai.com/docs/guides/structured-outputs/supported-schemas.
+     * If `false`, input schema will not be validated and model output will not
+     * be validated.
+     * If `undefined`, `strict` argument will not be passed to the model.
+     *
+     * @version 0.2.6
+     * @note Planned breaking change in version `0.3.0`:
+     * `strict` will default to `true` when `method` is
+     * "function_calling" as of version `0.3.0`.
+     */
+    strict?: boolean;
+}
 export interface ChatOpenAICallOptions extends OpenAICallOptions, BaseFunctionCallOptions {
-    tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[];
+    tools?: ChatOpenAIToolType[];
     tool_choice?: OpenAIToolChoice;
     promptIndex?: number;
     response_format?: {
@@ -45,6 +62,23 @@ export interface ChatOpenAICallOptions extends OpenAICallOptions, BaseFunctionCa
      * call multiple tools in one response.
      */
     parallel_tool_calls?: boolean;
+    /**
+     * If `true`, model output is guaranteed to exactly match the JSON Schema
+     * provided in the tool definition. If `true`, the input schema will also be
+     * validated according to
+     * https://platform.openai.com/docs/guides/structured-outputs/supported-schemas.
+     *
+     * If `false`, input schema will not be validated and model output will not
+     * be validated.
+     *
+     * If `undefined`, `strict` argument will not be passed to the model.
+     *
+     * @version 0.2.6
+     */
+    strict?: boolean;
+}
+export interface ChatOpenAIFields extends Partial<OpenAIChatInput>, Partial<AzureOpenAIInput>, BaseChatModelParams {
+    configuration?: ClientOptions & LegacyOpenAIInput;
 }
 /**
  * Wrapper around OpenAI large language models that use the Chat endpoint.
@@ -117,13 +151,16 @@ export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = Chat
     __includeRawResponse?: boolean;
     protected client: OpenAIClient;
     protected clientConfig: ClientOptions;
-    constructor(fields?: Partial<OpenAIChatInput> & Partial<AzureOpenAIInput> & BaseChatModelParams & {
-        configuration?: ClientOptions & LegacyOpenAIInput;
-    }, 
+    /**
+     * Whether the model supports the `strict` argument when passing in tools.
+     * If `undefined` the `strict` argument will not be passed to OpenAI.
+     */
+    supportsStrictToolCalling?: boolean;
+    constructor(fields?: ChatOpenAIFields, 
     /** @deprecated */
     configuration?: ClientOptions & LegacyOpenAIInput);
     getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
-    bindTools(tools: (Record<string, unknown> | StructuredToolInterface | RunnableToolLike)[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, CallOptions>;
+    bindTools(tools: ChatOpenAIToolType[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, CallOptions>;
     /**
      * Get the parameters used to invoke the model
      */
@@ -169,8 +206,8 @@ export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = Chat
     _llmType(): string;
     /** @ignore */
     _combineLLMOutput(...llmOutputs: OpenAILLMOutput[]): OpenAILLMOutput;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: StructuredOutputMethodParams<RunOutput, false> | z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: StructuredOutputMethodParams<RunOutput, true> | z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: StructuredOutputMethodParams<RunOutput, false> | z.ZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: StructuredOutputMethodParams<RunOutput, true> | z.ZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;
         parsed: RunOutput;
     }>;

package/dist/chat_models.js

@@ -3,6 +3,7 @@ import { AIMessage, AIMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessa
 import { ChatGenerationChunk, } from "@langchain/core/outputs";
 import { getEnvironmentVariable } from "@langchain/core/utils/env";
 import { BaseChatModel, } from "@langchain/core/language_models/chat_models";
+import { isOpenAITool, } from "@langchain/core/language_models/base";
 import { convertToOpenAITool } from "@langchain/core/utils/function_calling";
 import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnables";
 import { JsonOutputParser, StructuredOutputParser, } from "@langchain/core/output_parsers";
@@ -180,6 +181,21 @@ function convertMessagesToOpenAIParams(messages) {
         return completionParam;
     });
 }
+function _convertChatOpenAIToolTypeToOpenAITool(tool, fields) {
+    if (isOpenAITool(tool)) {
+        if (fields?.strict !== undefined) {
+            return {
+                ...tool,
+                function: {
+                    ...tool.function,
+                    strict: fields.strict,
+                },
+            };
+        }
+        return tool;
+    }
+    return convertToOpenAITool(tool, fields);
+}
 /**
  * Wrapper around OpenAI large language models that use the Chat endpoint.
  *
@@ -439,6 +455,16 @@ export class ChatOpenAI extends BaseChatModel {
             writable: true,
             value: void 0
         });
+        /**
+         * Whether the model supports the `strict` argument when passing in tools.
+         * If `undefined` the `strict` argument will not be passed to OpenAI.
+         */
+        Object.defineProperty(this, "supportsStrictToolCalling", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.openAIApiKey =
             fields?.apiKey ??
                 fields?.openAIApiKey ??
@@ -511,6 +537,11 @@ export class ChatOpenAI extends BaseChatModel {
             ...configuration,
             ...fields?.configuration,
         };
+        // If `supportsStrictToolCalling` is explicitly set, use that value.
+        // Else leave undefined so it's not passed to OpenAI.
+        if (fields?.supportsStrictToolCalling !== undefined) {
+            this.supportsStrictToolCalling = fields.supportsStrictToolCalling;
+        }
     }
     getLsParams(options) {
         const params = this.invocationParams(options);
@@ -524,8 +555,15 @@ export class ChatOpenAI extends BaseChatModel {
         };
     }
     bindTools(tools, kwargs) {
+        let strict;
+        if (kwargs?.strict !== undefined) {
+            strict = kwargs.strict;
+        }
+        else if (this.supportsStrictToolCalling !== undefined) {
+            strict = this.supportsStrictToolCalling;
+        }
         return this.bind({
-            tools: tools.map(convertToOpenAITool),
+            tools: tools.map((tool) => _convertChatOpenAIToolTypeToOpenAITool(tool, { strict })),
             ...kwargs,
         });
     }
@@ -533,9 +571,12 @@ export class ChatOpenAI extends BaseChatModel {
      * Get the parameters used to invoke the model
      */
     invocationParams(options, extra) {
-        function isStructuredToolArray(tools) {
-            return (tools !== undefined &&
-                tools.every((tool) => Array.isArray(tool.lc_namespace)));
+        let strict;
+        if (options?.strict !== undefined) {
+            strict = options.strict;
+        }
+        else if (this.supportsStrictToolCalling !== undefined) {
+            strict = this.supportsStrictToolCalling;
         }
         let streamOptionsConfig = {};
         if (options?.stream_options !== undefined) {
@@ -561,9 +602,9 @@ export class ChatOpenAI extends BaseChatModel {
             stream: this.streaming,
             functions: options?.functions,
             function_call: options?.function_call,
-            tools: isStructuredToolArray(options?.tools)
-                ? options?.tools.map(convertToOpenAITool)
-                : options?.tools,
+            tools: options?.tools?.length
+                ? options.tools.map((tool) => _convertChatOpenAIToolTypeToOpenAITool(tool, { strict }))
+                : undefined,
             tool_choice: formatToOpenAIToolChoice(options?.tool_choice),
             response_format: options?.response_format,
             seed: options?.seed,
@@ -924,6 +965,9 @@ export class ChatOpenAI extends BaseChatModel {
         }
         let llm;
         let outputParser;
+        if (config?.strict !== undefined && method === "jsonMode") {
+            throw new Error("Argument `strict` is only supported for `method` = 'function_calling'");
+        }
         if (method === "jsonMode") {
             llm = this.bind({
                 response_format: { type: "json_object" },
@@ -957,6 +1001,8 @@ export class ChatOpenAI extends BaseChatModel {
                             name: functionName,
                         },
                     },
+                    // Do not pass `strict` argument to OpenAI if `config.strict` is undefined
+                    ...(config?.strict !== undefined ? { strict: config.strict } : {}),
                 });
                 outputParser = new JsonOutputKeyToolsParser({
                     returnSingle: true,
@@ -993,6 +1039,8 @@ export class ChatOpenAI extends BaseChatModel {
                             name: functionName,
                         },
                     },
+                    // Do not pass `strict` argument to OpenAI if `config.strict` is undefined
+                    ...(config?.strict !== undefined ? { strict: config.strict } : {}),
                 });
                 outputParser = new JsonOutputKeyToolsParser({
                     returnSingle: true,

package/dist/types.d.ts

@@ -121,6 +121,11 @@ export interface OpenAIChatInput extends OpenAIBaseInput {
      * Currently in experimental beta.
      */
     __includeRawResponse?: boolean;
+    /**
+     * Whether the model supports the `strict` argument when passing in tools.
+     * If `undefined` the `strict` argument will not be passed to OpenAI.
+     */
+    supportsStrictToolCalling?: boolean;
 }
 export declare interface AzureOpenAIInput {
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/openai",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "OpenAI integrations for LangChain.js",
   "type": "module",
   "engines": {
@@ -15,7 +15,7 @@
   "homepage": "https://github.com/langchain-ai/langchainjs/tree/main/libs/langchain-openai/",
   "scripts": {
     "build": "yarn turbo:command build:internal --filter=@langchain/openai",
-    "build:internal": "yarn lc-build:v2 --create-entrypoints --pre --tree-shaking",
+    "build:internal": "yarn lc_build_v2 --create-entrypoints --pre --tree-shaking",
     "lint:eslint": "NODE_OPTIONS=--max-old-space-size=4096 eslint --cache --ext .ts,.js src/",
     "lint:dpdm": "dpdm --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts",
     "lint": "yarn lint:eslint && yarn lint:dpdm",
@@ -35,16 +35,16 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@langchain/core": ">=0.2.16 <0.3.0",
+    "@langchain/core": ">=0.2.21 <0.3.0",
     "js-tiktoken": "^1.0.12",
-    "openai": "^4.49.1",
+    "openai": "^4.55.0",
     "zod": "^3.22.4",
     "zod-to-json-schema": "^3.22.3"
   },
   "devDependencies": {
-    "@azure/identity": "^4.2.0",
+    "@azure/identity": "^4.2.1",
     "@jest/globals": "^29.5.0",
-    "@langchain/scripts": "~0.0.14",
+    "@langchain/scripts": "~0.0.20",
     "@langchain/standard-tests": "0.0.0",
     "@swc/core": "^1.3.90",
     "@swc/jest": "^0.2.29",
@@ -59,7 +59,7 @@
     "jest": "^29.5.0",
     "jest-environment-node": "^29.6.4",
     "prettier": "^2.8.3",
-    "release-it": "^15.10.1",
+    "release-it": "^17.6.0",
     "rimraf": "^5.0.1",
     "ts-jest": "^29.1.0",
     "typescript": "~5.1.6"

package/dist/tools/tests/dalle.int.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tools/tests/dalle.int.test.js

@@ -1,57 +0,0 @@
-import { test, expect } from "@jest/globals";
-import { DallEAPIWrapper } from "../dalle.js";
-test.skip("Dalle can generate images", async () => {
-    const dalle = new DallEAPIWrapper();
-    const res = await dalle.invoke("A painting of a cat");
-    expect(res).toBeDefined();
-    expect(res).toContain("https://");
-});
-test.skip("Dalle can generate images with base 64 response format", async () => {
-    const dalle = new DallEAPIWrapper({
-        responseFormat: "b64_json",
-    });
-    const res = await dalle.invoke("A painting of a cat");
-    expect(res).toBeDefined();
-    expect(res).not.toContain("https://");
-});
-test.skip("Dalle returns multiple image URLs if n > 1", async () => {
-    const dalle = new DallEAPIWrapper({
-        n: 2,
-    });
-    const res = await dalle.invoke("A painting of a cat");
-    expect(res).toBeDefined();
-    expect(res).toBeInstanceOf(Array);
-    if (!Array.isArray(res))
-        return;
-    expect(res).toHaveLength(2);
-    // The types for each should be `image_url` with an `image_url` field containing the URL
-    expect(res[0].type).toBe("image_url");
-    expect(res[1].type).toBe("image_url");
-    expect(res[0]).toHaveProperty("image_url");
-    expect(res[1]).toHaveProperty("image_url");
-    expect(res[0].image_url.startsWith("https://")).toBe(true);
-    expect(res[1].image_url.startsWith("https://")).toBe(true);
-});
-test.skip("Dalle returns multiple base64 image strings if n > 1", async () => {
-    const dalle = new DallEAPIWrapper({
-        n: 2,
-        dallEResponseFormat: "b64_json",
-    });
-    const res = await dalle.invoke("A painting of a cat");
-    expect(res).toBeDefined();
-    expect(res).toBeInstanceOf(Array);
-    if (!Array.isArray(res))
-        return;
-    expect(res).toHaveLength(2);
-    // The types for each should be `b64_json` with an `b64_json` field containing the URL
-    expect(res[0].type).toBe("image_url");
-    expect(res[1].type).toBe("image_url");
-    expect(res[0]).toHaveProperty("image_url");
-    expect(res[1]).toHaveProperty("image_url");
-    expect(res[0].image_url).toHaveProperty("url");
-    expect(res[1].image_url).toHaveProperty("url");
-    expect(res[0].image_url.url).toBeDefined();
-    expect(res[1].image_url.url).toBeDefined();
-    expect(res[0].image_url.url).not.toBe("");
-    expect(res[1].image_url.url).not.toBe("");
-});