@langchain/langgraph 0.0.26 → 0.0.27-rc.0

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/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 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 +317,79 @@ class CompiledGraph extends index_js_1.Pregel {
             }
         }
     }
+    // Returns a drawable representation of the computation graph.
+    getGraph(config) {
+        const xray = config?.xray;
+        const graph = new utils_js_1.DrawableGraph();
+        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])),
+                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;
+function isCompiledGraph(x) {
+    return (typeof x.attachNode === "function" &&
+        typeof x.attachEdge === "function");
+}

package/dist/graph/graph.d.ts

@@ -4,7 +4,7 @@ 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 { RunnableCallable } from "../utils.js";
+import { DrawableGraph, RunnableCallable } from "../utils.js";
 export declare const START = "__start__";
 export declare const END = "__end__";
 export interface BranchOptions<IO, N extends string> {
@@ -56,4 +56,7 @@ 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;
+    getGraph(config?: RunnableConfig & {
+        xray?: boolean | number;
+    }): DrawableGraph;
 }

package/dist/graph/graph.js

@@ -1,11 +1,12 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import { _coerceToRunnable, } from "@langchain/core/runnables";
+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 { RunnableCallable } from "../utils.js";
+import { DrawableGraph, RunnableCallable } from "../utils.js";
 export const START = "__start__";
 export const END = "__end__";
 export class Branch {
@@ -311,4 +312,78 @@ export class CompiledGraph extends Pregel {
             }
         }
     }
+    // Returns a drawable representation of the computation graph.
+    getGraph(config) {
+        const xray = config?.xray;
+        const graph = new DrawableGraph();
+        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;
+    }
+}
+function isCompiledGraph(x) {
+    return (typeof x.attachNode === "function" &&
+        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/tests/diagrams.test.d.ts

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

package/dist/tests/diagrams.test.js

@@ -0,0 +1,26 @@
+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 () => {
+    // Define the tools for the agent to use
+    const tools = [new TavilySearchResults({ maxResults: 1 })];
+    const model = new ChatOpenAI({ temperature: 0 });
+    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!"],
+        });
+    });
 });

package/dist/utils.cjs

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunnableCallable = void 0;
+exports.DrawableGraph = exports.RunnableCallable = void 0;
 const runnables_1 = require("@langchain/core/runnables");
 const singletons_1 = require("@langchain/core/singletons");
+const graph_1 = require("@langchain/core/runnables/graph");
+const uuid_1 = require("uuid");
 class RunnableCallable extends runnables_1.Runnable {
     constructor(fields) {
         super();
@@ -85,3 +87,36 @@ class RunnableCallable extends runnables_1.Runnable {
     }
 }
 exports.RunnableCallable = RunnableCallable;
+class DrawableGraph extends graph_1.Graph {
+    extend(graph, prefix = "") {
+        const nodeIds = Object.values(graph.nodes).map((node) => node.id);
+        if (nodeIds.every(uuid_1.validate)) {
+            super.extend(graph);
+            return [graph.firstNode(), graph.lastNode()];
+        }
+        const newNodes = Object.entries(graph.nodes).reduce((nodes, [key, value]) => {
+            nodes[`${prefix}:${key}`] = {
+                id: `${prefix}:${key}`,
+                data: value.data,
+            };
+            return nodes;
+        }, {});
+        const newEdges = graph.edges.map((edge) => {
+            return {
+                source: `${prefix}:${edge.source}`,
+                target: `${prefix}:${edge.target}`,
+                data: edge.data,
+                conditional: edge.conditional,
+            };
+        });
+        this.nodes = { ...this.nodes, ...newNodes };
+        this.edges = this.edges.concat(newEdges);
+        const first = graph.firstNode();
+        const last = graph.lastNode();
+        return [
+            first ? { id: `${prefix}:${first.id}`, data: first.data } : undefined,
+            last ? { id: `${prefix}:${last.id}`, data: last.data } : undefined,
+        ];
+    }
+}
+exports.DrawableGraph = DrawableGraph;

package/dist/utils.d.ts

@@ -1,5 +1,6 @@
 import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
 import { Runnable, RunnableConfig } from "@langchain/core/runnables";
+import { Graph, type Node as RunnableGraphNode } from "@langchain/core/runnables/graph";
 export interface RunnableCallableArgs extends Partial<any> {
     name?: string;
     func: (...args: any[]) => any;
@@ -18,3 +19,6 @@ export declare class RunnableCallable<I = unknown, O = unknown> extends Runnable
     protected _tracedInvoke(input: I, config?: Partial<RunnableConfig>, runManager?: CallbackManagerForChainRun): Promise<O>;
     invoke(input: any, options?: Partial<RunnableConfig> | undefined): Promise<any>;
 }
+export declare class DrawableGraph extends Graph {
+    extend(graph: Graph, prefix?: string): (RunnableGraphNode | undefined)[];
+}

package/dist/utils.js

@@ -1,5 +1,7 @@
 import { mergeConfigs, patchConfig, Runnable, } from "@langchain/core/runnables";
 import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
+import { Graph, } from "@langchain/core/runnables/graph";
+import { validate as isUuid } from "uuid";
 export class RunnableCallable extends Runnable {
     constructor(fields) {
         super();
@@ -81,3 +83,35 @@ export class RunnableCallable extends Runnable {
         return returnValue;
     }
 }
+export class DrawableGraph extends Graph {
+    extend(graph, prefix = "") {
+        const nodeIds = Object.values(graph.nodes).map((node) => node.id);
+        if (nodeIds.every(isUuid)) {
+            super.extend(graph);
+            return [graph.firstNode(), graph.lastNode()];
+        }
+        const newNodes = Object.entries(graph.nodes).reduce((nodes, [key, value]) => {
+            nodes[`${prefix}:${key}`] = {
+                id: `${prefix}:${key}`,
+                data: value.data,
+            };
+            return nodes;
+        }, {});
+        const newEdges = graph.edges.map((edge) => {
+            return {
+                source: `${prefix}:${edge.source}`,
+                target: `${prefix}:${edge.target}`,
+                data: edge.data,
+                conditional: edge.conditional,
+            };
+        });
+        this.nodes = { ...this.nodes, ...newNodes };
+        this.edges = this.edges.concat(newEdges);
+        const first = graph.firstNode();
+        const last = graph.lastNode();
+        return [
+            first ? { id: `${prefix}:${first.id}`, data: first.data } : undefined,
+            last ? { id: `${prefix}:${last.id}`, data: last.data } : undefined,
+        ];
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.0.26",
+  "version": "0.0.27-rc.0",
   "description": "LangGraph",
   "type": "module",
   "engines": {
@@ -37,8 +37,9 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@langchain/core": ">0.1.61 <0.3.0",
-    "uuid": "^10.0.0"
+    "@langchain/core": ">0.2.14 <0.3.0",
+    "uuid": "^10.0.0",
+    "zod": "^3.23.8"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",
@@ -73,7 +74,6 @@
     "ts-jest": "^29.1.0",
     "tsx": "^4.7.0",
     "typescript": "^4.9.5 || ^5.4.5",
-    "zod": "^3.22.4",
     "zod-to-json-schema": "^3.22.4"
   },
   "peerDependencies": {