@langchain/langgraph 0.0.26 → 0.0.27

package/dist/channels/binop.d.ts

@@ -1,16 +1,16 @@
 import { BaseChannel } from "./index.js";
-export type BinaryOperator<Value> = (a: Value, b: Value) => Value;
+export type BinaryOperator<ValueType, UpdateType> = (a: ValueType, b: UpdateType) => ValueType;
 /**
  * Stores the result of applying a binary operator to the current value and each new value.
  */
-export declare class BinaryOperatorAggregate<Value> extends BaseChannel<Value, Value, Value> {
+export declare class BinaryOperatorAggregate<ValueType, UpdateType = ValueType> extends BaseChannel<ValueType, UpdateType, ValueType> {
     lc_graph_name: string;
-    value: Value | undefined;
-    operator: BinaryOperator<Value>;
-    initialValueFactory?: () => Value;
-    constructor(operator: BinaryOperator<Value>, initialValueFactory?: () => Value);
-    fromCheckpoint(checkpoint?: Value): this;
-    update(values: Value[]): void;
-    get(): Value;
-    checkpoint(): Value;
+    value: ValueType | undefined;
+    operator: BinaryOperator<ValueType, UpdateType>;
+    initialValueFactory?: () => ValueType;
+    constructor(operator: BinaryOperator<ValueType, UpdateType>, initialValueFactory?: () => ValueType);
+    fromCheckpoint(checkpoint?: ValueType): this;
+    update(values: UpdateType[]): void;
+    get(): ValueType;
+    checkpoint(): ValueType;
 }

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,8 @@ 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");
 const ephemeral_value_js_1 = require("../channels/ephemeral_value.cjs");
@@ -316,5 +318,85 @@ class CompiledGraph extends index_js_1.Pregel {
             }
         }
     }
+    /**
+     * Returns a drawable representation of the computation graph.
+     */
+    getGraph(config) {
+        const xray = config?.xray;
+        const graph = new graph_1.Graph();
+        const startNodes = {
+            [exports.START]: graph.addNode({
+                schema: zod_1.z.any(),
+            }, exports.START),
+        };
+        const endNodes = {
+            [exports.END]: graph.addNode({
+                schema: zod_1.z.any(),
+            }, exports.END),
+        };
+        for (const [key, node] of Object.entries(this.builder.nodes)) {
+            if (config?.xray) {
+                const subgraph = isCompiledGraph(node)
+                    ? node.getGraph({
+                        ...config,
+                        xray: typeof xray === "number" && xray > 0 ? xray - 1 : xray,
+                    })
+                    : node.getGraph(config);
+                subgraph.trimFirstNode();
+                subgraph.trimLastNode();
+                if (Object.keys(subgraph.nodes).length > 1) {
+                    const [newEndNode, newStartNode] = graph.extend(subgraph, key);
+                    if (newEndNode !== undefined) {
+                        endNodes[key] = newEndNode;
+                    }
+                    if (newStartNode !== undefined) {
+                        startNodes[key] = newStartNode;
+                    }
+                }
+                else {
+                    const newNode = graph.addNode(node, key);
+                    startNodes[key] = newNode;
+                    endNodes[key] = newNode;
+                }
+            }
+            else {
+                const newNode = graph.addNode(node, key);
+                startNodes[key] = newNode;
+                endNodes[key] = newNode;
+            }
+        }
+        for (const [start, end] of this.builder.allEdges) {
+            graph.addEdge(startNodes[start], endNodes[end]);
+        }
+        for (const [start, branches] of Object.entries(this.builder.branches)) {
+            const defaultEnds = {
+                ...Object.fromEntries(Object.keys(this.builder.nodes)
+                    .filter((k) => k !== start)
+                    .map((k) => [k, k])),
+                [exports.END]: exports.END,
+            };
+            for (const branch of Object.values(branches)) {
+                let ends;
+                if (branch.ends !== undefined) {
+                    ends = branch.ends;
+                }
+                else {
+                    ends = defaultEnds;
+                }
+                for (const [label, end] of Object.entries(ends)) {
+                    graph.addEdge(startNodes[start], endNodes[end], label !== end ? label : undefined, true);
+                }
+            }
+        }
+        return graph;
+    }
 }
 exports.CompiledGraph = CompiledGraph;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isCompiledGraph(x) {
+    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,4 +1,5 @@
 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";
@@ -56,4 +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;
+    }): RunnableGraph;
 }

package/dist/graph/graph.js

@@ -1,5 +1,7 @@
 /* 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";
@@ -311,4 +313,84 @@ export class CompiledGraph extends Pregel {
             }
         }
     }
+    /**
+     * Returns a drawable representation of the computation graph.
+     */
+    getGraph(config) {
+        const xray = config?.xray;
+        const graph = new RunnableGraph();
+        const startNodes = {
+            [START]: graph.addNode({
+                schema: z.any(),
+            }, START),
+        };
+        const endNodes = {
+            [END]: graph.addNode({
+                schema: z.any(),
+            }, END),
+        };
+        for (const [key, node] of Object.entries(this.builder.nodes)) {
+            if (config?.xray) {
+                const subgraph = isCompiledGraph(node)
+                    ? node.getGraph({
+                        ...config,
+                        xray: typeof xray === "number" && xray > 0 ? xray - 1 : xray,
+                    })
+                    : node.getGraph(config);
+                subgraph.trimFirstNode();
+                subgraph.trimLastNode();
+                if (Object.keys(subgraph.nodes).length > 1) {
+                    const [newEndNode, newStartNode] = graph.extend(subgraph, key);
+                    if (newEndNode !== undefined) {
+                        endNodes[key] = newEndNode;
+                    }
+                    if (newStartNode !== undefined) {
+                        startNodes[key] = newStartNode;
+                    }
+                }
+                else {
+                    const newNode = graph.addNode(node, key);
+                    startNodes[key] = newNode;
+                    endNodes[key] = newNode;
+                }
+            }
+            else {
+                const newNode = graph.addNode(node, key);
+                startNodes[key] = newNode;
+                endNodes[key] = newNode;
+            }
+        }
+        for (const [start, end] of this.builder.allEdges) {
+            graph.addEdge(startNodes[start], endNodes[end]);
+        }
+        for (const [start, branches] of Object.entries(this.builder.branches)) {
+            const defaultEnds = {
+                ...Object.fromEntries(Object.keys(this.builder.nodes)
+                    .filter((k) => k !== start)
+                    .map((k) => [k, k])),
+                [END]: END,
+            };
+            for (const branch of Object.values(branches)) {
+                let ends;
+                if (branch.ends !== undefined) {
+                    ends = branch.ends;
+                }
+                else {
+                    ends = defaultEnds;
+                }
+                for (const [label, end] of Object.entries(ends)) {
+                    graph.addEdge(startNodes[start], endNodes[end], label !== end ? label : undefined, true);
+                }
+            }
+        }
+        return graph;
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isCompiledGraph(x) {
+    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/state.d.ts

@@ -4,18 +4,18 @@ import { BinaryOperator } from "../channels/binop.js";
 import { END, CompiledGraph, Graph, START, Branch } from "./graph.js";
 import { BaseCheckpointSaver } from "../checkpoint/base.js";
 import { All } from "../pregel/types.js";
-type SingleReducer<T> = {
-    reducer: BinaryOperator<T>;
-    default?: () => T;
+type SingleReducer<ValueType, UpdateType = ValueType> = {
+    reducer: BinaryOperator<ValueType, UpdateType>;
+    default?: () => ValueType;
 } | {
     /**
      * @deprecated Use `reducer` instead
      */
-    value: BinaryOperator<T>;
-    default?: () => T;
+    value: BinaryOperator<ValueType, UpdateType>;
+    default?: () => ValueType;
 } | null;
 export type ChannelReducers<Channels extends object> = {
-    [K in keyof Channels]: SingleReducer<Channels[K]>;
+    [K in keyof Channels]: SingleReducer<Channels[K], any>;
 };
 export interface StateGraphArgs<Channels extends object | unknown> {
     channels: Channels extends object ? Channels extends unknown[] ? ChannelReducers<{
@@ -24,7 +24,7 @@ export interface StateGraphArgs<Channels extends object | unknown> {
         __root__: Channels;
     }>;
 }
-export declare class StateGraph<State extends object | unknown, Update extends object | unknown = Partial<State>, N extends string = typeof START> extends Graph<N, State, Update> {
+export declare class StateGraph<State extends object | unknown, Update extends object | unknown = Partial<Record<keyof State, any>>, N extends string = typeof START> extends Graph<N, State, Update> {
     channels: Record<string, BaseChannel>;
     waitingEdges: Set<[N[], N]>;
     constructor(fields: StateGraphArgs<State>);

package/dist/prebuilt/agent_executor.d.ts

@@ -16,5 +16,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/state.js").CompiledStateGraph<AgentExecutorState, Partial<Record<keyof AgentExecutorState, any>>, "__start__" | "agent" | "action">;
 export {};

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

@@ -22,6 +22,13 @@ export declare class ToolExecutor extends RunnableBinding<ToolExecutorInputType,
     toolMap: Record<string, StructuredTool>;
     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.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.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/diagrams.test.js

@@ -0,0 +1,25 @@
+import { test, expect } from "@jest/globals";
+import { createReactAgent } from "../prebuilt/index.js";
+import { FakeSearchTool, FakeToolCallingChatModel } from "./utils.js";
+test("prebuilt agent", async () => {
+    // Define the tools for the agent to use
+    const tools = [new FakeSearchTool()];
+    const model = new FakeToolCallingChatModel({});
+    const app = createReactAgent({ llm: model, tools });
+    const graph = app.getGraph();
+    const mermaid = graph.drawMermaid();
+    expect(mermaid).toEqual(`%%{init: {'flowchart': {'curve': 'linear'}}}%%
+graph TD;
+\t__start__[__start__]:::startclass;
+\t__end__[__end__]:::endclass;
+\tagent([agent]):::otherclass;
+\ttools([tools]):::otherclass;
+\t__start__ --> agent;
+\ttools --> agent;
+\tagent -. continue .-> tools;
+\tagent -.-> __end__;
+\tclassDef startclass fill:#ffdfba;
+\tclassDef endclass fill:#baffc9;
+\tclassDef otherclass fill:#fad7de;
+`);
+});

package/dist/tests/graph.test.js

@@ -1,5 +1,6 @@
 import { describe, it, expect } from "@jest/globals";
 import { StateGraph } from "../graph/state.js";
+import { END, START } from "../web.js";
 describe("State", () => {
     it("should validate a new node key correctly ", () => {
         const stateGraph = new StateGraph({
@@ -12,4 +13,21 @@ describe("State", () => {
             stateGraph.addNode("newNodeKey", (_) => ({}));
         }).not.toThrow();
     });
+    it("should allow reducers with different argument types", async () => {
+        const stateGraph = new StateGraph({
+            channels: {
+                testval: {
+                    reducer: (left, right) => right ? left.concat([right.toString()]) : left,
+                },
+            },
+        });
+        const graph = stateGraph
+            .addNode("testnode", (_) => ({ testval: "hi!" }))
+            .addEdge(START, "testnode")
+            .addEdge("testnode", END)
+            .compile();
+        expect(await graph.invoke({ testval: ["hello"] })).toEqual({
+            testval: ["hello", "hi!"],
+        });
+    });
 });