@langchain/langgraph 0.0.12 → 0.0.13

package/dist/prebuilt/chat_agent_executor.d.ts

@@ -1,10 +1,12 @@
 import { StructuredTool } from "@langchain/core/tools";
 import { BaseMessage } from "@langchain/core/messages";
 import { ToolExecutor } from "./tool_executor.js";
+import { CompiledStateGraph } from "../graph/state.js";
+import { START } from "../index.js";
 export type FunctionCallingExecutorState = {
     messages: Array<BaseMessage>;
 };
 export declare function createFunctionCallingExecutor<Model extends object>({ model, tools, }: {
     model: Model;
     tools: Array<StructuredTool> | ToolExecutor;
-}): import("../pregel/index.js").Pregel;
+}): CompiledStateGraph<FunctionCallingExecutorState, Partial<FunctionCallingExecutorState>, typeof START | "agent" | "action">;

package/dist/prebuilt/chat_agent_executor.js

@@ -2,8 +2,8 @@ import { convertToOpenAIFunction } from "@langchain/core/utils/function_calling"
 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 } from "../index.js";
+import { StateGraph, } from "../graph/state.js";
+import { END, START } from "../index.js";
 export function createFunctionCallingExecutor({ model, tools, }) {
     let toolExecutor;
     let toolClasses;
@@ -90,15 +90,15 @@ export function createFunctionCallingExecutor({ model, tools, }) {
     // Define a new graph
     const workflow = new StateGraph({
         channels: schema,
-    });
-    // Define the two nodes we will cycle between
-    workflow.addNode("agent", new RunnableLambda({ func: callModel }));
-    workflow.addNode("action", new RunnableLambda({ func: callTool }));
-    // Set the entrypoint as `agent`
-    // This means that this node is the first one called
-    workflow.setEntryPoint("agent");
-    // We now add a conditional edge
-    workflow.addConditionalEdges(
+    })
+        // Define the two nodes we will cycle between
+        .addNode("agent", new RunnableLambda({ func: callModel }))
+        .addNode("action", new RunnableLambda({ func: callTool }))
+        // Set the entrypoint as `agent`
+        // This means that this node is the first one called
+        .addEdge(START, "agent")
+        // We now add a conditional edge
+        .addConditionalEdges(
     // First, we define the start node. We use `agent`.
     // This means these are the edges taken after the `agent` node is called.
     "agent", 
@@ -115,10 +115,10 @@ export function createFunctionCallingExecutor({ model, tools, }) {
         continue: "action",
         // Otherwise we finish.
         end: END,
-    });
-    // We now add a normal edge from `tools` to `agent`.
-    // This means that after `tools` is called, `agent` node is called next.
-    workflow.addEdge("action", "agent");
+    })
+        // We now add a normal edge from `tools` to `agent`.
+        // This means that after `tools` is called, `agent` node is called next.
+        .addEdge("action", "agent");
     // Finally, we compile it!
     // This compiles it into a LangChain Runnable,
     // meaning you can use it as you would any other runnable

package/dist/prebuilt/index.cjs

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolExecutor = exports.createFunctionCallingExecutor = exports.createAgentExecutor = void 0;
+exports.toolsCondition = exports.ToolNode = exports.ToolExecutor = exports.createFunctionCallingExecutor = exports.createAgentExecutor = void 0;
 var agent_executor_js_1 = require("./agent_executor.cjs");
 Object.defineProperty(exports, "createAgentExecutor", { enumerable: true, get: function () { return agent_executor_js_1.createAgentExecutor; } });
 var chat_agent_executor_js_1 = require("./chat_agent_executor.cjs");
 Object.defineProperty(exports, "createFunctionCallingExecutor", { enumerable: true, get: function () { return chat_agent_executor_js_1.createFunctionCallingExecutor; } });
 var tool_executor_js_1 = require("./tool_executor.cjs");
 Object.defineProperty(exports, "ToolExecutor", { enumerable: true, get: function () { return tool_executor_js_1.ToolExecutor; } });
+var tool_node_js_1 = require("./tool_node.cjs");
+Object.defineProperty(exports, "ToolNode", { enumerable: true, get: function () { return tool_node_js_1.ToolNode; } });
+Object.defineProperty(exports, "toolsCondition", { enumerable: true, get: function () { return tool_node_js_1.toolsCondition; } });

package/dist/prebuilt/index.d.ts

@@ -1,3 +1,4 @@
 export { type AgentExecutorState, createAgentExecutor, } from "./agent_executor.js";
 export { type FunctionCallingExecutorState, createFunctionCallingExecutor, } from "./chat_agent_executor.js";
 export { type ToolExecutorArgs, type ToolInvocationInterface, ToolExecutor, } from "./tool_executor.js";
+export { ToolNode, toolsCondition } from "./tool_node.js";

package/dist/prebuilt/index.js

@@ -1,3 +1,4 @@
 export { createAgentExecutor, } from "./agent_executor.js";
 export { createFunctionCallingExecutor, } from "./chat_agent_executor.js";
 export { ToolExecutor, } from "./tool_executor.js";
+export { ToolNode, toolsCondition } from "./tool_node.js";

package/dist/prebuilt/tool_node.cjs

@@ -0,0 +1,59 @@
+"use strict";
+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");
+class ToolNode extends utils_js_1.RunnableCallable {
+    constructor(tools, name = "tools", tags = []) {
+        super({ name, tags, func: (input, config) => this.run(input, config) });
+        /**
+        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
+        tool calls are requested, they will be run in parallel. The output will be
+        a list of ToolMessages, one for each tool call.
+        */
+        Object.defineProperty(this, "tools", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tools = tools;
+    }
+    async run(input, config) {
+        const message = Array.isArray(input)
+            ? input[input.length - 1]
+            : input.messages[input.messages.length - 1];
+        if (message._getType() !== "ai") {
+            throw new Error("ToolNode only accepts AIMessages as input.");
+        }
+        const outputs = await Promise.all(message.tool_calls?.map(async (call) => {
+            const tool = this.tools.find((tool) => tool.name === call.name);
+            if (tool === undefined) {
+                throw new Error(`Tool ${call.name} not found.`);
+            }
+            const output = await tool.invoke(call.args, config);
+            return new messages_1.ToolMessage({
+                name: tool.name,
+                content: typeof output === "string" ? output : JSON.stringify(output),
+                tool_call_id: call.id,
+            });
+        }) ?? []);
+        return Array.isArray(input) ? outputs : { messages: outputs };
+    }
+}
+exports.ToolNode = ToolNode;
+function toolsCondition(state) {
+    const message = Array.isArray(state)
+        ? state[state.length - 1]
+        : state.messages[state.messages.length - 1];
+    if ("tool_calls" in message &&
+        (message.tool_calls?.length ?? 0) > 0) {
+        return "tools";
+    }
+    else {
+        return graph_js_1.END;
+    }
+}
+exports.toolsCondition = toolsCondition;

package/dist/prebuilt/tool_node.d.ts

@@ -0,0 +1,17 @@
+import { BaseMessage } from "@langchain/core/messages";
+import { Tool } from "@langchain/core/tools";
+import { RunnableCallable } from "../utils.js";
+import { END } from "../graph/graph.js";
+import { MessagesState } from "../graph/message.js";
+export declare class ToolNode extends RunnableCallable<BaseMessage[] | MessagesState, BaseMessage[] | MessagesState> {
+    /**
+    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
+    tool calls are requested, they will be run in parallel. The output will be
+    a list of ToolMessages, one for each tool call.
+    */
+    tools: Tool[];
+    constructor(tools: Tool[], name?: string, tags?: string[]);
+    private run;
+}
+export declare function toolsCondition(state: BaseMessage[] | MessagesState): "tools" | typeof END;

package/dist/prebuilt/tool_node.js

@@ -0,0 +1,54 @@
+import { ToolMessage } from "@langchain/core/messages";
+import { RunnableCallable } from "../utils.js";
+import { END } from "../graph/graph.js";
+export class ToolNode extends RunnableCallable {
+    constructor(tools, name = "tools", tags = []) {
+        super({ name, tags, func: (input, config) => this.run(input, config) });
+        /**
+        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
+        tool calls are requested, they will be run in parallel. The output will be
+        a list of ToolMessages, one for each tool call.
+        */
+        Object.defineProperty(this, "tools", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tools = tools;
+    }
+    async run(input, config) {
+        const message = Array.isArray(input)
+            ? input[input.length - 1]
+            : input.messages[input.messages.length - 1];
+        if (message._getType() !== "ai") {
+            throw new Error("ToolNode only accepts AIMessages as input.");
+        }
+        const outputs = await Promise.all(message.tool_calls?.map(async (call) => {
+            const tool = this.tools.find((tool) => tool.name === call.name);
+            if (tool === undefined) {
+                throw new Error(`Tool ${call.name} not found.`);
+            }
+            const output = await tool.invoke(call.args, config);
+            return new ToolMessage({
+                name: tool.name,
+                content: typeof output === "string" ? output : JSON.stringify(output),
+                tool_call_id: call.id,
+            });
+        }) ?? []);
+        return Array.isArray(input) ? outputs : { messages: outputs };
+    }
+}
+export function toolsCondition(state) {
+    const message = Array.isArray(state)
+        ? state[state.length - 1]
+        : state.messages[state.messages.length - 1];
+    if ("tool_calls" in message &&
+        (message.tool_calls?.length ?? 0) > 0) {
+        return "tools";
+    }
+    else {
+        return END;
+    }
+}

package/dist/pregel/debug.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printCheckpoint = exports.printStepStart = void 0;
-const base_js_1 = require("../channels/base.cjs");
+const errors_js_1 = require("../errors.cjs");
 const COLORS_MAP = {
     blue: {
         start: "\x1b[34m",
@@ -12,17 +12,15 @@ const COLORS_MAP = {
  * Wrap some text in a color for printing to the console.
  */
 const wrap = (color, text) => `${color.start}${text}${color.end}`;
-function printStepStart(step, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-nextTasks) {
+function printStepStart(step, nextTasks) {
     const nTasks = nextTasks.length;
-    console.log(`${wrap(COLORS_MAP.blue, "[pregel/step]")}`, `Starting step ${step} with ${nTasks} task${nTasks === 1 ? "" : "s"}. Next tasks:\n`, `\n${nextTasks
-        .map(([_, val, name]) => `- ${name}(${JSON.stringify(val, null, 2)})`)
+    console.log(`${wrap(COLORS_MAP.blue, "[langgraph/step]")}`, `Starting step ${step} with ${nTasks} task${nTasks === 1 ? "" : "s"}. Next tasks:\n`, `\n${nextTasks
+        .map((task) => `${String(task.name)}(${JSON.stringify(task.input, null, 2)})`)
         .join("\n")}`);
 }
 exports.printStepStart = printStepStart;
 function printCheckpoint(step, channels) {
-    console.log(`${wrap(COLORS_MAP.blue, "[pregel/checkpoint]")}`, `Finishing step ${step}. Channel values:\n`, `\n${JSON.stringify(Object.fromEntries(_readChannels(channels)), null, 2)}`);
+    console.log(`${wrap(COLORS_MAP.blue, "[langgraph/checkpoint]")}`, `Finishing step ${step}. Channel values:\n`, `\n${JSON.stringify(Object.fromEntries(_readChannels(channels)), null, 2)}`);
 }
 exports.printCheckpoint = printCheckpoint;
 function* _readChannels(channels
@@ -34,7 +32,7 @@ function* _readChannels(channels
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (error) {
-            if (error.name === base_js_1.EmptyChannelError.name) {
+            if (error.name === errors_js_1.EmptyChannelError.name) {
                 // Skip the channel if it's empty
                 continue;
             }

package/dist/pregel/debug.d.ts

@@ -1,4 +1,4 @@
-import { Runnable } from "@langchain/core/runnables";
 import { BaseChannel } from "../channels/base.js";
-export declare function printStepStart(step: number, nextTasks: Array<[Runnable, any, string]>): void;
+import { PregelExecutableTask } from "./types.js";
+export declare function printStepStart<N extends PropertyKey, C extends PropertyKey>(step: number, nextTasks: readonly PregelExecutableTask<N, C>[]): void;
 export declare function printCheckpoint<Value>(step: number, channels: Record<string, BaseChannel<Value>>): void;

package/dist/pregel/debug.js

@@ -1,4 +1,4 @@
-import { EmptyChannelError } from "../channels/base.js";
+import { EmptyChannelError } from "../errors.js";
 const COLORS_MAP = {
     blue: {
         start: "\x1b[34m",
@@ -9,16 +9,14 @@ const COLORS_MAP = {
  * Wrap some text in a color for printing to the console.
  */
 const wrap = (color, text) => `${color.start}${text}${color.end}`;
-export function printStepStart(step, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-nextTasks) {
+export function printStepStart(step, nextTasks) {
     const nTasks = nextTasks.length;
-    console.log(`${wrap(COLORS_MAP.blue, "[pregel/step]")}`, `Starting step ${step} with ${nTasks} task${nTasks === 1 ? "" : "s"}. Next tasks:\n`, `\n${nextTasks
-        .map(([_, val, name]) => `- ${name}(${JSON.stringify(val, null, 2)})`)
+    console.log(`${wrap(COLORS_MAP.blue, "[langgraph/step]")}`, `Starting step ${step} with ${nTasks} task${nTasks === 1 ? "" : "s"}. Next tasks:\n`, `\n${nextTasks
+        .map((task) => `${String(task.name)}(${JSON.stringify(task.input, null, 2)})`)
         .join("\n")}`);
 }
 export function printCheckpoint(step, channels) {
-    console.log(`${wrap(COLORS_MAP.blue, "[pregel/checkpoint]")}`, `Finishing step ${step}. Channel values:\n`, `\n${JSON.stringify(Object.fromEntries(_readChannels(channels)), null, 2)}`);
+    console.log(`${wrap(COLORS_MAP.blue, "[langgraph/checkpoint]")}`, `Finishing step ${step}. Channel values:\n`, `\n${JSON.stringify(Object.fromEntries(_readChannels(channels)), null, 2)}`);
 }
 function* _readChannels(channels
 // eslint-disable-next-line @typescript-eslint/no-explicit-any