@langchain/langgraph 0.2.40 → 0.2.42

package/dist/prebuilt/agent_executor.cjs

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAgentExecutor = void 0;
 const tool_executor_js_1 = require("./tool_executor.cjs");
 const state_js_1 = require("../graph/state.cjs");
-const index_js_1 = require("../graph/index.cjs");
+const constants_js_1 = require("../constants.cjs");
 /** @ignore */
 function createAgentExecutor({ agentRunnable, tools, }) {
     let toolExecutor;
@@ -54,7 +54,7 @@ function createAgentExecutor({ agentRunnable, tools, }) {
         .addNode("action", executeTools)
         // Set the entrypoint as `agent`
         // This means that this node is the first one called
-        .addEdge(index_js_1.START, "agent")
+        .addEdge(constants_js_1.START, "agent")
         // We now add a conditional edge
         .addConditionalEdges(
     // First, we define the start node. We use `agent`.
@@ -72,7 +72,7 @@ function createAgentExecutor({ agentRunnable, tools, }) {
         // If `tools`, then we call the tool node.
         continue: "action",
         // Otherwise we finish.
-        end: index_js_1.END,
+        end: constants_js_1.END,
     })
         // We now add a normal edge from `tools` to `agent`.
         // This means that after `tools` is called, `agent` node is called next.

package/dist/prebuilt/agent_executor.d.ts

@@ -18,5 +18,5 @@ export interface AgentExecutorState {
 export declare function createAgentExecutor({ agentRunnable, tools, }: {
     agentRunnable: Runnable;
     tools: Array<Tool> | ToolExecutor;
-}): import("../graph/state.js").CompiledStateGraph<AgentExecutorState, Partial<AgentExecutorState>, "__start__" | "agent" | "action", import("../graph/annotation.js").StateDefinition, import("../graph/annotation.js").StateDefinition, import("../graph/annotation.js").StateDefinition>;
+}): import("../graph/state.js").CompiledStateGraph<AgentExecutorState, Partial<AgentExecutorState>, "__start__" | "agent" | "action", import("../web.js").StateDefinition, import("../web.js").StateDefinition, import("../web.js").StateDefinition>;
 export {};

package/dist/prebuilt/agent_executor.js

@@ -1,6 +1,6 @@
 import { ToolExecutor } from "./tool_executor.js";
 import { StateGraph } from "../graph/state.js";
-import { END, START } from "../graph/index.js";
+import { END, START } from "../constants.js";
 /** @ignore */
 export function createAgentExecutor({ agentRunnable, tools, }) {
     let toolExecutor;

package/dist/prebuilt/chat_agent_executor.cjs

@@ -6,7 +6,7 @@ const messages_1 = require("@langchain/core/messages");
 const runnables_1 = require("@langchain/core/runnables");
 const tool_executor_js_1 = require("./tool_executor.cjs");
 const state_js_1 = require("../graph/state.cjs");
-const index_js_1 = require("../graph/index.cjs");
+const constants_js_1 = require("../constants.cjs");
 /** @deprecated Use {@link createReactAgent} instead with tool calling. */
 function createFunctionCallingExecutor({ model, tools, }) {
     let toolExecutor;
@@ -99,7 +99,7 @@ function createFunctionCallingExecutor({ model, tools, }) {
         .addNode("action", new runnables_1.RunnableLambda({ func: callTool }))
         // Set the entrypoint as `agent`
         // This means that this node is the first one called
-        .addEdge(index_js_1.START, "agent")
+        .addEdge(constants_js_1.START, "agent")
         // We now add a conditional edge
         .addConditionalEdges(
     // First, we define the start node. We use `agent`.
@@ -117,7 +117,7 @@ function createFunctionCallingExecutor({ model, tools, }) {
         // If `tools`, then we call the tool node.
         continue: "action",
         // Otherwise we finish.
-        end: index_js_1.END,
+        end: constants_js_1.END,
     })
         // We now add a normal edge from `tools` to `agent`.
         // This means that after `tools` is called, `agent` node is called next.

package/dist/prebuilt/chat_agent_executor.d.ts

@@ -3,7 +3,7 @@ import { BaseMessage } from "@langchain/core/messages";
 import { RunnableToolLike } from "@langchain/core/runnables";
 import { ToolExecutor } from "./tool_executor.js";
 import { CompiledStateGraph } from "../graph/state.js";
-import { START } from "../graph/index.js";
+import { START } from "../constants.js";
 /** @deprecated Use {@link createReactAgent} instead with tool calling. */
 export type FunctionCallingExecutorState = {
     messages: Array<BaseMessage>;

package/dist/prebuilt/chat_agent_executor.js

@@ -3,7 +3,7 @@ import { FunctionMessage } from "@langchain/core/messages";
 import { RunnableLambda, } from "@langchain/core/runnables";
 import { ToolExecutor } from "./tool_executor.js";
 import { StateGraph, } from "../graph/state.js";
-import { END, START } from "../graph/index.js";
+import { END, START } from "../constants.js";
 /** @deprecated Use {@link createReactAgent} instead with tool calling. */
 export function createFunctionCallingExecutor({ model, tools, }) {
     let toolExecutor;

package/dist/prebuilt/react_agent_executor.cjs

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createReactAgent = void 0;
+exports.createReactAgent = exports.createReactAgentAnnotation = void 0;
 const messages_1 = require("@langchain/core/messages");
 const runnables_1 = require("@langchain/core/runnables");
 const index_js_1 = require("../graph/index.cjs");
-const messages_annotation_js_1 = require("../graph/messages_annotation.cjs");
 const tool_node_js_1 = require("./tool_node.cjs");
+const annotation_js_1 = require("../graph/annotation.cjs");
+const message_js_1 = require("../graph/message.cjs");
+const constants_js_1 = require("../constants.cjs");
 function _convertMessageModifierToStateModifier(messageModifier) {
     // Handle string or SystemMessage
     if (typeof messageModifier === "string" ||
@@ -65,6 +67,14 @@ function _getModelPreprocessingRunnable(stateModifier, messageModifier) {
     }
     return _getStateModifierRunnable(stateModifier);
 }
+const createReactAgentAnnotation = () => annotation_js_1.Annotation.Root({
+    messages: (0, annotation_js_1.Annotation)({
+        reducer: message_js_1.messagesStateReducer,
+        default: () => [],
+    }),
+    structuredResponse: (annotation_js_1.Annotation),
+});
+exports.createReactAgentAnnotation = createReactAgentAnnotation;
 /**
  * Creates a StateGraph agent that relies on a chat model utilizing tool calling.
  *
@@ -108,7 +118,7 @@ function _getModelPreprocessingRunnable(stateModifier, messageModifier) {
  * ```
  */
 function createReactAgent(params) {
-    const { llm, tools, messageModifier, stateModifier, stateSchema, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
+    const { llm, tools, messageModifier, stateModifier, stateSchema, checkpointSaver, checkpointer, interruptBefore, interruptAfter, store, responseFormat, } = params;
     let toolClasses;
     if (!Array.isArray(tools)) {
         toolClasses = tools.tools;
@@ -123,32 +133,89 @@ function createReactAgent(params) {
     // we're passing store here for validation
     const preprocessor = _getModelPreprocessingRunnable(stateModifier, messageModifier);
     const modelRunnable = preprocessor.pipe(modelWithTools);
+    // If any of the tools are configured to return_directly after running,
+    // our graph needs to check if these were called
+    const shouldReturnDirect = new Set(toolClasses
+        .filter((tool) => "returnDirect" in tool && tool.returnDirect)
+        .map((tool) => tool.name));
     const shouldContinue = (state) => {
         const { messages } = state;
         const lastMessage = messages[messages.length - 1];
         if ((0, messages_1.isAIMessage)(lastMessage) &&
             (!lastMessage.tool_calls || lastMessage.tool_calls.length === 0)) {
-            return index_js_1.END;
+            return responseFormat != null ? "generate_structured_response" : constants_js_1.END;
         }
         else {
             return "continue";
         }
     };
+    const generateStructuredResponse = async (state, config) => {
+        if (responseFormat == null) {
+            throw new Error("Attempted to generate structured output with no passed response schema. Please contact us for help.");
+        }
+        // Exclude the last message as there's enough information
+        // for the LLM to generate the structured response
+        const messages = state.messages.slice(0, -1);
+        let modelWithStructuredOutput;
+        if (typeof responseFormat === "object" &&
+            "prompt" in responseFormat &&
+            "schema" in responseFormat) {
+            const { prompt, schema } = responseFormat;
+            modelWithStructuredOutput = llm.withStructuredOutput(schema);
+            messages.unshift(new messages_1.SystemMessage({ content: prompt }));
+        }
+        else {
+            modelWithStructuredOutput = llm.withStructuredOutput(responseFormat);
+        }
+        const response = await modelWithStructuredOutput.invoke(messages, config);
+        return { structuredResponse: response };
+    };
     const callModel = async (state, config) => {
         // TODO: Auto-promote streaming.
         return { messages: [await modelRunnable.invoke(state, config)] };
     };
-    const workflow = new index_js_1.StateGraph(stateSchema ?? messages_annotation_js_1.MessagesAnnotation)
+    const workflow = new index_js_1.StateGraph(stateSchema ?? (0, exports.createReactAgentAnnotation)())
         .addNode("agent", callModel)
         .addNode("tools", new tool_node_js_1.ToolNode(toolClasses))
-        .addEdge(index_js_1.START, "agent")
-        .addConditionalEdges("agent", shouldContinue, {
-        continue: "tools",
-        [index_js_1.END]: index_js_1.END,
-    })
-        .addEdge("tools", "agent");
+        .addEdge(constants_js_1.START, "agent");
+    if (responseFormat !== undefined) {
+        workflow
+            .addNode("generate_structured_response", generateStructuredResponse)
+            .addEdge("generate_structured_response", constants_js_1.END)
+            .addConditionalEdges("agent", shouldContinue, {
+            continue: "tools",
+            [constants_js_1.END]: constants_js_1.END,
+            generate_structured_response: "generate_structured_response",
+        });
+    }
+    else {
+        workflow.addConditionalEdges("agent", shouldContinue, {
+            continue: "tools",
+            [constants_js_1.END]: constants_js_1.END,
+        });
+    }
+    const routeToolResponses = (state) => {
+        // Check the last consecutive tool calls
+        for (let i = state.messages.length - 1; i >= 0; i -= 1) {
+            const message = state.messages[i];
+            if (!(0, messages_1.isToolMessage)(message)) {
+                break;
+            }
+            // Check if this tool is configured to return directly
+            if (message.name !== undefined && shouldReturnDirect.has(message.name)) {
+                return constants_js_1.END;
+            }
+        }
+        return "agent";
+    };
+    if (shouldReturnDirect.size > 0) {
+        workflow.addConditionalEdges("tools", routeToolResponses, ["agent", constants_js_1.END]);
+    }
+    else {
+        workflow.addEdge("tools", "agent");
+    }
     return workflow.compile({
-        checkpointer: checkpointSaver,
+        checkpointer: checkpointer ?? checkpointSaver,
         interruptBefore,
         interruptAfter,
         store,

package/dist/prebuilt/react_agent_executor.d.ts

@@ -3,18 +3,34 @@ import { BaseMessage, BaseMessageLike, SystemMessage } from "@langchain/core/mes
 import { Runnable, RunnableToolLike } from "@langchain/core/runnables";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
-import { START, CompiledStateGraph, AnnotationRoot } from "../graph/index.js";
+import { z } from "zod";
+import { CompiledStateGraph, AnnotationRoot } from "../graph/index.js";
 import { MessagesAnnotation } from "../graph/messages_annotation.js";
 import { ToolNode } from "./tool_node.js";
 import { LangGraphRunnableConfig } from "../pregel/runnable_types.js";
-export interface AgentState {
+import { Messages } from "../graph/message.js";
+import { START } from "../constants.js";
+export interface AgentState<StructuredResponseType extends Record<string, any> = Record<string, any>> {
     messages: BaseMessage[];
+    structuredResponse: StructuredResponseType;
 }
 export type N = typeof START | "agent" | "tools";
+export type StructuredResponseSchemaAndPrompt<StructuredResponseType> = {
+    prompt: string;
+    schema: z.ZodType<StructuredResponseType> | Record<string, any>;
+};
 export type StateModifier = SystemMessage | string | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => BaseMessageLike[]) | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => Promise<BaseMessageLike[]>) | Runnable;
 /** @deprecated Use StateModifier instead. */
 export type MessageModifier = SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | ((messages: BaseMessage[]) => Promise<BaseMessage[]>) | Runnable;
-export type CreateReactAgentParams<A extends AnnotationRoot<any> = AnnotationRoot<any>> = {
+export declare const createReactAgentAnnotation: <T extends Record<string, any> = Record<string, any>>() => AnnotationRoot<{
+    messages: import("../web.js").BinaryOperatorAggregate<BaseMessage[], Messages>;
+    structuredResponse: {
+        (): import("../web.js").LastValue<T>;
+        (annotation: import("../graph/annotation.js").SingleReducer<T, T>): import("../web.js").BinaryOperatorAggregate<T, T>;
+        Root: <S extends import("../graph/annotation.js").StateDefinition>(sd: S) => AnnotationRoot<S>;
+    };
+}>;
+export type CreateReactAgentParams<A extends AnnotationRoot<any> = AnnotationRoot<any>, StructuredResponseType = Record<string, any>> = {
     /** The chat model that can utilize OpenAI-style tool calling. */
     llm: BaseChatModel;
     /** A list of tools or a ToolNode. */
@@ -76,11 +92,26 @@ export type CreateReactAgentParams<A extends AnnotationRoot<any> = AnnotationRoo
     stateSchema?: A;
     /** An optional checkpoint saver to persist the agent's state. */
     checkpointSaver?: BaseCheckpointSaver;
+    /** An optional checkpoint saver to persist the agent's state. Alias of "checkpointSaver". */
+    checkpointer?: BaseCheckpointSaver;
     /** An optional list of node names to interrupt before running. */
     interruptBefore?: N[] | All;
     /** An optional list of node names to interrupt after running. */
     interruptAfter?: N[] | All;
     store?: BaseStore;
+    /**
+     * An optional schema for the final agent output.
+     *
+     * If provided, output will be formatted to match the given schema and returned in the 'structured_response' state key.
+     * If not provided, `structured_response` will not be present in the output state.
+     *
+     * Can be passed in as:
+     *   - Zod schema
+     *   - Dictionary object
+     *   - [prompt, schema], where schema is one of the above.
+     *        The prompt will be used together with the model that is being used to generate the structured response.
+     */
+    responseFormat?: z.ZodType<StructuredResponseType> | StructuredResponseSchemaAndPrompt<StructuredResponseType> | Record<string, any>;
 };
 /**
  * Creates a StateGraph agent that relies on a chat model utilizing tool calling.
@@ -124,4 +155,4 @@ export type CreateReactAgentParams<A extends AnnotationRoot<any> = AnnotationRoo
  * // Returns the messages in the state at each step of execution
  * ```
  */
-export declare function createReactAgent<A extends AnnotationRoot<any> = AnnotationRoot<any>>(params: CreateReactAgentParams<A>): CompiledStateGraph<(typeof MessagesAnnotation)["State"], (typeof MessagesAnnotation)["Update"], typeof START | "agent" | "tools", typeof MessagesAnnotation.spec & A["spec"], typeof MessagesAnnotation.spec & A["spec"]>;
+export declare function createReactAgent<A extends AnnotationRoot<any> = AnnotationRoot<{}>, StructuredResponseFormat extends Record<string, any> = Record<string, any>>(params: CreateReactAgentParams<A, StructuredResponseFormat>): CompiledStateGraph<(typeof MessagesAnnotation)["State"], (typeof MessagesAnnotation)["Update"], any, typeof MessagesAnnotation.spec & A["spec"], ReturnType<typeof createReactAgentAnnotation<StructuredResponseFormat>>["spec"] & A["spec"]>;

package/dist/prebuilt/react_agent_executor.js

@@ -1,8 +1,10 @@
-import { isAIMessage, isBaseMessage, SystemMessage, } from "@langchain/core/messages";
+import { isAIMessage, isBaseMessage, isToolMessage, SystemMessage, } from "@langchain/core/messages";
 import { Runnable, RunnableLambda, } from "@langchain/core/runnables";
-import { END, START, StateGraph, } from "../graph/index.js";
-import { MessagesAnnotation } from "../graph/messages_annotation.js";
+import { StateGraph, } from "../graph/index.js";
 import { ToolNode } from "./tool_node.js";
+import { Annotation } from "../graph/annotation.js";
+import { messagesStateReducer } from "../graph/message.js";
+import { END, START } from "../constants.js";
 function _convertMessageModifierToStateModifier(messageModifier) {
     // Handle string or SystemMessage
     if (typeof messageModifier === "string" ||
@@ -62,6 +64,13 @@ function _getModelPreprocessingRunnable(stateModifier, messageModifier) {
     }
     return _getStateModifierRunnable(stateModifier);
 }
+export const createReactAgentAnnotation = () => Annotation.Root({
+    messages: Annotation({
+        reducer: messagesStateReducer,
+        default: () => [],
+    }),
+    structuredResponse: (Annotation),
+});
 /**
  * Creates a StateGraph agent that relies on a chat model utilizing tool calling.
  *
@@ -105,7 +114,7 @@ function _getModelPreprocessingRunnable(stateModifier, messageModifier) {
  * ```
  */
 export function createReactAgent(params) {
-    const { llm, tools, messageModifier, stateModifier, stateSchema, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
+    const { llm, tools, messageModifier, stateModifier, stateSchema, checkpointSaver, checkpointer, interruptBefore, interruptAfter, store, responseFormat, } = params;
     let toolClasses;
     if (!Array.isArray(tools)) {
         toolClasses = tools.tools;
@@ -120,32 +129,89 @@ export function createReactAgent(params) {
     // we're passing store here for validation
     const preprocessor = _getModelPreprocessingRunnable(stateModifier, messageModifier);
     const modelRunnable = preprocessor.pipe(modelWithTools);
+    // If any of the tools are configured to return_directly after running,
+    // our graph needs to check if these were called
+    const shouldReturnDirect = new Set(toolClasses
+        .filter((tool) => "returnDirect" in tool && tool.returnDirect)
+        .map((tool) => tool.name));
     const shouldContinue = (state) => {
         const { messages } = state;
         const lastMessage = messages[messages.length - 1];
         if (isAIMessage(lastMessage) &&
             (!lastMessage.tool_calls || lastMessage.tool_calls.length === 0)) {
-            return END;
+            return responseFormat != null ? "generate_structured_response" : END;
         }
         else {
             return "continue";
         }
     };
+    const generateStructuredResponse = async (state, config) => {
+        if (responseFormat == null) {
+            throw new Error("Attempted to generate structured output with no passed response schema. Please contact us for help.");
+        }
+        // Exclude the last message as there's enough information
+        // for the LLM to generate the structured response
+        const messages = state.messages.slice(0, -1);
+        let modelWithStructuredOutput;
+        if (typeof responseFormat === "object" &&
+            "prompt" in responseFormat &&
+            "schema" in responseFormat) {
+            const { prompt, schema } = responseFormat;
+            modelWithStructuredOutput = llm.withStructuredOutput(schema);
+            messages.unshift(new SystemMessage({ content: prompt }));
+        }
+        else {
+            modelWithStructuredOutput = llm.withStructuredOutput(responseFormat);
+        }
+        const response = await modelWithStructuredOutput.invoke(messages, config);
+        return { structuredResponse: response };
+    };
     const callModel = async (state, config) => {
         // TODO: Auto-promote streaming.
         return { messages: [await modelRunnable.invoke(state, config)] };
     };
-    const workflow = new StateGraph(stateSchema ?? MessagesAnnotation)
+    const workflow = new StateGraph(stateSchema ?? createReactAgentAnnotation())
         .addNode("agent", callModel)
         .addNode("tools", new ToolNode(toolClasses))
-        .addEdge(START, "agent")
-        .addConditionalEdges("agent", shouldContinue, {
-        continue: "tools",
-        [END]: END,
-    })
-        .addEdge("tools", "agent");
+        .addEdge(START, "agent");
+    if (responseFormat !== undefined) {
+        workflow
+            .addNode("generate_structured_response", generateStructuredResponse)
+            .addEdge("generate_structured_response", END)
+            .addConditionalEdges("agent", shouldContinue, {
+            continue: "tools",
+            [END]: END,
+            generate_structured_response: "generate_structured_response",
+        });
+    }
+    else {
+        workflow.addConditionalEdges("agent", shouldContinue, {
+            continue: "tools",
+            [END]: END,
+        });
+    }
+    const routeToolResponses = (state) => {
+        // Check the last consecutive tool calls
+        for (let i = state.messages.length - 1; i >= 0; i -= 1) {
+            const message = state.messages[i];
+            if (!isToolMessage(message)) {
+                break;
+            }
+            // Check if this tool is configured to return directly
+            if (message.name !== undefined && shouldReturnDirect.has(message.name)) {
+                return END;
+            }
+        }
+        return "agent";
+    };
+    if (shouldReturnDirect.size > 0) {
+        workflow.addConditionalEdges("tools", routeToolResponses, ["agent", END]);
+    }
+    else {
+        workflow.addEdge("tools", "agent");
+    }
     return workflow.compile({
-        checkpointer: checkpointSaver,
+        checkpointer: checkpointer ?? checkpointSaver,
         interruptBefore,
         interruptAfter,
         store,

package/dist/prebuilt/tool_node.cjs

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.toolsCondition = exports.ToolNode = void 0;
 const messages_1 = require("@langchain/core/messages");
 const utils_js_1 = require("../utils.cjs");
-const graph_js_1 = require("../graph/graph.cjs");
 const errors_js_1 = require("../errors.cjs");
 const constants_js_1 = require("../constants.cjs");
 /**
@@ -218,7 +217,7 @@ function toolsCondition(state) {
         return "tools";
     }
     else {
-        return graph_js_1.END;
+        return constants_js_1.END;
     }
 }
 exports.toolsCondition = toolsCondition;

package/dist/prebuilt/tool_node.d.ts

@@ -2,8 +2,8 @@ import { BaseMessage } from "@langchain/core/messages";
 import { RunnableConfig, RunnableToolLike } from "@langchain/core/runnables";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { RunnableCallable } from "../utils.js";
-import { END } from "../graph/graph.js";
 import { MessagesAnnotation } from "../graph/messages_annotation.js";
+import { END } from "../constants.js";
 export type ToolNodeOptions = {
     name?: string;
     tags?: string[];

package/dist/prebuilt/tool_node.js

@@ -1,8 +1,7 @@
 import { ToolMessage, isBaseMessage, } from "@langchain/core/messages";
 import { RunnableCallable } from "../utils.js";
-import { END } from "../graph/graph.js";
 import { isGraphInterrupt } from "../errors.js";
-import { isCommand } from "../constants.js";
+import { END, isCommand } from "../constants.js";
 /**
  * A node that runs the tools requested in the last AIMessage. It can be used
  * either in StateGraph with a "messages" key or in MessageGraph. If multiple