@langchain/openai 0.0.18 → 0.0.20

package/dist/chat_models.cjs

@@ -470,10 +470,18 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
                 console.log("[WARNING]: Received non-string content from OpenAI. This is currently not supported.");
                 continue;
             }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const generationInfo = { ...newTokenIndices };
+            if (choice.finish_reason !== undefined) {
+                generationInfo.finish_reason = choice.finish_reason;
+            }
+            if (this.logprobs) {
+                generationInfo.logprobs = choice.logprobs;
+            }
             const generationChunk = new outputs_1.ChatGenerationChunk({
                 message: chunk,
                 text: chunk.content,
-                generationInfo: newTokenIndices,
+                generationInfo,
             });
             yield generationChunk;
             // eslint-disable-next-line no-void
@@ -499,6 +507,10 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
             const stream = this._streamResponseChunks(messages, options, runManager);
             const finalChunks = {};
             for await (const chunk of stream) {
+                chunk.message.response_metadata = {
+                    ...chunk.generationInfo,
+                    ...chunk.message.response_metadata,
+                };
                 const index = chunk.generationInfo?.completion ?? 0;
                 if (finalChunks[index] === undefined) {
                     finalChunks[index] = chunk;
@@ -742,21 +754,26 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
             llm = this.bind({
                 response_format: { type: "json_object" },
             });
-            outputParser = new output_parsers_1.JsonOutputParser();
+            if (isZodSchema(schema)) {
+                outputParser = output_parsers_1.StructuredOutputParser.fromZodSchema(schema);
+            }
+            else {
+                outputParser = new output_parsers_1.JsonOutputParser();
+            }
         }
         else {
             const functionName = name ?? "extract";
             // Is function calling
             if (isZodSchema(schema)) {
-                const asZodSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(schema);
+                const asJsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(schema);
                 llm = this.bind({
                     tools: [
                         {
                             type: "function",
                             function: {
                                 name: functionName,
-                                description: asZodSchema.description,
-                                parameters: asZodSchema,
+                                description: asJsonSchema.description,
+                                parameters: asJsonSchema,
                             },
                         },
                     ],
@@ -770,6 +787,7 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
                 outputParser = new openai_tools_1.JsonOutputKeyToolsParser({
                     returnSingle: true,
                     keyName: functionName,
+                    zodSchema: schema,
                 });
             }
             else {
@@ -819,7 +837,9 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
     }
 }
 exports.ChatOpenAI = ChatOpenAI;
-function isZodSchema(input) {
+function isZodSchema(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+input) {
     // Check for a characteristic method of Zod schemas
     return typeof input?.parse === "function";
 }

package/dist/chat_models.js

@@ -5,7 +5,7 @@ import { getEnvironmentVariable } from "@langchain/core/utils/env";
 import { BaseChatModel, } from "@langchain/core/language_models/chat_models";
 import { convertToOpenAITool } from "@langchain/core/utils/function_calling";
 import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnables";
-import { JsonOutputParser } from "@langchain/core/output_parsers";
+import { JsonOutputParser, StructuredOutputParser, } from "@langchain/core/output_parsers";
 import { JsonOutputKeyToolsParser } from "@langchain/core/output_parsers/openai_tools";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { getEndpoint } from "./utils/azure.js";
@@ -466,10 +466,18 @@ export class ChatOpenAI extends BaseChatModel {
                 console.log("[WARNING]: Received non-string content from OpenAI. This is currently not supported.");
                 continue;
             }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const generationInfo = { ...newTokenIndices };
+            if (choice.finish_reason !== undefined) {
+                generationInfo.finish_reason = choice.finish_reason;
+            }
+            if (this.logprobs) {
+                generationInfo.logprobs = choice.logprobs;
+            }
             const generationChunk = new ChatGenerationChunk({
                 message: chunk,
                 text: chunk.content,
-                generationInfo: newTokenIndices,
+                generationInfo,
             });
             yield generationChunk;
             // eslint-disable-next-line no-void
@@ -495,6 +503,10 @@ export class ChatOpenAI extends BaseChatModel {
             const stream = this._streamResponseChunks(messages, options, runManager);
             const finalChunks = {};
             for await (const chunk of stream) {
+                chunk.message.response_metadata = {
+                    ...chunk.generationInfo,
+                    ...chunk.message.response_metadata,
+                };
                 const index = chunk.generationInfo?.completion ?? 0;
                 if (finalChunks[index] === undefined) {
                     finalChunks[index] = chunk;
@@ -738,21 +750,26 @@ export class ChatOpenAI extends BaseChatModel {
             llm = this.bind({
                 response_format: { type: "json_object" },
             });
-            outputParser = new JsonOutputParser();
+            if (isZodSchema(schema)) {
+                outputParser = StructuredOutputParser.fromZodSchema(schema);
+            }
+            else {
+                outputParser = new JsonOutputParser();
+            }
         }
         else {
             const functionName = name ?? "extract";
             // Is function calling
             if (isZodSchema(schema)) {
-                const asZodSchema = zodToJsonSchema(schema);
+                const asJsonSchema = zodToJsonSchema(schema);
                 llm = this.bind({
                     tools: [
                         {
                             type: "function",
                             function: {
                                 name: functionName,
-                                description: asZodSchema.description,
-                                parameters: asZodSchema,
+                                description: asJsonSchema.description,
+                                parameters: asJsonSchema,
                             },
                         },
                     ],
@@ -766,6 +783,7 @@ export class ChatOpenAI extends BaseChatModel {
                 outputParser = new JsonOutputKeyToolsParser({
                     returnSingle: true,
                     keyName: functionName,
+                    zodSchema: schema,
                 });
             }
             else {
@@ -814,7 +832,9 @@ export class ChatOpenAI extends BaseChatModel {
         ]);
     }
 }
-function isZodSchema(input) {
+function isZodSchema(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+input) {
     // Check for a characteristic method of Zod schemas
     return typeof input?.parse === "function";
 }

package/dist/index.cjs

@@ -26,3 +26,4 @@ __exportStar(require("./embeddings.cjs"), exports);
 __exportStar(require("./types.cjs"), exports);
 __exportStar(require("./utils/openai.cjs"), exports);
 __exportStar(require("./utils/azure.cjs"), exports);
+__exportStar(require("./tools/index.cjs"), exports);

package/dist/index.d.ts

@@ -7,3 +7,4 @@ export * from "./embeddings.js";
 export * from "./types.js";
 export * from "./utils/openai.js";
 export * from "./utils/azure.js";
+export * from "./tools/index.js";

package/dist/index.js

@@ -7,3 +7,4 @@ export * from "./embeddings.js";
 export * from "./types.js";
 export * from "./utils/openai.js";
 export * from "./utils/azure.js";
+export * from "./tools/index.js";

package/dist/legacy.cjs

@@ -42,7 +42,7 @@ const openai_js_1 = require("./utils/openai.cjs");
  *   maxTokens: 50,
  * });
  *
- * const res = await model.call(
+ * const res = await model.invoke(
  *   "What would be a good company name for a company that makes colorful socks?"
  * );
  * console.log({ res });

package/dist/legacy.d.ts

@@ -47,7 +47,7 @@ export interface OpenAIChatCallOptions extends OpenAICallOptions {
  *   maxTokens: 50,
  * });
  *
- * const res = await model.call(
+ * const res = await model.invoke(
  *   "What would be a good company name for a company that makes colorful socks?"
  * );
  * console.log({ res });

package/dist/legacy.js

@@ -39,7 +39,7 @@ import { wrapOpenAIClientError } from "./utils/openai.js";
  *   maxTokens: 50,
  * });
  *
- * const res = await model.call(
+ * const res = await model.invoke(
  *   "What would be a good company name for a company that makes colorful socks?"
  * );
  * console.log({ res });

package/dist/llms.cjs

@@ -37,7 +37,7 @@ const openai_js_1 = require("./utils/openai.cjs");
  *   maxRetries: 5,
  * });
  *
- * const res = await model.call(
+ * const res = await model.invoke(
  *   "Question: What would be a good company name for a company that makes colorful socks?\nAnswer:"
  * );
  * console.log({ res });

package/dist/llms.d.ts

@@ -32,7 +32,7 @@ export { OpenAIChat };
  *   maxRetries: 5,
  * });
  *
- * const res = await model.call(
+ * const res = await model.invoke(
  *   "Question: What would be a good company name for a company that makes colorful socks?\nAnswer:"
  * );
  * console.log({ res });

package/dist/llms.js

@@ -34,7 +34,7 @@ export { OpenAIChat };
  *   maxRetries: 5,
  * });
  *
- * const res = await model.call(
+ * const res = await model.invoke(
  *   "Question: What would be a good company name for a company that makes colorful socks?\nAnswer:"
  * );
  * console.log({ res });

package/dist/tests/chat_models-extended.int.test.js

@@ -62,6 +62,17 @@ test("Test ChatOpenAI tool calling", async () => {
     console.log(JSON.stringify(res));
     expect(res.additional_kwargs.tool_calls?.length).toBeGreaterThan(1);
 });
+test("Test ChatOpenAI streaming logprobs", async () => {
+    const model = new ChatOpenAI({
+        maxTokens: 50,
+        modelName: "gpt-3.5-turbo",
+        streaming: true,
+        logprobs: true,
+    });
+    const res = await model.invoke("Print hello world.");
+    console.log(res.response_metadata.logprobs.content);
+    expect(res.response_metadata.logprobs.content.length).toBeGreaterThan(0);
+});
 test("Test ChatOpenAI tool calling with ToolMessages", async () => {
     function getCurrentWeather(location) {
         if (location.toLowerCase().includes("tokyo")) {

package/dist/tests/chat_models.int.test.js

@@ -1,25 +1,10 @@
-import { test, jest, expect, describe } from "@jest/globals";
+import { test, jest, expect } from "@jest/globals";
 import { ChatMessage, HumanMessage, SystemMessage, } from "@langchain/core/messages";
 import { ChatPromptValue } from "@langchain/core/prompt_values";
 import { PromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate, } from "@langchain/core/prompts";
 import { CallbackManager } from "@langchain/core/callbacks/manager";
 import { InMemoryCache } from "@langchain/core/caches";
-import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
 import { ChatOpenAI } from "../chat_models.js";
-test("Test ChatOpenAI", async () => {
-    const chat = new ChatOpenAI({ modelName: "gpt-3.5-turbo", maxTokens: 10 });
-    const message = new HumanMessage("Hello!");
-    const res = await chat.call([message]);
-    console.log({ res });
-});
-test("Test ChatOpenAI with SystemChatMessage", async () => {
-    const chat = new ChatOpenAI({ modelName: "gpt-3.5-turbo", maxTokens: 10 });
-    const system_message = new SystemMessage("You are to chat with a user.");
-    const message = new HumanMessage("Hello!");
-    const res = await chat.call([system_message, message]);
-    console.log({ res });
-});
 test("Test ChatOpenAI Generate", async () => {
     const chat = new ChatOpenAI({
         modelName: "gpt-3.5-turbo",
@@ -65,7 +50,7 @@ test("Test ChatOpenAI tokenUsage", async () => {
         }),
     });
     const message = new HumanMessage("Hello");
-    const res = await model.call([message]);
+    const res = await model.invoke([message]);
     console.log({ res });
     expect(tokenUsage.promptTokens).toBeGreaterThan(0);
 });
@@ -108,7 +93,7 @@ test("Test ChatOpenAI in streaming mode", async () => {
         ],
     });
     const message = new HumanMessage("Hello!");
-    const result = await model.call([message]);
+    const result = await model.invoke([message]);
     console.log(result);
     expect(nrNewTokens > 0).toBe(true);
     expect(result.content).toBe(streamedCompletion);
@@ -175,25 +160,27 @@ test("OpenAI Chat, docs, prompt templates", async () => {
 }, 5000);
 test("Test OpenAI with stop", async () => {
     const model = new ChatOpenAI({ maxTokens: 5 });
-    const res = await model.call([new HumanMessage("Print hello world")], ["world"]);
+    const res = await model.invoke([new HumanMessage("Print hello world")], {
+        stop: ["world"],
+    });
     console.log({ res });
 });
 test("Test OpenAI with stop in object", async () => {
     const model = new ChatOpenAI({ maxTokens: 5 });
-    const res = await model.call([new HumanMessage("Print hello world")], {
+    const res = await model.invoke([new HumanMessage("Print hello world")], {
         stop: ["world"],
     });
     console.log({ res });
 });
 test("Test OpenAI with timeout in call options", async () => {
-    const model = new ChatOpenAI({ maxTokens: 5 });
-    await expect(() => model.call([new HumanMessage("Print hello world")], {
+    const model = new ChatOpenAI({ maxTokens: 5, maxRetries: 0 });
+    await expect(() => model.invoke([new HumanMessage("Print hello world")], {
         options: { timeout: 10 },
     })).rejects.toThrow();
 }, 5000);
 test("Test OpenAI with timeout in call options and node adapter", async () => {
-    const model = new ChatOpenAI({ maxTokens: 5 });
-    await expect(() => model.call([new HumanMessage("Print hello world")], {
+    const model = new ChatOpenAI({ maxTokens: 5, maxRetries: 0 });
+    await expect(() => model.invoke([new HumanMessage("Print hello world")], {
         options: { timeout: 10 },
     })).rejects.toThrow();
 }, 5000);
@@ -201,7 +188,7 @@ test("Test OpenAI with signal in call options", async () => {
     const model = new ChatOpenAI({ maxTokens: 5 });
     const controller = new AbortController();
     await expect(() => {
-        const ret = model.call([new HumanMessage("Print hello world")], {
+        const ret = model.invoke([new HumanMessage("Print hello world")], {
             options: { signal: controller.signal },
         });
         controller.abort();
@@ -215,7 +202,7 @@ test("Test OpenAI with signal in call options and node adapter", async () => {
     });
     const controller = new AbortController();
     await expect(() => {
-        const ret = model.call([new HumanMessage("Print hello world")], {
+        const ret = model.invoke([new HumanMessage("Print hello world")], {
             options: { signal: controller.signal },
         });
         controller.abort();
@@ -260,7 +247,7 @@ test("Test OpenAI with specific roles in ChatMessage", async () => {
     const chat = new ChatOpenAI({ modelName: "gpt-3.5-turbo", maxTokens: 10 });
     const system_message = new ChatMessage("You are to chat with a user.", "system");
     const user_message = new ChatMessage("Hello!", "user");
-    const res = await chat.call([system_message, user_message]);
+    const res = await chat.invoke([system_message, user_message]);
     console.log({ res });
 });
 test("Test ChatOpenAI stream method", async () => {
@@ -305,6 +292,7 @@ test("Test ChatOpenAI stream method, timeout error thrown from SDK", async () =>
             maxTokens: 50,
             modelName: "gpt-3.5-turbo",
             timeout: 1,
+            maxRetries: 0,
         });
         const stream = await model.stream("How is your day going? Be extremely verbose.");
         for await (const chunk of stream) {
@@ -630,169 +618,3 @@ test("Test ChatOpenAI token usage reporting for streaming calls", async () => {
         expect(streamingTokenUsed).toEqual(nonStreamingTokenUsed);
     }
 });
-describe("ChatOpenAI withStructuredOutput", () => {
-    test("withStructuredOutput zod schema function calling", async () => {
-        const model = new ChatOpenAI({
-            temperature: 0,
-            modelName: "gpt-4-turbo-preview",
-        });
-        const calculatorSchema = z.object({
-            operation: z.enum(["add", "subtract", "multiply", "divide"]),
-            number1: z.number(),
-            number2: z.number(),
-        });
-        const modelWithStructuredOutput = model.withStructuredOutput(calculatorSchema, {
-            name: "calculator",
-        });
-        const prompt = ChatPromptTemplate.fromMessages([
-            "system",
-            "You are VERY bad at math and must always use a calculator.",
-            "human",
-            "Please help me!! What is 2 + 2?",
-        ]);
-        const chain = prompt.pipe(modelWithStructuredOutput);
-        const result = await chain.invoke({});
-        console.log(result);
-        expect("operation" in result).toBe(true);
-        expect("number1" in result).toBe(true);
-        expect("number2" in result).toBe(true);
-    });
-    test("withStructuredOutput zod schema JSON mode", async () => {
-        const model = new ChatOpenAI({
-            temperature: 0,
-            modelName: "gpt-4-turbo-preview",
-        });
-        const calculatorSchema = z.object({
-            operation: z.enum(["add", "subtract", "multiply", "divide"]),
-            number1: z.number(),
-            number2: z.number(),
-        });
-        const modelWithStructuredOutput = model.withStructuredOutput(calculatorSchema, {
-            name: "calculator",
-            method: "jsonMode",
-        });
-        const prompt = ChatPromptTemplate.fromMessages([
-            "system",
-            `You are VERY bad at math and must always use a calculator.
-  Respond with a JSON object containing three keys:
-  'operation': the type of operation to execute, either 'add', 'subtract', 'multiply' or 'divide',
-  'number1': the first number to operate on,
-  'number2': the second number to operate on.
-  `,
-            "human",
-            "Please help me!! What is 2 + 2?",
-        ]);
-        const chain = prompt.pipe(modelWithStructuredOutput);
-        const result = await chain.invoke({});
-        console.log(result);
-        expect("operation" in result).toBe(true);
-        expect("number1" in result).toBe(true);
-        expect("number2" in result).toBe(true);
-    });
-    test("withStructuredOutput JSON schema function calling", async () => {
-        const model = new ChatOpenAI({
-            temperature: 0,
-            modelName: "gpt-4-turbo-preview",
-        });
-        const calculatorSchema = z.object({
-            operation: z.enum(["add", "subtract", "multiply", "divide"]),
-            number1: z.number(),
-            number2: z.number(),
-        });
-        const modelWithStructuredOutput = model.withStructuredOutput({
-            schema: zodToJsonSchema(calculatorSchema),
-            name: "calculator",
-        });
-        const prompt = ChatPromptTemplate.fromMessages([
-            "system",
-            `You are VERY bad at math and must always use a calculator.`,
-            "human",
-            "Please help me!! What is 2 + 2?",
-        ]);
-        const chain = prompt.pipe(modelWithStructuredOutput);
-        const result = await chain.invoke({});
-        console.log(result);
-        expect("operation" in result).toBe(true);
-        expect("number1" in result).toBe(true);
-        expect("number2" in result).toBe(true);
-    });
-    test("withStructuredOutput JSON schema JSON mode", async () => {
-        const model = new ChatOpenAI({
-            temperature: 0,
-            modelName: "gpt-4-turbo-preview",
-        });
-        const calculatorSchema = z.object({
-            operation: z.enum(["add", "subtract", "multiply", "divide"]),
-            number1: z.number(),
-            number2: z.number(),
-        });
-        const modelWithStructuredOutput = model.withStructuredOutput(zodToJsonSchema(calculatorSchema), {
-            name: "calculator",
-            method: "jsonMode",
-        });
-        const prompt = ChatPromptTemplate.fromMessages([
-            "system",
-            `You are VERY bad at math and must always use a calculator.
-  Respond with a JSON object containing three keys:
-  'operation': the type of operation to execute, either 'add', 'subtract', 'multiply' or 'divide',
-  'number1': the first number to operate on,
-  'number2': the second number to operate on.
-  `,
-            "human",
-            "Please help me!! What is 2 + 2?",
-        ]);
-        const chain = prompt.pipe(modelWithStructuredOutput);
-        const result = await chain.invoke({});
-        console.log(result);
-        expect("operation" in result).toBe(true);
-        expect("number1" in result).toBe(true);
-        expect("number2" in result).toBe(true);
-    });
-    test("withStructuredOutput includeRaw true", async () => {
-        const model = new ChatOpenAI({
-            temperature: 0,
-            modelName: "gpt-4-turbo-preview",
-        });
-        const calculatorSchema = z.object({
-            operation: z.enum(["add", "subtract", "multiply", "divide"]),
-            number1: z.number(),
-            number2: z.number(),
-        });
-        const modelWithStructuredOutput = model.withStructuredOutput(calculatorSchema, {
-            name: "calculator",
-            includeRaw: true,
-        });
-        const prompt = ChatPromptTemplate.fromMessages([
-            "system",
-            "You are VERY bad at math and must always use a calculator.",
-            "human",
-            "Please help me!! What is 2 + 2?",
-        ]);
-        const chain = prompt.pipe(modelWithStructuredOutput);
-        const result = await chain.invoke({});
-        console.log(result);
-        expect("parsed" in result).toBe(true);
-        // Need to make TS happy :)
-        if (!("parsed" in result)) {
-            throw new Error("parsed not in result");
-        }
-        const { parsed } = result;
-        expect("operation" in parsed).toBe(true);
-        expect("number1" in parsed).toBe(true);
-        expect("number2" in parsed).toBe(true);
-        expect("raw" in result).toBe(true);
-        // Need to make TS happy :)
-        if (!("raw" in result)) {
-            throw new Error("raw not in result");
-        }
-        const { raw } = result;
-        expect(raw.additional_kwargs.tool_calls?.length).toBeGreaterThan(0);
-        expect(raw.additional_kwargs.tool_calls?.[0].function.name).toBe("calculator");
-        expect("operation" in
-            JSON.parse(raw.additional_kwargs.tool_calls?.[0].function.arguments ?? "")).toBe(true);
-        expect("number1" in
-            JSON.parse(raw.additional_kwargs.tool_calls?.[0].function.arguments ?? "")).toBe(true);
-        expect("number2" in
-            JSON.parse(raw.additional_kwargs.tool_calls?.[0].function.arguments ?? "")).toBe(true);
-    });
-});

package/dist/tests/chat_models_structured_output.int.test.d.ts

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

package/dist/tests/chat_models_structured_output.int.test.js

@@ -0,0 +1,168 @@
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+import { ChatOpenAI } from "../chat_models.js";
+test("withStructuredOutput zod schema function calling", async () => {
+    const model = new ChatOpenAI({
+        temperature: 0,
+        modelName: "gpt-4-turbo-preview",
+    });
+    const calculatorSchema = z.object({
+        operation: z.enum(["add", "subtract", "multiply", "divide"]),
+        number1: z.number(),
+        number2: z.number(),
+    });
+    const modelWithStructuredOutput = model.withStructuredOutput(calculatorSchema, {
+        name: "calculator",
+    });
+    const prompt = ChatPromptTemplate.fromMessages([
+        "system",
+        "You are VERY bad at math and must always use a calculator.",
+        "human",
+        "Please help me!! What is 2 + 2?",
+    ]);
+    const chain = prompt.pipe(modelWithStructuredOutput);
+    const result = await chain.invoke({});
+    console.log(result);
+    expect("operation" in result).toBe(true);
+    expect("number1" in result).toBe(true);
+    expect("number2" in result).toBe(true);
+});
+test("withStructuredOutput zod schema JSON mode", async () => {
+    const model = new ChatOpenAI({
+        temperature: 0,
+        modelName: "gpt-4-turbo-preview",
+    });
+    const calculatorSchema = z.object({
+        operation: z.enum(["add", "subtract", "multiply", "divide"]),
+        number1: z.number(),
+        number2: z.number(),
+    });
+    const modelWithStructuredOutput = model.withStructuredOutput(calculatorSchema, {
+        name: "calculator",
+        method: "jsonMode",
+    });
+    const prompt = ChatPromptTemplate.fromMessages([
+        "system",
+        `You are VERY bad at math and must always use a calculator.
+Respond with a JSON object containing three keys:
+'operation': the type of operation to execute, either 'add', 'subtract', 'multiply' or 'divide',
+'number1': the first number to operate on,
+'number2': the second number to operate on.
+`,
+        "human",
+        "Please help me!! What is 2 + 2?",
+    ]);
+    const chain = prompt.pipe(modelWithStructuredOutput);
+    const result = await chain.invoke({});
+    console.log(result);
+    expect("operation" in result).toBe(true);
+    expect("number1" in result).toBe(true);
+    expect("number2" in result).toBe(true);
+});
+test("withStructuredOutput JSON schema function calling", async () => {
+    const model = new ChatOpenAI({
+        temperature: 0,
+        modelName: "gpt-4-turbo-preview",
+    });
+    const calculatorSchema = z.object({
+        operation: z.enum(["add", "subtract", "multiply", "divide"]),
+        number1: z.number(),
+        number2: z.number(),
+    });
+    const modelWithStructuredOutput = model.withStructuredOutput({
+        schema: zodToJsonSchema(calculatorSchema),
+        name: "calculator",
+    });
+    const prompt = ChatPromptTemplate.fromMessages([
+        "system",
+        `You are VERY bad at math and must always use a calculator.`,
+        "human",
+        "Please help me!! What is 2 + 2?",
+    ]);
+    const chain = prompt.pipe(modelWithStructuredOutput);
+    const result = await chain.invoke({});
+    console.log(result);
+    expect("operation" in result).toBe(true);
+    expect("number1" in result).toBe(true);
+    expect("number2" in result).toBe(true);
+});
+test("withStructuredOutput JSON schema JSON mode", async () => {
+    const model = new ChatOpenAI({
+        temperature: 0,
+        modelName: "gpt-4-turbo-preview",
+    });
+    const calculatorSchema = z.object({
+        operation: z.enum(["add", "subtract", "multiply", "divide"]),
+        number1: z.number(),
+        number2: z.number(),
+    });
+    const modelWithStructuredOutput = model.withStructuredOutput(zodToJsonSchema(calculatorSchema), {
+        name: "calculator",
+        method: "jsonMode",
+    });
+    const prompt = ChatPromptTemplate.fromMessages([
+        "system",
+        `You are VERY bad at math and must always use a calculator.
+Respond with a JSON object containing three keys:
+'operation': the type of operation to execute, either 'add', 'subtract', 'multiply' or 'divide',
+'number1': the first number to operate on,
+'number2': the second number to operate on.
+`,
+        "human",
+        "Please help me!! What is 2 + 2?",
+    ]);
+    const chain = prompt.pipe(modelWithStructuredOutput);
+    const result = await chain.invoke({});
+    console.log(result);
+    expect("operation" in result).toBe(true);
+    expect("number1" in result).toBe(true);
+    expect("number2" in result).toBe(true);
+});
+test("withStructuredOutput includeRaw true", async () => {
+    const model = new ChatOpenAI({
+        temperature: 0,
+        modelName: "gpt-4-turbo-preview",
+    });
+    const calculatorSchema = z.object({
+        operation: z.enum(["add", "subtract", "multiply", "divide"]),
+        number1: z.number(),
+        number2: z.number(),
+    });
+    const modelWithStructuredOutput = model.withStructuredOutput(calculatorSchema, {
+        name: "calculator",
+        includeRaw: true,
+    });
+    const prompt = ChatPromptTemplate.fromMessages([
+        "system",
+        "You are VERY bad at math and must always use a calculator.",
+        "human",
+        "Please help me!! What is 2 + 2?",
+    ]);
+    const chain = prompt.pipe(modelWithStructuredOutput);
+    const result = await chain.invoke({});
+    console.log(result);
+    expect("parsed" in result).toBe(true);
+    // Need to make TS happy :)
+    if (!("parsed" in result)) {
+        throw new Error("parsed not in result");
+    }
+    const { parsed } = result;
+    expect("operation" in parsed).toBe(true);
+    expect("number1" in parsed).toBe(true);
+    expect("number2" in parsed).toBe(true);
+    expect("raw" in result).toBe(true);
+    // Need to make TS happy :)
+    if (!("raw" in result)) {
+        throw new Error("raw not in result");
+    }
+    const { raw } = result;
+    expect(raw.additional_kwargs.tool_calls?.length).toBeGreaterThan(0);
+    expect(raw.additional_kwargs.tool_calls?.[0].function.name).toBe("calculator");
+    expect("operation" in
+        JSON.parse(raw.additional_kwargs.tool_calls?.[0].function.arguments ?? "")).toBe(true);
+    expect("number1" in
+        JSON.parse(raw.additional_kwargs.tool_calls?.[0].function.arguments ?? "")).toBe(true);
+    expect("number2" in
+        JSON.parse(raw.additional_kwargs.tool_calls?.[0].function.arguments ?? "")).toBe(true);
+});

package/dist/tests/embeddings.int.test.js

@@ -32,6 +32,7 @@ test("Test timeout error thrown from SDK", async () => {
     await expect(async () => {
         const model = new OpenAIEmbeddings({
             timeout: 1,
+            maxRetries: 0,
         });
         await model.embedDocuments([
             "Hello world",

package/dist/tests/legacy.int.test.js

@@ -3,7 +3,7 @@ import { CallbackManager } from "@langchain/core/callbacks/manager";
 import { OpenAIChat } from "../legacy.js";
 test("Test OpenAI", async () => {
     const model = new OpenAIChat({ modelName: "gpt-3.5-turbo", maxTokens: 10 });
-    const res = await model.call("Print hello world");
+    const res = await model.invoke("Print hello world");
     console.log({ res });
 });
 test("Test OpenAI with prefix messages", async () => {
@@ -14,7 +14,7 @@ test("Test OpenAI with prefix messages", async () => {
         ],
         maxTokens: 10,
     });
-    const res = await model.call("What is my name");
+    const res = await model.invoke("What is my name");
     console.log({ res });
 });
 test("Test OpenAI in streaming mode", async () => {
@@ -31,7 +31,7 @@ test("Test OpenAI in streaming mode", async () => {
             },
         }),
     });
-    const res = await model.call("Print hello world");
+    const res = await model.invoke("Print hello world");
     console.log({ res });
     expect(nrNewTokens > 0).toBe(true);
     expect(res).toBe(streamedCompletion);
@@ -43,18 +43,18 @@ test("Test OpenAI with stop", async () => {
 });
 test("Test OpenAI with stop in object", async () => {
     const model = new OpenAIChat({ maxTokens: 5 });
-    const res = await model.call("Print hello world", { stop: ["world"] });
+    const res = await model.invoke("Print hello world", { stop: ["world"] });
     console.log({ res });
 });
 test("Test OpenAI with timeout in call options", async () => {
     const model = new OpenAIChat({ maxTokens: 5 });
-    await expect(() => model.call("Print hello world", {
+    await expect(() => model.invoke("Print hello world", {
         timeout: 10,
     })).rejects.toThrow();
 }, 5000);
 test("Test OpenAI with timeout in call options and node adapter", async () => {
     const model = new OpenAIChat({ maxTokens: 5 });
-    await expect(() => model.call("Print hello world", {
+    await expect(() => model.invoke("Print hello world", {
         timeout: 10,
     })).rejects.toThrow();
 }, 5000);
@@ -62,7 +62,7 @@ test("Test OpenAI with signal in call options", async () => {
     const model = new OpenAIChat({ maxTokens: 5 });
     const controller = new AbortController();
     await expect(() => {
-        const ret = model.call("Print hello world", {
+        const ret = model.invoke("Print hello world", {
             signal: controller.signal,
         });
         controller.abort();
@@ -73,7 +73,7 @@ test("Test OpenAI with signal in call options and node adapter", async () => {
     const model = new OpenAIChat({ maxTokens: 5 });
     const controller = new AbortController();
     await expect(() => {
-        const ret = model.call("Print hello world", {
+        const ret = model.invoke("Print hello world", {
             signal: controller.signal,
         });
         controller.abort();

package/dist/tests/llms.int.test.js

@@ -8,7 +8,7 @@ test("Test OpenAI", async () => {
         maxTokens: 5,
         modelName: "gpt-3.5-turbo-instruct",
     });
-    const res = await model.call("Print hello world");
+    const res = await model.invoke("Print hello world");
     console.log({ res });
 });
 test("Test OpenAI with stop", async () => {
@@ -24,24 +24,26 @@ test("Test OpenAI with stop in object", async () => {
         maxTokens: 5,
         modelName: "gpt-3.5-turbo-instruct",
     });
-    const res = await model.call("Print hello world", { stop: ["world"] });
+    const res = await model.invoke("Print hello world", { stop: ["world"] });
     console.log({ res });
 });
 test("Test OpenAI with timeout in call options", async () => {
     const model = new OpenAI({
         maxTokens: 5,
+        maxRetries: 0,
         modelName: "gpt-3.5-turbo-instruct",
     });
-    await expect(() => model.call("Print hello world", {
+    await expect(() => model.invoke("Print hello world", {
         timeout: 10,
     })).rejects.toThrow();
 }, 5000);
 test("Test OpenAI with timeout in call options and node adapter", async () => {
     const model = new OpenAI({
         maxTokens: 5,
+        maxRetries: 0,
         modelName: "gpt-3.5-turbo-instruct",
     });
-    await expect(() => model.call("Print hello world", {
+    await expect(() => model.invoke("Print hello world", {
         timeout: 10,
     })).rejects.toThrow();
 }, 5000);
@@ -52,7 +54,7 @@ test("Test OpenAI with signal in call options", async () => {
     });
     const controller = new AbortController();
     await expect(() => {
-        const ret = model.call("Print hello world", {
+        const ret = model.invoke("Print hello world", {
             signal: controller.signal,
         });
         controller.abort();
@@ -66,7 +68,7 @@ test("Test OpenAI with signal in call options and node adapter", async () => {
     });
     const controller = new AbortController();
     await expect(() => {
-        const ret = model.call("Print hello world", {
+        const ret = model.invoke("Print hello world", {
             signal: controller.signal,
         });
         controller.abort();
@@ -80,8 +82,8 @@ test("Test OpenAI with concurrency == 1", async () => {
         maxConcurrency: 1,
     });
     const res = await Promise.all([
-        model.call("Print hello world"),
-        model.call("Print hello world"),
+        model.invoke("Print hello world"),
+        model.invoke("Print hello world"),
     ]);
     console.log({ res });
 });
@@ -96,21 +98,21 @@ test("Test OpenAI with maxTokens -1", async () => {
 test("Test OpenAI with chat model returns OpenAIChat", async () => {
     const model = new OpenAI({ modelName: "gpt-3.5-turbo" });
     expect(model).toBeInstanceOf(OpenAIChat);
-    const res = await model.call("Print hello world");
+    const res = await model.invoke("Print hello world");
     console.log({ res });
     expect(typeof res).toBe("string");
 });
 test("Test OpenAI with instruct model returns OpenAI", async () => {
     const model = new OpenAI({ modelName: "gpt-3.5-turbo-instruct" });
     expect(model).toBeInstanceOf(OpenAI);
-    const res = await model.call("Print hello world");
+    const res = await model.invoke("Print hello world");
     console.log({ res });
     expect(typeof res).toBe("string");
 });
 test("Test OpenAI with versioned instruct model returns OpenAI", async () => {
     const model = new OpenAI({ modelName: "gpt-3.5-turbo-instruct-0914" });
     expect(model).toBeInstanceOf(OpenAI);
-    const res = await model.call("Print hello world");
+    const res = await model.invoke("Print hello world");
     console.log({ res });
     expect(typeof res).toBe("string");
 });
@@ -129,7 +131,7 @@ test("Test ChatOpenAI tokenUsage", async () => {
             },
         }),
     });
-    const res = await model.call("Hello");
+    const res = await model.invoke("Hello");
     console.log({ res });
     expect(tokenUsage.promptTokens).toBe(1);
 });
@@ -147,7 +149,7 @@ test("Test OpenAI in streaming mode", async () => {
             },
         }),
     });
-    const res = await model.call("Print hello world");
+    const res = await model.invoke("Print hello world");
     console.log({ res });
     expect(nrNewTokens > 0).toBe(true);
     expect(res).toBe(streamedCompletion);
@@ -230,6 +232,7 @@ test("Test OpenAI stream method with abort", async () => {
     await expect(async () => {
         const model = new OpenAI({
             maxTokens: 250,
+            maxRetries: 0,
             modelName: "gpt-3.5-turbo-instruct",
         });
         const stream = await model.stream("How is your day going? Be extremely verbose.", {

package/dist/tools/dalle.cjs

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DallEAPIWrapper = void 0;
+const env_1 = require("@langchain/core/utils/env");
+const openai_1 = require("openai");
+const tools_1 = require("@langchain/core/tools");
+/**
+ * A tool for generating images with Open AIs Dall-E 2 or 3 API.
+ */
+class DallEAPIWrapper extends tools_1.Tool {
+    static lc_name() {
+        return "DallEAPIWrapper";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "dalle_api_wrapper"
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "A wrapper around OpenAI DALL-E API. Useful for when you need to generate images from a text description. Input should be an image description."
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "dall-e-3"
+        });
+        Object.defineProperty(this, "style", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "vivid"
+        });
+        Object.defineProperty(this, "quality", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "standard"
+        });
+        Object.defineProperty(this, "n", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        Object.defineProperty(this, "size", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "1024x1024"
+        });
+        Object.defineProperty(this, "responseFormat", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "url"
+        });
+        Object.defineProperty(this, "user", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const openAIApiKey = fields?.openAIApiKey ?? (0, env_1.getEnvironmentVariable)("OPENAI_API_KEY");
+        const organization = fields?.organization ?? (0, env_1.getEnvironmentVariable)("OPENAI_ORGANIZATION");
+        const clientConfig = {
+            apiKey: openAIApiKey,
+            organization,
+            dangerouslyAllowBrowser: true,
+        };
+        this.client = new openai_1.OpenAI(clientConfig);
+        this.modelName = fields?.modelName ?? this.modelName;
+        this.style = fields?.style ?? this.style;
+        this.quality = fields?.quality ?? this.quality;
+        this.n = fields?.n ?? this.n;
+        this.size = fields?.size ?? this.size;
+        this.responseFormat = fields?.responseFormat ?? this.responseFormat;
+        this.user = fields?.user;
+    }
+    /** @ignore */
+    async _call(input) {
+        const response = await this.client.images.generate({
+            model: this.modelName,
+            prompt: input,
+            n: this.n,
+            size: this.size,
+            response_format: this.responseFormat,
+            style: this.style,
+            quality: this.quality,
+            user: this.user,
+        });
+        let data = "";
+        if (this.responseFormat === "url") {
+            [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");
+        }
+        return data;
+    }
+}
+exports.DallEAPIWrapper = DallEAPIWrapper;
+Object.defineProperty(DallEAPIWrapper, "toolName", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: "dalle_api_wrapper"
+});

package/dist/tools/dalle.d.ts

@@ -0,0 +1,79 @@
+import { OpenAI as OpenAIClient } from "openai";
+import { Tool, ToolParams } from "@langchain/core/tools";
+/**
+ * An interface for the Dall-E API Wrapper.
+ */
+export interface DallEAPIWrapperParams extends ToolParams {
+    /**
+     * The OpenAI API key
+     */
+    openAIApiKey?: string;
+    /**
+     * The model to use.
+     * @params "dall-e-2" | "dall-e-3"
+     * @default "dall-e-3"
+     */
+    modelName?: string;
+    /**
+     * The style of the generated images. Must be one of vivid or natural.
+     * Vivid causes the model to lean towards generating hyper-real and dramatic images.
+     * Natural causes the model to produce more natural, less hyper-real looking images.
+     * @default "vivid"
+     */
+    style?: "natural" | "vivid";
+    /**
+     * The quality of the image that will be generated. ‘hd’ creates images with finer
+     * details and greater consistency across the image.
+     * @default "standard"
+     */
+    quality?: "standard" | "hd";
+    /**
+     * The number of images to generate.
+     * Must be between 1 and 10.
+     * For dall-e-3, only `n: 1` is supported.
+     * @default 1
+     */
+    n?: number;
+    /**
+     * The size of the generated images.
+     * Must be one of 256x256, 512x512, or 1024x1024 for DALL·E-2 models.
+     * Must be one of 1024x1024, 1792x1024, or 1024x1792 for DALL·E-3 models.
+     * @default "1024x1024"
+     */
+    size?: "256x256" | "512x512" | "1024x1024" | "1792x1024" | "1024x1792";
+    /**
+     * The format in which the generated images are returned.
+     * Must be one of "url" or "b64_json".
+     * @default "url"
+     */
+    responseFormat?: "url" | "b64_json";
+    /**
+     * A unique identifier representing your end-user, which will help
+     * OpenAI to monitor and detect abuse.
+     */
+    user?: string;
+    /**
+     * The organization to use
+     */
+    organization?: string;
+}
+/**
+ * A tool for generating images with Open AIs Dall-E 2 or 3 API.
+ */
+export declare class DallEAPIWrapper extends Tool {
+    static lc_name(): string;
+    name: string;
+    description: string;
+    protected client: OpenAIClient;
+    static readonly toolName = "dalle_api_wrapper";
+    private modelName;
+    private style;
+    private quality;
+    private n;
+    private size;
+    private responseFormat;
+    private user?;
+    constructor(fields?: DallEAPIWrapperParams);
+    /** @ignore */
+    _call(input: string): Promise<string>;
+}

package/dist/tools/dalle.js

@@ -0,0 +1,120 @@
+import { getEnvironmentVariable } from "@langchain/core/utils/env";
+import { OpenAI as OpenAIClient } from "openai";
+import { Tool } from "@langchain/core/tools";
+/**
+ * A tool for generating images with Open AIs Dall-E 2 or 3 API.
+ */
+export class DallEAPIWrapper extends Tool {
+    static lc_name() {
+        return "DallEAPIWrapper";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "dalle_api_wrapper"
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "A wrapper around OpenAI DALL-E API. Useful for when you need to generate images from a text description. Input should be an image description."
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "dall-e-3"
+        });
+        Object.defineProperty(this, "style", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "vivid"
+        });
+        Object.defineProperty(this, "quality", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "standard"
+        });
+        Object.defineProperty(this, "n", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        Object.defineProperty(this, "size", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "1024x1024"
+        });
+        Object.defineProperty(this, "responseFormat", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "url"
+        });
+        Object.defineProperty(this, "user", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const openAIApiKey = fields?.openAIApiKey ?? getEnvironmentVariable("OPENAI_API_KEY");
+        const organization = fields?.organization ?? getEnvironmentVariable("OPENAI_ORGANIZATION");
+        const clientConfig = {
+            apiKey: openAIApiKey,
+            organization,
+            dangerouslyAllowBrowser: true,
+        };
+        this.client = new OpenAIClient(clientConfig);
+        this.modelName = fields?.modelName ?? this.modelName;
+        this.style = fields?.style ?? this.style;
+        this.quality = fields?.quality ?? this.quality;
+        this.n = fields?.n ?? this.n;
+        this.size = fields?.size ?? this.size;
+        this.responseFormat = fields?.responseFormat ?? this.responseFormat;
+        this.user = fields?.user;
+    }
+    /** @ignore */
+    async _call(input) {
+        const response = await this.client.images.generate({
+            model: this.modelName,
+            prompt: input,
+            n: this.n,
+            size: this.size,
+            response_format: this.responseFormat,
+            style: this.style,
+            quality: this.quality,
+            user: this.user,
+        });
+        let data = "";
+        if (this.responseFormat === "url") {
+            [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");
+        }
+        return data;
+    }
+}
+Object.defineProperty(DallEAPIWrapper, "toolName", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: "dalle_api_wrapper"
+});

package/dist/tools/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dalle.cjs"), exports);

package/dist/tools/index.d.ts

@@ -0,0 +1 @@
+export * from "./dalle.js";

package/dist/tools/index.js

@@ -0,0 +1 @@
+export * from "./dalle.js";

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

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

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

@@ -0,0 +1,16 @@
+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://");
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/openai",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "OpenAI integrations for LangChain.js",
   "type": "module",
   "engines": {
@@ -39,7 +39,7 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@langchain/core": "~0.1.41",
+    "@langchain/core": "~0.1.45",
     "js-tiktoken": "^1.0.7",
     "openai": "^4.26.0",
     "zod": "^3.22.4",