@langchain/openai 0.0.14 → 0.0.15

package/dist/chat_models.cjs

@@ -7,6 +7,10 @@ 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 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");
+const openai_tools_1 = require("@langchain/core/output_parsers/openai_tools");
+const zod_to_json_schema_1 = require("zod-to-json-schema");
 const azure_js_1 = require("./utils/azure.cjs");
 const openai_js_1 = require("./utils/openai.cjs");
 const openai_format_fndef_js_1 = require("./utils/openai-format-fndef.cjs");
@@ -714,5 +718,91 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
             },
         });
     }
+    /**
+     * Model wrapper that returns outputs formatted to match the given schema.
+     *
+     * @template {z.ZodObject<any, any, any, any>} RunOutput The output type for the Runnable, expected to be a Zod schema object for structured output validation.
+     *
+     * @param {z.ZodEffects<RunOutput>} schema The schema for the structured output. Either as a Zod schema or a valid JSON schema object.
+     * @param {string} name The name of the function to call.
+     * @param {"functionCalling" | "jsonMode"} method The method to use for getting the structured output. Defaults to "functionCalling".
+     * @param {boolean | undefined} includeRaw Whether to include the raw output in the result. Defaults to false.
+     * @returns {Runnable<RunInput, RunOutput> | Runnable<RunInput, { raw: BaseMessage; parsed: RunOutput }>} A new runnable that calls the LLM with structured output.
+     */
+    withStructuredOutput({ schema, name, method = "functionCalling", includeRaw = false, }) {
+        let llm;
+        let outputParser;
+        if (method === "jsonMode") {
+            llm = this.bind({
+                response_format: { type: "json_object" },
+            });
+            outputParser = new output_parsers_1.JsonOutputParser();
+        }
+        else {
+            // Is function calling
+            if (isZodSchema(schema)) {
+                const asZodSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(schema);
+                llm = this.bind({
+                    tools: [
+                        {
+                            type: "function",
+                            function: {
+                                name,
+                                description: asZodSchema.description,
+                                parameters: asZodSchema,
+                            },
+                        },
+                    ],
+                    tool_choice: "auto",
+                });
+                outputParser = new openai_tools_1.JsonOutputKeyToolsParser({
+                    returnSingle: true,
+                    keyName: name,
+                });
+            }
+            else {
+                llm = this.bind({
+                    tools: [
+                        {
+                            type: "function",
+                            function: {
+                                name,
+                                description: schema.description,
+                                parameters: schema,
+                            },
+                        },
+                    ],
+                    tool_choice: "auto",
+                });
+                outputParser = new openai_tools_1.JsonOutputKeyToolsParser({
+                    returnSingle: true,
+                    keyName: name,
+                });
+            }
+        }
+        if (!includeRaw) {
+            return llm.pipe(outputParser);
+        }
+        const parserAssign = runnables_1.RunnablePassthrough.assign({
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            parsed: (input, config) => outputParser.invoke(input.raw, config),
+        });
+        const parserNone = runnables_1.RunnablePassthrough.assign({
+            parsed: () => null,
+        });
+        const parsedWithFallback = parserAssign.withFallbacks({
+            fallbacks: [parserNone],
+        });
+        return runnables_1.RunnableSequence.from([
+            {
+                raw: llm,
+            },
+            parsedWithFallback,
+        ]);
+    }
 }
 exports.ChatOpenAI = ChatOpenAI;
+function isZodSchema(input) {
+    // Check for a characteristic method of Zod schemas
+    return typeof input?.parse === "function";
+}

package/dist/chat_models.d.ts

@@ -2,9 +2,11 @@ import { type ClientOptions, OpenAI as OpenAIClient } from "openai";
 import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
 import { type BaseMessage } from "@langchain/core/messages";
 import { ChatGenerationChunk, type ChatResult } from "@langchain/core/outputs";
-import type { StructuredToolInterface } from "@langchain/core/tools";
+import { type StructuredToolInterface } from "@langchain/core/tools";
 import { BaseChatModel, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
-import type { BaseFunctionCallOptions } from "@langchain/core/language_models/base";
+import type { BaseFunctionCallOptions, BaseLanguageModelInput } from "@langchain/core/language_models/base";
+import { z } from "zod";
+import { Runnable } from "@langchain/core/runnables";
 import type { AzureOpenAIInput, OpenAICallOptions, OpenAIChatInput, OpenAICoreRequestOptions, LegacyOpenAIInput } from "./types.js";
 export type { AzureOpenAIInput, OpenAICallOptions, OpenAIChatInput };
 interface TokenUsage {
@@ -140,4 +142,19 @@ export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = Chat
     _llmType(): string;
     /** @ignore */
     _combineLLMOutput(...llmOutputs: OpenAILLMOutput[]): OpenAILLMOutput;
+    withStructuredOutput<RunInput = BaseLanguageModelInput, RunOutput extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>>({ schema, name, method, includeRaw, }: {
+        schema: z.ZodEffects<RunOutput> | Record<string, any>;
+        name: string;
+        method?: "functionCalling" | "jsonMode";
+        includeRaw: true;
+    }): Runnable<RunInput, {
+        raw: BaseMessage;
+        parsed: RunOutput;
+    }>;
+    withStructuredOutput<RunInput = BaseLanguageModelInput, RunOutput extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>>({ schema, name, method, includeRaw, }: {
+        schema: z.ZodEffects<RunOutput> | Record<string, any>;
+        name: string;
+        method?: "functionCalling" | "jsonMode";
+        includeRaw?: false;
+    }): Runnable<RunInput, RunOutput>;
 }

package/dist/chat_models.js

@@ -4,6 +4,10 @@ import { ChatGenerationChunk, } from "@langchain/core/outputs";
 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 { JsonOutputKeyToolsParser } from "@langchain/core/output_parsers/openai_tools";
+import { zodToJsonSchema } from "zod-to-json-schema";
 import { getEndpoint } from "./utils/azure.js";
 import { wrapOpenAIClientError } from "./utils/openai.js";
 import { formatFunctionDefinitions, } from "./utils/openai-format-fndef.js";
@@ -710,4 +714,90 @@ export class ChatOpenAI extends BaseChatModel {
             },
         });
     }
+    /**
+     * Model wrapper that returns outputs formatted to match the given schema.
+     *
+     * @template {z.ZodObject<any, any, any, any>} RunOutput The output type for the Runnable, expected to be a Zod schema object for structured output validation.
+     *
+     * @param {z.ZodEffects<RunOutput>} schema The schema for the structured output. Either as a Zod schema or a valid JSON schema object.
+     * @param {string} name The name of the function to call.
+     * @param {"functionCalling" | "jsonMode"} method The method to use for getting the structured output. Defaults to "functionCalling".
+     * @param {boolean | undefined} includeRaw Whether to include the raw output in the result. Defaults to false.
+     * @returns {Runnable<RunInput, RunOutput> | Runnable<RunInput, { raw: BaseMessage; parsed: RunOutput }>} A new runnable that calls the LLM with structured output.
+     */
+    withStructuredOutput({ schema, name, method = "functionCalling", includeRaw = false, }) {
+        let llm;
+        let outputParser;
+        if (method === "jsonMode") {
+            llm = this.bind({
+                response_format: { type: "json_object" },
+            });
+            outputParser = new JsonOutputParser();
+        }
+        else {
+            // Is function calling
+            if (isZodSchema(schema)) {
+                const asZodSchema = zodToJsonSchema(schema);
+                llm = this.bind({
+                    tools: [
+                        {
+                            type: "function",
+                            function: {
+                                name,
+                                description: asZodSchema.description,
+                                parameters: asZodSchema,
+                            },
+                        },
+                    ],
+                    tool_choice: "auto",
+                });
+                outputParser = new JsonOutputKeyToolsParser({
+                    returnSingle: true,
+                    keyName: name,
+                });
+            }
+            else {
+                llm = this.bind({
+                    tools: [
+                        {
+                            type: "function",
+                            function: {
+                                name,
+                                description: schema.description,
+                                parameters: schema,
+                            },
+                        },
+                    ],
+                    tool_choice: "auto",
+                });
+                outputParser = new JsonOutputKeyToolsParser({
+                    returnSingle: true,
+                    keyName: name,
+                });
+            }
+        }
+        if (!includeRaw) {
+            return llm.pipe(outputParser);
+        }
+        const parserAssign = RunnablePassthrough.assign({
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            parsed: (input, config) => outputParser.invoke(input.raw, config),
+        });
+        const parserNone = RunnablePassthrough.assign({
+            parsed: () => null,
+        });
+        const parsedWithFallback = parserAssign.withFallbacks({
+            fallbacks: [parserNone],
+        });
+        return RunnableSequence.from([
+            {
+                raw: llm,
+            },
+            parsedWithFallback,
+        ]);
+    }
+}
+function isZodSchema(input) {
+    // Check for a characteristic method of Zod schemas
+    return typeof input?.parse === "function";
 }

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

@@ -1,9 +1,11 @@
-import { test, jest, expect } from "@jest/globals";
+import { test, jest, expect, describe } 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 });
@@ -628,3 +630,173 @@ 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({
+            schema: 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({
+            schema: 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({
+            schema: 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({
+            schema: 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/openai",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "description": "OpenAI integrations for LangChain.js",
   "type": "module",
   "engines": {
@@ -12,6 +12,7 @@
     "type": "git",
     "url": "git@github.com:langchain-ai/langchainjs.git"
   },
+  "homepage": "https://github.com/langchain-ai/langchainjs/tree/main/libs/langchain-openai/",
   "scripts": {
     "build": "yarn run build:deps && yarn clean && yarn build:esm && yarn build:cjs && yarn build:scripts",
     "build:deps": "yarn run turbo:command build --filter=@langchain/core",
@@ -23,7 +24,7 @@
     "lint:dpdm": "dpdm --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts",
     "lint": "yarn lint:eslint && yarn lint:dpdm",
     "lint:fix": "yarn lint:eslint --fix && yarn lint:dpdm",
-    "clean": "rimraf .turbo/ dist/ && NODE_OPTIONS=--max-old-space-size=4096 yarn create-entrypoints -- --pre",
+    "clean": "rimraf .turbo/ dist/ && NODE_OPTIONS=--max-old-space-size=4096 yarn lc-build --config ./langchain.config.js --create-entrypoints --pre",
     "prepack": "yarn build",
     "test": "yarn run build:deps && NODE_OPTIONS=--experimental-vm-modules jest --testPathIgnorePatterns=\\.int\\.test.ts --testTimeout 30000 --maxWorkers=50%",
     "test:watch": "yarn run build:deps && NODE_OPTIONS=--experimental-vm-modules jest --watch --testPathIgnorePatterns=\\.int\\.test.ts",
@@ -38,7 +39,7 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@langchain/core": "~0.1.13",
+    "@langchain/core": "~0.1.39",
     "js-tiktoken": "^1.0.7",
     "openai": "^4.26.0",
     "zod": "^3.22.4",