@langchain/langgraph 0.0.27-rc.0 → 0.0.28

package/dist/constants.cjs

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TAG_HIDDEN = exports.INTERRUPT = exports.CONFIG_KEY_READ = exports.CONFIG_KEY_SEND = void 0;
+exports.TASKS = exports.TAG_HIDDEN = exports.INTERRUPT = exports.CONFIG_KEY_READ = exports.CONFIG_KEY_SEND = void 0;
 exports.CONFIG_KEY_SEND = "__pregel_send";
 exports.CONFIG_KEY_READ = "__pregel_read";
 exports.INTERRUPT = "__interrupt__";
 exports.TAG_HIDDEN = "langsmith:hidden";
+exports.TASKS = "__pregel_tasks";

package/dist/constants.d.ts

@@ -2,3 +2,4 @@ export declare const CONFIG_KEY_SEND = "__pregel_send";
 export declare const CONFIG_KEY_READ = "__pregel_read";
 export declare const INTERRUPT = "__interrupt__";
 export declare const TAG_HIDDEN = "langsmith:hidden";
+export declare const TASKS = "__pregel_tasks";

package/dist/constants.js

@@ -2,3 +2,4 @@ export const CONFIG_KEY_SEND = "__pregel_send";
 export const CONFIG_KEY_READ = "__pregel_read";
 export const INTERRUPT = "__interrupt__";
 export const TAG_HIDDEN = "langsmith:hidden";
+export const TASKS = "__pregel_tasks";

package/dist/graph/graph.cjs

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CompiledGraph = exports.Graph = exports.Branch = exports.END = exports.START = void 0;
 /* eslint-disable @typescript-eslint/no-use-before-define */
 const runnables_1 = require("@langchain/core/runnables");
+const graph_1 = require("@langchain/core/runnables/graph");
 const zod_1 = require("zod");
 const read_js_1 = require("../pregel/read.cjs");
 const index_js_1 = require("../pregel/index.cjs");
@@ -317,10 +318,12 @@ class CompiledGraph extends index_js_1.Pregel {
             }
         }
     }
-    // Returns a drawable representation of the computation graph.
+    /**
+     * Returns a drawable representation of the computation graph.
+     */
     getGraph(config) {
         const xray = config?.xray;
-        const graph = new utils_js_1.DrawableGraph();
+        const graph = new graph_1.Graph();
         const startNodes = {
             [exports.START]: graph.addNode({
                 schema: zod_1.z.any(),
@@ -332,7 +335,7 @@ class CompiledGraph extends index_js_1.Pregel {
             }, exports.END),
         };
         for (const [key, node] of Object.entries(this.builder.nodes)) {
-            if (!!config?.xray) {
+            if (config?.xray) {
                 const subgraph = isCompiledGraph(node)
                     ? node.getGraph({
                         ...config,
@@ -370,7 +373,7 @@ class CompiledGraph extends index_js_1.Pregel {
                 ...Object.fromEntries(Object.keys(this.builder.nodes)
                     .filter((k) => k !== start)
                     .map((k) => [k, k])),
-                END: exports.END,
+                [exports.END]: exports.END,
             };
             for (const branch of Object.values(branches)) {
                 let ends;
@@ -389,7 +392,11 @@ class CompiledGraph extends index_js_1.Pregel {
     }
 }
 exports.CompiledGraph = CompiledGraph;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function isCompiledGraph(x) {
-    return (typeof x.attachNode === "function" &&
+    return (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    typeof x.attachNode === "function" &&
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         typeof x.attachEdge === "function");
 }

package/dist/graph/graph.d.ts

@@ -1,10 +1,11 @@
 import { Runnable, RunnableConfig, RunnableLike } from "@langchain/core/runnables";
+import { Graph as RunnableGraph } from "@langchain/core/runnables/graph";
 import { PregelNode } from "../pregel/read.js";
 import { Pregel, PregelInterface } from "../pregel/index.js";
 import { BaseCheckpointSaver } from "../checkpoint/base.js";
 import { BaseChannel } from "../channels/base.js";
 import { All } from "../pregel/types.js";
-import { DrawableGraph, RunnableCallable } from "../utils.js";
+import { RunnableCallable } from "../utils.js";
 export declare const START = "__start__";
 export declare const END = "__end__";
 export interface BranchOptions<IO, N extends string> {
@@ -56,7 +57,10 @@ export declare class CompiledGraph<N extends string, RunInput = any, RunOutput =
     attachNode(key: N, node: Runnable<RunInput, RunOutput>): void;
     attachEdge(start: N | typeof START, end: N | typeof END): void;
     attachBranch(start: N | typeof START, name: string, branch: Branch<RunInput, N>): void;
+    /**
+     * Returns a drawable representation of the computation graph.
+     */
     getGraph(config?: RunnableConfig & {
         xray?: boolean | number;
-    }): DrawableGraph;
+    }): RunnableGraph;
 }

package/dist/graph/graph.js

@@ -1,12 +1,13 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import { _coerceToRunnable, } from "@langchain/core/runnables";
+import { Graph as RunnableGraph, } from "@langchain/core/runnables/graph";
 import { z } from "zod";
 import { PregelNode } from "../pregel/read.js";
 import { Channel, Pregel } from "../pregel/index.js";
 import { EphemeralValue } from "../channels/ephemeral_value.js";
 import { ChannelWrite, PASSTHROUGH } from "../pregel/write.js";
 import { TAG_HIDDEN } from "../constants.js";
-import { DrawableGraph, RunnableCallable } from "../utils.js";
+import { RunnableCallable } from "../utils.js";
 export const START = "__start__";
 export const END = "__end__";
 export class Branch {
@@ -312,10 +313,12 @@ export class CompiledGraph extends Pregel {
             }
         }
     }
-    // Returns a drawable representation of the computation graph.
+    /**
+     * Returns a drawable representation of the computation graph.
+     */
     getGraph(config) {
         const xray = config?.xray;
-        const graph = new DrawableGraph();
+        const graph = new RunnableGraph();
         const startNodes = {
             [START]: graph.addNode({
                 schema: z.any(),
@@ -327,7 +330,7 @@ export class CompiledGraph extends Pregel {
             }, END),
         };
         for (const [key, node] of Object.entries(this.builder.nodes)) {
-            if (!!config?.xray) {
+            if (config?.xray) {
                 const subgraph = isCompiledGraph(node)
                     ? node.getGraph({
                         ...config,
@@ -365,7 +368,7 @@ export class CompiledGraph extends Pregel {
                 ...Object.fromEntries(Object.keys(this.builder.nodes)
                     .filter((k) => k !== start)
                     .map((k) => [k, k])),
-                END: END,
+                [END]: END,
             };
             for (const branch of Object.values(branches)) {
                 let ends;
@@ -383,7 +386,11 @@ export class CompiledGraph extends Pregel {
         return graph;
     }
 }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function isCompiledGraph(x) {
-    return (typeof x.attachNode === "function" &&
+    return (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    typeof x.attachNode === "function" &&
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         typeof x.attachEdge === "function");
 }

package/dist/prebuilt/chat_agent_executor.d.ts

@@ -1,5 +1,6 @@
-import { StructuredTool } from "@langchain/core/tools";
+import { StructuredToolInterface } from "@langchain/core/tools";
 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";
@@ -8,5 +9,5 @@ export type FunctionCallingExecutorState = {
 };
 export declare function createFunctionCallingExecutor<Model extends object>({ model, tools, }: {
     model: Model;
-    tools: Array<StructuredTool> | ToolExecutor;
+    tools: Array<StructuredToolInterface | RunnableToolLike> | ToolExecutor;
 }): CompiledStateGraph<FunctionCallingExecutorState, Partial<FunctionCallingExecutorState>, typeof START | "agent" | "action">;

package/dist/prebuilt/chat_agent_executor.js

@@ -1,6 +1,6 @@
 import { convertToOpenAIFunction } from "@langchain/core/utils/function_calling";
 import { FunctionMessage } from "@langchain/core/messages";
-import { RunnableLambda } from "@langchain/core/runnables";
+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";

package/dist/prebuilt/react_agent_executor.d.ts

@@ -1,7 +1,7 @@
 import { BaseChatModel } from "@langchain/core/language_models/chat_models";
 import { BaseMessage, SystemMessage } from "@langchain/core/messages";
-import { Runnable } from "@langchain/core/runnables";
-import { StructuredTool } from "@langchain/core/tools";
+import { Runnable, RunnableToolLike } from "@langchain/core/runnables";
+import { StructuredToolInterface } from "@langchain/core/tools";
 import { BaseCheckpointSaver } from "../checkpoint/base.js";
 import { START } from "../graph/index.js";
 import { MessagesState } from "../graph/message.js";
@@ -14,7 +14,7 @@ export interface AgentState {
 export type N = typeof START | "agent" | "tools";
 export type CreateReactAgentParams = {
     llm: BaseChatModel;
-    tools: ToolNode<MessagesState> | StructuredTool[];
+    tools: ToolNode<MessagesState> | (StructuredToolInterface | RunnableToolLike)[];
     messageModifier?: SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | ((messages: BaseMessage[]) => Promise<BaseMessage[]>) | Runnable;
     checkpointSaver?: BaseCheckpointSaver;
     interruptBefore?: N[] | All;

package/dist/prebuilt/tool_executor.cjs

@@ -45,6 +45,13 @@ class ToolExecutor extends runnables_1.RunnableBinding {
             return acc;
         }, {});
     }
+    /**
+     * Execute a tool invocation
+     *
+     * @param {ToolInvocationInterface} toolInvocation The tool to invoke and the input to pass to it.
+     * @param {RunnableConfig | undefined} config Optional configuration to pass to the tool when invoked.
+     * @returns Either the result of the tool invocation (`string` or `ToolMessage`, set by the `ToolOutput` generic) or a string error message.
+     */
     async _execute(toolInvocation, config) {
         if (!(toolInvocation.tool in this.toolMap)) {
             return this.invalidToolMsgTemplate

package/dist/prebuilt/tool_executor.d.ts

@@ -1,7 +1,7 @@
-import { RunnableBinding, RunnableConfig } from "@langchain/core/runnables";
-import { StructuredTool } from "@langchain/core/tools";
+import { RunnableBinding, RunnableConfig, RunnableToolLike } from "@langchain/core/runnables";
+import { StructuredToolInterface } from "@langchain/core/tools";
 export interface ToolExecutorArgs {
-    tools: Array<StructuredTool>;
+    tools: Array<StructuredToolInterface | RunnableToolLike>;
     /**
      * @default {INVALID_TOOL_MSG_TEMPLATE}
      */
@@ -18,10 +18,17 @@ type ToolExecutorInputType = any;
 type ToolExecutorOutputType = any;
 export declare class ToolExecutor extends RunnableBinding<ToolExecutorInputType, ToolExecutorOutputType> {
     lc_graph_name: string;
-    tools: Array<StructuredTool>;
-    toolMap: Record<string, StructuredTool>;
+    tools: Array<StructuredToolInterface | RunnableToolLike>;
+    toolMap: Record<string, StructuredToolInterface | RunnableToolLike>;
     invalidToolMsgTemplate: string;
     constructor(fields: ToolExecutorArgs);
-    _execute(toolInvocation: ToolInvocationInterface, config?: RunnableConfig): Promise<string>;
+    /**
+     * Execute a tool invocation
+     *
+     * @param {ToolInvocationInterface} toolInvocation The tool to invoke and the input to pass to it.
+     * @param {RunnableConfig | undefined} config Optional configuration to pass to the tool when invoked.
+     * @returns Either the result of the tool invocation (`string` or `ToolMessage`, set by the `ToolOutput` generic) or a string error message.
+     */
+    _execute(toolInvocation: ToolInvocationInterface, config?: RunnableConfig): Promise<ToolExecutorOutputType>;
 }
 export {};

package/dist/prebuilt/tool_executor.js

@@ -42,6 +42,13 @@ export class ToolExecutor extends RunnableBinding {
             return acc;
         }, {});
     }
+    /**
+     * Execute a tool invocation
+     *
+     * @param {ToolInvocationInterface} toolInvocation The tool to invoke and the input to pass to it.
+     * @param {RunnableConfig | undefined} config Optional configuration to pass to the tool when invoked.
+     * @returns Either the result of the tool invocation (`string` or `ToolMessage`, set by the `ToolOutput` generic) or a string error message.
+     */
     async _execute(toolInvocation, config) {
         if (!(toolInvocation.tool in this.toolMap)) {
             return this.invalidToolMsgTemplate

package/dist/prebuilt/tool_node.cjs

@@ -33,12 +33,17 @@ class ToolNode extends utils_js_1.RunnableCallable {
             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,
-            });
+            const output = await tool.invoke({ ...call, type: "tool_call" }, config);
+            if ((0, messages_1.isBaseMessage)(output) && output._getType() === "tool") {
+                return output;
+            }
+            else {
+                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 };
     }

package/dist/prebuilt/tool_node.d.ts

@@ -1,5 +1,6 @@
 import { BaseMessage } from "@langchain/core/messages";
-import { StructuredTool } from "@langchain/core/tools";
+import { RunnableToolLike } from "@langchain/core/runnables";
+import { StructuredToolInterface } from "@langchain/core/tools";
 import { RunnableCallable } from "../utils.js";
 import { END } from "../graph/graph.js";
 import { MessagesState } from "../graph/message.js";
@@ -10,8 +11,8 @@ export declare class ToolNode<T extends BaseMessage[] | MessagesState> extends R
     tool calls are requested, they will be run in parallel. The output will be
     a list of ToolMessages, one for each tool call.
     */
-    tools: StructuredTool[];
-    constructor(tools: StructuredTool[], name?: string, tags?: string[]);
+    tools: (StructuredToolInterface | RunnableToolLike)[];
+    constructor(tools: (StructuredToolInterface | RunnableToolLike)[], name?: string, tags?: string[]);
     private run;
 }
 export declare function toolsCondition(state: BaseMessage[] | MessagesState): "tools" | typeof END;

package/dist/prebuilt/tool_node.js

@@ -1,4 +1,4 @@
-import { ToolMessage } from "@langchain/core/messages";
+import { ToolMessage, isBaseMessage, } from "@langchain/core/messages";
 import { RunnableCallable } from "../utils.js";
 import { END } from "../graph/graph.js";
 export class ToolNode extends RunnableCallable {
@@ -30,12 +30,17 @@ export class ToolNode extends RunnableCallable {
             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,
-            });
+            const output = await tool.invoke({ ...call, type: "tool_call" }, config);
+            if (isBaseMessage(output) && output._getType() === "tool") {
+                return output;
+            }
+            else {
+                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 };
     }

package/dist/pregel/index.cjs

@@ -442,10 +442,17 @@ class Pregel extends runnables_1.Runnable {
                 }
                 const tasksWithConfig = nextTasks.map(
                 // eslint-disable-next-line no-loop-func
-                (task) => [
+                (task, i) => [
                     task.proc,
                     task.input,
-                    (0, runnables_1.patchConfig)(restConfig, {
+                    (0, runnables_1.patchConfig)((0, runnables_1.mergeConfigs)(restConfig, processes[task.name].config, {
+                        metadata: {
+                            langgraph_step: step,
+                            langgraph_node: task.name,
+                            langgraph_triggers: [constants_js_1.TASKS],
+                            langgraph_task_idx: i,
+                        },
+                    }), {
                         callbacks: runManager?.getChild(`graph:step:${step}`),
                         runName: task.name,
                         configurable: {

package/dist/pregel/index.js

@@ -1,5 +1,5 @@
 /* eslint-disable no-param-reassign */
-import { Runnable, RunnableSequence, _coerceToRunnable, ensureConfig, patchConfig, } from "@langchain/core/runnables";
+import { Runnable, RunnableSequence, _coerceToRunnable, ensureConfig, mergeConfigs, patchConfig, } from "@langchain/core/runnables";
 import { IterableReadableStream } from "@langchain/core/utils/stream";
 import { createCheckpoint, emptyChannels, } from "../channels/base.js";
 import { copyCheckpoint, emptyCheckpoint, getChannelVersion, getVersionSeen, } from "../checkpoint/base.js";
@@ -7,7 +7,7 @@ import { PregelNode } from "./read.js";
 import { validateGraph, validateKeys } from "./validate.js";
 import { mapInput, mapOutputUpdates, mapOutputValues, readChannel, readChannels, single, } from "./io.js";
 import { ChannelWrite, PASSTHROUGH } from "./write.js";
-import { CONFIG_KEY_READ, CONFIG_KEY_SEND, INTERRUPT, TAG_HIDDEN, } from "../constants.js";
+import { CONFIG_KEY_READ, CONFIG_KEY_SEND, INTERRUPT, TAG_HIDDEN, TASKS, } from "../constants.js";
 import { EmptyChannelError, GraphRecursionError, GraphValueError, InvalidUpdateError, } from "../errors.js";
 const DEFAULT_LOOP_LIMIT = 25;
 function isString(value) {
@@ -438,10 +438,17 @@ export class Pregel extends Runnable {
                 }
                 const tasksWithConfig = nextTasks.map(
                 // eslint-disable-next-line no-loop-func
-                (task) => [
+                (task, i) => [
                     task.proc,
                     task.input,
-                    patchConfig(restConfig, {
+                    patchConfig(mergeConfigs(restConfig, processes[task.name].config, {
+                        metadata: {
+                            langgraph_step: step,
+                            langgraph_node: task.name,
+                            langgraph_triggers: [TASKS],
+                            langgraph_task_idx: i,
+                        },
+                    }), {
                         callbacks: runManager?.getChild(`graph:step:${step}`),
                         runName: task.name,
                         configurable: {

package/dist/tests/diagrams.test.js

@@ -1,11 +1,10 @@
 import { test, expect } from "@jest/globals";
-import { TavilySearchResults } from "@langchain/community/tools/tavily_search";
-import { ChatOpenAI } from "@langchain/openai";
 import { createReactAgent } from "../prebuilt/index.js";
-test("langgraph", async () => {
+import { FakeSearchTool, FakeToolCallingChatModel } from "./utils.js";
+test("prebuilt agent", async () => {
     // Define the tools for the agent to use
-    const tools = [new TavilySearchResults({ maxResults: 1 })];
-    const model = new ChatOpenAI({ temperature: 0 });
+    const tools = [new FakeSearchTool()];
+    const model = new FakeToolCallingChatModel({});
     const app = createReactAgent({ llm: model, tools });
     const graph = app.getGraph();
     const mermaid = graph.drawMermaid();

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

@@ -3,6 +3,8 @@ import { it, beforeAll, describe, expect } from "@jest/globals";
 import { Tool } from "@langchain/core/tools";
 import { ChatOpenAI } from "@langchain/openai";
 import { HumanMessage } from "@langchain/core/messages";
+import { RunnableLambda } from "@langchain/core/runnables";
+import { z } from "zod";
 import { createReactAgent, createFunctionCallingExecutor, } from "../prebuilt/index.js";
 import { initializeAsyncLocalStorageSingleton } from "../setup/async_local_storage.js";
 // Tracing slows down the tests
@@ -97,6 +99,32 @@ describe("createFunctionCallingExecutor", () => {
         const functionCall = endState.messages.find((message) => message._getType() === "function");
         expect(functionCall.content).toBe(weatherResponse);
     });
+    it("can accept RunnableToolLike tools", async () => {
+        const weatherResponse = `Not too cold, not too hot 😎`;
+        const model = new ChatOpenAI();
+        const sfWeatherTool = RunnableLambda.from(async (_) => weatherResponse);
+        const tools = [
+            sfWeatherTool.asTool({
+                name: "current_weather",
+                description: "Get the current weather report for San Francisco, CA",
+                schema: z.object({
+                    location: z.string(),
+                }),
+            }),
+        ];
+        const functionsAgentExecutor = createFunctionCallingExecutor({
+            model,
+            tools,
+        });
+        const response = await functionsAgentExecutor.invoke({
+            messages: [new HumanMessage("What's the weather like in SF?")],
+        });
+        // It needs at least one human message, one AI and one function message.
+        expect(response.messages.length > 3).toBe(true);
+        const firstFunctionMessage = response.messages.find((message) => message._getType() === "function");
+        expect(firstFunctionMessage).toBeDefined();
+        expect(firstFunctionMessage?.content).toBe(weatherResponse);
+    });
 });
 describe("createReactAgent", () => {
     it("can call a tool", async () => {