langchain 0.0.211 → 0.0.213

package/dist/agents/openai/output_parser.cjs

@@ -1,198 +1,22 @@
 "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 });
-exports.OpenAIToolsAgentOutputParser = exports.OpenAIFunctionsAgentOutputParser = void 0;
-const index_js_1 = require("../../schema/index.cjs");
-const types_js_1 = require("../types.cjs");
-const output_parser_js_1 = require("../../schema/output_parser.cjs");
-/**
- * @example
- * ```typescript
- *
- * const prompt = ChatPromptTemplate.fromMessages([
- *   ["ai", "You are a helpful assistant"],
- *   ["human", "{input}"],
- *   new MessagesPlaceholder("agent_scratchpad"),
- * ]);
- *
- * const modelWithFunctions = new ChatOpenAI({
- *   modelName: "gpt-4",
- *   temperature: 0,
- * }).bind({
- *   functions: tools.map((tool) => formatToOpenAIFunction(tool)),
- * });
- *
- * const runnableAgent = RunnableSequence.from([
- *   {
- *     input: (i) => i.input,
- *     agent_scratchpad: (i) => formatAgentSteps(i.steps),
- *   },
- *   prompt,
- *   modelWithFunctions,
- *   new OpenAIFunctionsAgentOutputParser(),
- * ]);
- *
- * const result = await runnableAgent.invoke({
- *   input: "What is the weather in New York?",
- *   steps: agentSteps,
- * });
- *
- * ```
- */
-class OpenAIFunctionsAgentOutputParser extends types_js_1.AgentActionOutputParser {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "agents", "openai"]
-        });
-    }
-    static lc_name() {
-        return "OpenAIFunctionsAgentOutputParser";
-    }
-    async parse(text) {
-        throw new Error(`OpenAIFunctionsAgentOutputParser can only parse messages.\nPassed input: ${text}`);
-    }
-    async parseResult(generations) {
-        if ("message" in generations[0] && (0, index_js_1.isBaseMessage)(generations[0].message)) {
-            return this.parseAIMessage(generations[0].message);
-        }
-        throw new Error("parseResult on OpenAIFunctionsAgentOutputParser only works on ChatGeneration output");
-    }
-    /**
-     * Parses the output message into a FunctionsAgentAction or AgentFinish
-     * object.
-     * @param message The BaseMessage to parse.
-     * @returns A FunctionsAgentAction or AgentFinish object.
-     */
-    parseAIMessage(message) {
-        if (message.content && typeof message.content !== "string") {
-            throw new Error("This agent cannot parse non-string model responses.");
-        }
-        if (message.additional_kwargs.function_call) {
-            // eslint-disable-next-line prefer-destructuring
-            const function_call = message.additional_kwargs.function_call;
-            try {
-                const toolInput = function_call.arguments
-                    ? JSON.parse(function_call.arguments)
-                    : {};
-                return {
-                    tool: function_call.name,
-                    toolInput,
-                    log: `Invoking "${function_call.name}" with ${function_call.arguments ?? "{}"}\n${message.content}`,
-                    messageLog: [message],
-                };
-            }
-            catch (error) {
-                throw new output_parser_js_1.OutputParserException(`Failed to parse function arguments from chat model response. Text: "${function_call.arguments}". ${error}`);
-            }
-        }
-        else {
-            return {
-                returnValues: { output: message.content },
-                log: message.content,
-            };
-        }
-    }
-    getFormatInstructions() {
-        throw new Error("getFormatInstructions not implemented inside OpenAIFunctionsAgentOutputParser.");
-    }
-}
-exports.OpenAIFunctionsAgentOutputParser = OpenAIFunctionsAgentOutputParser;
-/**
- * @example
- * ```typescript
- *
- * const prompt = ChatPromptTemplate.fromMessages([
- *   ["ai", "You are a helpful assistant"],
- *   ["human", "{input}"],
- *   new MessagesPlaceholder("agent_scratchpad"),
- * ]);
- *
- * const runnableAgent = RunnableSequence.from([
- *   {
- *     input: (i: { input: string; steps: ToolsAgentStep[] }) => i.input,
- *     agent_scratchpad: (i: { input: string; steps: ToolsAgentStep[] }) =>
- *       formatToOpenAIToolMessages(i.steps),
- *   },
- *   prompt,
- *   new ChatOpenAI({
- *     modelName: "gpt-3.5-turbo-1106",
- *     temperature: 0,
- *   }).bind({ tools: tools.map(formatToOpenAITool) }),
- *   new OpenAIToolsAgentOutputParser(),
- * ]).withConfig({ runName: "OpenAIToolsAgent" });
- *
- * const result = await runnableAgent.invoke({
- *   input:
- *     "What is the sum of the current temperature in San Francisco, New York, and Tokyo?",
- * });
- *
- * ```
- */
-class OpenAIToolsAgentOutputParser extends types_js_1.AgentMultiActionOutputParser {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "agents", "openai"]
-        });
-    }
-    static lc_name() {
-        return "OpenAIToolsAgentOutputParser";
-    }
-    async parse(text) {
-        throw new Error(`OpenAIFunctionsAgentOutputParser can only parse messages.\nPassed input: ${text}`);
-    }
-    async parseResult(generations) {
-        if ("message" in generations[0] && (0, index_js_1.isBaseMessage)(generations[0].message)) {
-            return this.parseAIMessage(generations[0].message);
-        }
-        throw new Error("parseResult on OpenAIFunctionsAgentOutputParser only works on ChatGeneration output");
-    }
-    /**
-     * Parses the output message into a ToolsAgentAction[] or AgentFinish
-     * object.
-     * @param message The BaseMessage to parse.
-     * @returns A ToolsAgentAction[] or AgentFinish object.
-     */
-    parseAIMessage(message) {
-        if (message.content && typeof message.content !== "string") {
-            throw new Error("This agent cannot parse non-string model responses.");
-        }
-        if (message.additional_kwargs.tool_calls) {
-            const toolCalls = message.additional_kwargs.tool_calls;
-            try {
-                return toolCalls.map((toolCall, i) => {
-                    const toolInput = toolCall.function.arguments
-                        ? JSON.parse(toolCall.function.arguments)
-                        : {};
-                    const messageLog = i === 0 ? [message] : [];
-                    return {
-                        tool: toolCall.function.name,
-                        toolInput,
-                        toolCallId: toolCall.id,
-                        log: `Invoking "${toolCall.function.name}" with ${toolCall.function.arguments ?? "{}"}\n${message.content}`,
-                        messageLog,
-                    };
-                });
-            }
-            catch (error) {
-                throw new output_parser_js_1.OutputParserException(`Failed to parse tool arguments from chat model response. Text: "${JSON.stringify(toolCalls)}". ${error}`);
-            }
-        }
-        else {
-            return {
-                returnValues: { output: message.content },
-                log: message.content,
-            };
-        }
-    }
-    getFormatInstructions() {
-        throw new Error("getFormatInstructions not implemented inside OpenAIToolsAgentOutputParser.");
-    }
-}
-exports.OpenAIToolsAgentOutputParser = OpenAIToolsAgentOutputParser;
+// console.warn([
+//   `[WARNING]: The root "langchain/agents/openai/output_parser" entrypoint is deprecated.`,
+//   `Please use either "langchain/agents/openai/output_parser" specific entrypoint instead.`
+// ].join("\n"));
+__exportStar(require("../openai_functions/output_parser.cjs"), exports);
+__exportStar(require("../openai_tools/output_parser.cjs"), exports);

package/dist/agents/openai/output_parser.d.ts

@@ -1,111 +1,2 @@
-import { AgentAction, AgentFinish, AgentStep, BaseMessage, ChatGeneration } from "../../schema/index.js";
-import { AgentActionOutputParser, AgentMultiActionOutputParser } from "../types.js";
-/**
- * Type that represents an agent action with an optional message log.
- */
-export type FunctionsAgentAction = AgentAction & {
-    messageLog?: BaseMessage[];
-};
-/**
- * @example
- * ```typescript
- *
- * const prompt = ChatPromptTemplate.fromMessages([
- *   ["ai", "You are a helpful assistant"],
- *   ["human", "{input}"],
- *   new MessagesPlaceholder("agent_scratchpad"),
- * ]);
- *
- * const modelWithFunctions = new ChatOpenAI({
- *   modelName: "gpt-4",
- *   temperature: 0,
- * }).bind({
- *   functions: tools.map((tool) => formatToOpenAIFunction(tool)),
- * });
- *
- * const runnableAgent = RunnableSequence.from([
- *   {
- *     input: (i) => i.input,
- *     agent_scratchpad: (i) => formatAgentSteps(i.steps),
- *   },
- *   prompt,
- *   modelWithFunctions,
- *   new OpenAIFunctionsAgentOutputParser(),
- * ]);
- *
- * const result = await runnableAgent.invoke({
- *   input: "What is the weather in New York?",
- *   steps: agentSteps,
- * });
- *
- * ```
- */
-export declare class OpenAIFunctionsAgentOutputParser extends AgentActionOutputParser {
-    lc_namespace: string[];
-    static lc_name(): string;
-    parse(text: string): Promise<AgentAction | AgentFinish>;
-    parseResult(generations: ChatGeneration[]): Promise<AgentFinish | FunctionsAgentAction>;
-    /**
-     * Parses the output message into a FunctionsAgentAction or AgentFinish
-     * object.
-     * @param message The BaseMessage to parse.
-     * @returns A FunctionsAgentAction or AgentFinish object.
-     */
-    parseAIMessage(message: BaseMessage): FunctionsAgentAction | AgentFinish;
-    getFormatInstructions(): string;
-}
-/**
- * Type that represents an agent action with an optional message log.
- */
-export type ToolsAgentAction = AgentAction & {
-    toolCallId: string;
-    messageLog?: BaseMessage[];
-};
-export type ToolsAgentStep = AgentStep & {
-    action: ToolsAgentAction;
-};
-/**
- * @example
- * ```typescript
- *
- * const prompt = ChatPromptTemplate.fromMessages([
- *   ["ai", "You are a helpful assistant"],
- *   ["human", "{input}"],
- *   new MessagesPlaceholder("agent_scratchpad"),
- * ]);
- *
- * const runnableAgent = RunnableSequence.from([
- *   {
- *     input: (i: { input: string; steps: ToolsAgentStep[] }) => i.input,
- *     agent_scratchpad: (i: { input: string; steps: ToolsAgentStep[] }) =>
- *       formatToOpenAIToolMessages(i.steps),
- *   },
- *   prompt,
- *   new ChatOpenAI({
- *     modelName: "gpt-3.5-turbo-1106",
- *     temperature: 0,
- *   }).bind({ tools: tools.map(formatToOpenAITool) }),
- *   new OpenAIToolsAgentOutputParser(),
- * ]).withConfig({ runName: "OpenAIToolsAgent" });
- *
- * const result = await runnableAgent.invoke({
- *   input:
- *     "What is the sum of the current temperature in San Francisco, New York, and Tokyo?",
- * });
- *
- * ```
- */
-export declare class OpenAIToolsAgentOutputParser extends AgentMultiActionOutputParser {
-    lc_namespace: string[];
-    static lc_name(): string;
-    parse(text: string): Promise<AgentAction[] | AgentFinish>;
-    parseResult(generations: ChatGeneration[]): Promise<AgentFinish | ToolsAgentAction[]>;
-    /**
-     * Parses the output message into a ToolsAgentAction[] or AgentFinish
-     * object.
-     * @param message The BaseMessage to parse.
-     * @returns A ToolsAgentAction[] or AgentFinish object.
-     */
-    parseAIMessage(message: BaseMessage): ToolsAgentAction[] | AgentFinish;
-    getFormatInstructions(): string;
-}
+export * from "../openai_functions/output_parser.js";
+export * from "../openai_tools/output_parser.js";

package/dist/agents/openai/output_parser.js

@@ -1,193 +1,6 @@
-import { isBaseMessage, } from "../../schema/index.js";
-import { AgentActionOutputParser, AgentMultiActionOutputParser, } from "../types.js";
-import { OutputParserException } from "../../schema/output_parser.js";
-/**
- * @example
- * ```typescript
- *
- * const prompt = ChatPromptTemplate.fromMessages([
- *   ["ai", "You are a helpful assistant"],
- *   ["human", "{input}"],
- *   new MessagesPlaceholder("agent_scratchpad"),
- * ]);
- *
- * const modelWithFunctions = new ChatOpenAI({
- *   modelName: "gpt-4",
- *   temperature: 0,
- * }).bind({
- *   functions: tools.map((tool) => formatToOpenAIFunction(tool)),
- * });
- *
- * const runnableAgent = RunnableSequence.from([
- *   {
- *     input: (i) => i.input,
- *     agent_scratchpad: (i) => formatAgentSteps(i.steps),
- *   },
- *   prompt,
- *   modelWithFunctions,
- *   new OpenAIFunctionsAgentOutputParser(),
- * ]);
- *
- * const result = await runnableAgent.invoke({
- *   input: "What is the weather in New York?",
- *   steps: agentSteps,
- * });
- *
- * ```
- */
-export class OpenAIFunctionsAgentOutputParser extends AgentActionOutputParser {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "agents", "openai"]
-        });
-    }
-    static lc_name() {
-        return "OpenAIFunctionsAgentOutputParser";
-    }
-    async parse(text) {
-        throw new Error(`OpenAIFunctionsAgentOutputParser can only parse messages.\nPassed input: ${text}`);
-    }
-    async parseResult(generations) {
-        if ("message" in generations[0] && isBaseMessage(generations[0].message)) {
-            return this.parseAIMessage(generations[0].message);
-        }
-        throw new Error("parseResult on OpenAIFunctionsAgentOutputParser only works on ChatGeneration output");
-    }
-    /**
-     * Parses the output message into a FunctionsAgentAction or AgentFinish
-     * object.
-     * @param message The BaseMessage to parse.
-     * @returns A FunctionsAgentAction or AgentFinish object.
-     */
-    parseAIMessage(message) {
-        if (message.content && typeof message.content !== "string") {
-            throw new Error("This agent cannot parse non-string model responses.");
-        }
-        if (message.additional_kwargs.function_call) {
-            // eslint-disable-next-line prefer-destructuring
-            const function_call = message.additional_kwargs.function_call;
-            try {
-                const toolInput = function_call.arguments
-                    ? JSON.parse(function_call.arguments)
-                    : {};
-                return {
-                    tool: function_call.name,
-                    toolInput,
-                    log: `Invoking "${function_call.name}" with ${function_call.arguments ?? "{}"}\n${message.content}`,
-                    messageLog: [message],
-                };
-            }
-            catch (error) {
-                throw new OutputParserException(`Failed to parse function arguments from chat model response. Text: "${function_call.arguments}". ${error}`);
-            }
-        }
-        else {
-            return {
-                returnValues: { output: message.content },
-                log: message.content,
-            };
-        }
-    }
-    getFormatInstructions() {
-        throw new Error("getFormatInstructions not implemented inside OpenAIFunctionsAgentOutputParser.");
-    }
-}
-/**
- * @example
- * ```typescript
- *
- * const prompt = ChatPromptTemplate.fromMessages([
- *   ["ai", "You are a helpful assistant"],
- *   ["human", "{input}"],
- *   new MessagesPlaceholder("agent_scratchpad"),
- * ]);
- *
- * const runnableAgent = RunnableSequence.from([
- *   {
- *     input: (i: { input: string; steps: ToolsAgentStep[] }) => i.input,
- *     agent_scratchpad: (i: { input: string; steps: ToolsAgentStep[] }) =>
- *       formatToOpenAIToolMessages(i.steps),
- *   },
- *   prompt,
- *   new ChatOpenAI({
- *     modelName: "gpt-3.5-turbo-1106",
- *     temperature: 0,
- *   }).bind({ tools: tools.map(formatToOpenAITool) }),
- *   new OpenAIToolsAgentOutputParser(),
- * ]).withConfig({ runName: "OpenAIToolsAgent" });
- *
- * const result = await runnableAgent.invoke({
- *   input:
- *     "What is the sum of the current temperature in San Francisco, New York, and Tokyo?",
- * });
- *
- * ```
- */
-export class OpenAIToolsAgentOutputParser extends AgentMultiActionOutputParser {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "agents", "openai"]
-        });
-    }
-    static lc_name() {
-        return "OpenAIToolsAgentOutputParser";
-    }
-    async parse(text) {
-        throw new Error(`OpenAIFunctionsAgentOutputParser can only parse messages.\nPassed input: ${text}`);
-    }
-    async parseResult(generations) {
-        if ("message" in generations[0] && isBaseMessage(generations[0].message)) {
-            return this.parseAIMessage(generations[0].message);
-        }
-        throw new Error("parseResult on OpenAIFunctionsAgentOutputParser only works on ChatGeneration output");
-    }
-    /**
-     * Parses the output message into a ToolsAgentAction[] or AgentFinish
-     * object.
-     * @param message The BaseMessage to parse.
-     * @returns A ToolsAgentAction[] or AgentFinish object.
-     */
-    parseAIMessage(message) {
-        if (message.content && typeof message.content !== "string") {
-            throw new Error("This agent cannot parse non-string model responses.");
-        }
-        if (message.additional_kwargs.tool_calls) {
-            const toolCalls = message.additional_kwargs.tool_calls;
-            try {
-                return toolCalls.map((toolCall, i) => {
-                    const toolInput = toolCall.function.arguments
-                        ? JSON.parse(toolCall.function.arguments)
-                        : {};
-                    const messageLog = i === 0 ? [message] : [];
-                    return {
-                        tool: toolCall.function.name,
-                        toolInput,
-                        toolCallId: toolCall.id,
-                        log: `Invoking "${toolCall.function.name}" with ${toolCall.function.arguments ?? "{}"}\n${message.content}`,
-                        messageLog,
-                    };
-                });
-            }
-            catch (error) {
-                throw new OutputParserException(`Failed to parse tool arguments from chat model response. Text: "${JSON.stringify(toolCalls)}". ${error}`);
-            }
-        }
-        else {
-            return {
-                returnValues: { output: message.content },
-                log: message.content,
-            };
-        }
-    }
-    getFormatInstructions() {
-        throw new Error("getFormatInstructions not implemented inside OpenAIToolsAgentOutputParser.");
-    }
-}
+// console.warn([
+//   `[WARNING]: The root "langchain/agents/openai/output_parser" entrypoint is deprecated.`,
+//   `Please use either "langchain/agents/openai/output_parser" specific entrypoint instead.`
+// ].join("\n"));
+export * from "../openai_functions/output_parser.js";
+export * from "../openai_tools/output_parser.js";

package/dist/agents/{openai → openai_functions}/index.cjs

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAIAgent = exports._formatIntermediateSteps = void 0;
+exports.createOpenAIFunctionsAgent = exports.OpenAIAgent = exports._formatIntermediateSteps = void 0;
+const runnables_1 = require("@langchain/core/runnables");
 const index_js_1 = require("../../schema/index.cjs");
 const agent_js_1 = require("../agent.cjs");
 const prompt_js_1 = require("./prompt.cjs");
 const chat_js_1 = require("../../prompts/chat.cjs");
 const llm_chain_js_1 = require("../../chains/llm_chain.cjs");
-const output_parser_js_1 = require("./output_parser.cjs");
+const output_parser_js_1 = require("../openai/output_parser.cjs");
 const convert_to_openai_js_1 = require("../../tools/convert_to_openai.cjs");
+const openai_functions_js_1 = require("../format_scratchpad/openai_functions.cjs");
 /**
  * Checks if the given action is a FunctionsAgentAction.
  * @param action The action to check.
@@ -160,3 +162,77 @@ class OpenAIAgent extends agent_js_1.Agent {
     }
 }
 exports.OpenAIAgent = OpenAIAgent;
+/**
+ * Create an agent that uses OpenAI-style function calling.
+ * @param params Params required to create the agent. Includes an LLM, tools, and prompt.
+ * @returns A runnable sequence representing an agent. It takes as input all the same input
+ *     variables as the prompt passed in does. It returns as output either an
+ *     AgentAction or AgentFinish.
+ *
+ * @example
+ * ```typescript
+ * import { AgentExecutor, createOpenAIFunctionsAgent } from "langchain/agents";
+ * import { pull } from "langchain/hub";
+ * import type { ChatPromptTemplate } from "@langchain/core/prompts";
+ * import { AIMessage, HumanMessage } from "@langchain/core/messages";
+ *
+ * import { ChatOpenAI } from "@langchain/openai";
+ *
+ * // Define the tools the agent will have access to.
+ * const tools = [...];
+ *
+ * // Get the prompt to use - you can modify this!
+ * const prompt = await pull<ChatPromptTemplate>(
+ *   "hwchase17/openai-functions-agent"
+ * );
+ *
+ * const llm = new ChatOpenAI({
+ *   temperature: 0,
+ * });
+ *
+ * const agent = await createOpenAIFunctionsAgent({
+ *   llm,
+ *   tools,
+ *   prompt,
+ * });
+ *
+ * const agentExecutor = new AgentExecutor({
+ *   agent,
+ *   tools,
+ * });
+ *
+ * const result = await agentExecutor.invoke({
+ *   input: "what is LangChain?",
+ * });
+ *
+ * // With chat history
+ * const result2 = await agentExecutor.invoke({
+ *   input: "what's my name?",
+ *   chat_history: [
+ *     new HumanMessage("hi! my name is cob"),
+ *     new AIMessage("Hello Cob! How can I assist you today?"),
+ *   ],
+ * });
+ * ```
+ */
+async function createOpenAIFunctionsAgent({ llm, tools, prompt, }) {
+    if (!prompt.inputVariables.includes("agent_scratchpad")) {
+        throw new Error([
+            `Prompt must have an input variable named "agent_scratchpad".`,
+            `Found ${JSON.stringify(prompt.inputVariables)} instead.`,
+        ].join("\n"));
+    }
+    const llmWithTools = llm.bind({
+        functions: tools.map(convert_to_openai_js_1.formatToOpenAIFunction),
+    });
+    const agent = runnables_1.RunnableSequence.from([
+        runnables_1.RunnablePassthrough.assign({
+            agent_scratchpad: (input) => (0, openai_functions_js_1.formatToOpenAIFunctionMessages)(input.steps),
+        }),
+        prompt,
+        llmWithTools,
+        new output_parser_js_1.OpenAIFunctionsAgentOutputParser(),
+    ]);
+    return agent;
+}
+exports.createOpenAIFunctionsAgent = createOpenAIFunctionsAgent;