@langchain/langgraph 0.0.12 → 0.0.13

package/dist/pregel/write.cjs

@@ -1,54 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChannelWrite = void 0;
-const runnables_1 = require("@langchain/core/runnables");
+exports.ChannelWrite = exports.PASSTHROUGH = exports.SKIP_WRITE = void 0;
 const constants_js_1 = require("../constants.cjs");
+const utils_js_1 = require("../utils.cjs");
+exports.SKIP_WRITE = {};
+exports.PASSTHROUGH = {};
+const IS_WRITER = Symbol("IS_WRITER");
 /**
  * Mapping of write channels to Runnables that return the value to be written,
  * or None to skip writing.
  */
-class ChannelWrite extends runnables_1.RunnablePassthrough {
-    constructor(channels) {
-        const name = `ChannelWrite<${channels.map(([chan]) => chan).join(",")}>`;
+class ChannelWrite extends utils_js_1.RunnableCallable {
+    constructor(writes, tags) {
+        const name = `ChannelWrite<${writes
+            .map(({ channel }) => channel)
+            .join(",")}>`;
         super({
-            ...{ channels, name },
+            ...{ writes, name, tags },
             func: async (input, config) => this._write(input, config ?? {}),
         });
-        Object.defineProperty(this, "channels", {
+        Object.defineProperty(this, "writes", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.channels = channels;
+        this.writes = writes;
     }
-    get configSpecs() {
-        return [
-            {
-                id: constants_js_1.CONFIG_KEY_SEND,
-                name: constants_js_1.CONFIG_KEY_SEND,
-                description: null,
-                default: null,
-                annotation: "TYPE_SEND",
-                isShared: true,
-                dependencies: null,
-            },
-        ];
+    async _getWriteValues(input, config) {
+        return Promise.all(this.writes
+            .map((write) => ({
+            channel: write.channel,
+            value: write.value === exports.PASSTHROUGH ? input : write.value,
+            skipNone: write.skipNone,
+            mapper: write.mapper,
+        }))
+            .map(async (write) => ({
+            channel: write.channel,
+            value: write.mapper
+                ? await write.mapper.invoke(write.value, config)
+                : write.value,
+            skipNone: write.skipNone,
+            mapper: write.mapper,
+        }))).then((writes) => writes
+            .filter((write) => !write.skipNone || write.value !== null)
+            .reduce((acc, write) => {
+            acc[write.channel] = write.value;
+            return acc;
+        }, {}));
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async _write(input, config) {
-        const values = this.channels.map(async ([chan, r]) => [
-            chan,
-            r ? await r.invoke(input, config) : input,
-        ]);
-        let valuesAwaited = await Promise.all(values);
-        valuesAwaited = valuesAwaited.filter((write, index) => this.channels[index][1] === null || write[1] !== null);
-        ChannelWrite.doWrite(config, Object.fromEntries(valuesAwaited.filter(([_, val], i) => this.channels[i][1] ? Boolean(val) : val)));
+        const values = await this._getWriteValues(input, config);
+        ChannelWrite.doWrite(config, values);
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static doWrite(config, values) {
         const write = config.configurable?.[constants_js_1.CONFIG_KEY_SEND];
-        write(Object.entries(values));
+        write(Object.entries(values).filter(([_channel, value]) => value !== exports.SKIP_WRITE));
+    }
+    static isWriter(runnable) {
+        return (
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        runnable instanceof ChannelWrite ||
+            (IS_WRITER in runnable && !!runnable[IS_WRITER]));
+    }
+    static registerWriter(runnable) {
+        return Object.defineProperty(runnable, IS_WRITER, { value: true });
     }
 }
 exports.ChannelWrite = ChannelWrite;

package/dist/pregel/write.d.ts

@@ -1,13 +1,23 @@
-import { Runnable, RunnableConfig, RunnablePassthrough } from "@langchain/core/runnables";
-import { ConfigurableFieldSpec } from "../checkpoint/index.js";
+import { Runnable, RunnableConfig, RunnableLike } from "@langchain/core/runnables";
+import { RunnableCallable } from "../utils.js";
+export declare const SKIP_WRITE: {};
+export declare const PASSTHROUGH: {};
 /**
  * Mapping of write channels to Runnables that return the value to be written,
  * or None to skip writing.
  */
-export declare class ChannelWrite<RunInput = any, RunOutput = any> extends RunnablePassthrough<RunInput> {
-    channels: Array<[string, Runnable<RunInput, RunOutput> | undefined]>;
-    constructor(channels: Array<[string, Runnable<RunInput, RunOutput> | undefined]>);
-    get configSpecs(): ConfigurableFieldSpec[];
-    _write(input: any, config: RunnableConfig): Promise<void>;
-    static doWrite(config: RunnableConfig, values: Record<string, any>): void;
+export declare class ChannelWrite<RunInput = any> extends RunnableCallable {
+    writes: Array<ChannelWriteEntry>;
+    constructor(writes: Array<ChannelWriteEntry>, tags?: string[]);
+    _getWriteValues(input: unknown, config: RunnableConfig): Promise<Record<string, unknown>>;
+    _write(input: unknown, config: RunnableConfig): Promise<void>;
+    static doWrite(config: RunnableConfig, values: Record<string, unknown>): void;
+    static isWriter(runnable: RunnableLike): boolean;
+    static registerWriter<T extends Runnable>(runnable: T): T;
+}
+export interface ChannelWriteEntry {
+    channel: string;
+    value: unknown;
+    skipNone?: boolean;
+    mapper?: Runnable;
 }

package/dist/pregel/write.js

@@ -1,50 +1,66 @@
-import { RunnablePassthrough, } from "@langchain/core/runnables";
 import { CONFIG_KEY_SEND } from "../constants.js";
+import { RunnableCallable } from "../utils.js";
+export const SKIP_WRITE = {};
+export const PASSTHROUGH = {};
+const IS_WRITER = Symbol("IS_WRITER");
 /**
  * Mapping of write channels to Runnables that return the value to be written,
  * or None to skip writing.
  */
-export class ChannelWrite extends RunnablePassthrough {
-    constructor(channels) {
-        const name = `ChannelWrite<${channels.map(([chan]) => chan).join(",")}>`;
+export class ChannelWrite extends RunnableCallable {
+    constructor(writes, tags) {
+        const name = `ChannelWrite<${writes
+            .map(({ channel }) => channel)
+            .join(",")}>`;
         super({
-            ...{ channels, name },
+            ...{ writes, name, tags },
             func: async (input, config) => this._write(input, config ?? {}),
         });
-        Object.defineProperty(this, "channels", {
+        Object.defineProperty(this, "writes", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.channels = channels;
+        this.writes = writes;
     }
-    get configSpecs() {
-        return [
-            {
-                id: CONFIG_KEY_SEND,
-                name: CONFIG_KEY_SEND,
-                description: null,
-                default: null,
-                annotation: "TYPE_SEND",
-                isShared: true,
-                dependencies: null,
-            },
-        ];
+    async _getWriteValues(input, config) {
+        return Promise.all(this.writes
+            .map((write) => ({
+            channel: write.channel,
+            value: write.value === PASSTHROUGH ? input : write.value,
+            skipNone: write.skipNone,
+            mapper: write.mapper,
+        }))
+            .map(async (write) => ({
+            channel: write.channel,
+            value: write.mapper
+                ? await write.mapper.invoke(write.value, config)
+                : write.value,
+            skipNone: write.skipNone,
+            mapper: write.mapper,
+        }))).then((writes) => writes
+            .filter((write) => !write.skipNone || write.value !== null)
+            .reduce((acc, write) => {
+            acc[write.channel] = write.value;
+            return acc;
+        }, {}));
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async _write(input, config) {
-        const values = this.channels.map(async ([chan, r]) => [
-            chan,
-            r ? await r.invoke(input, config) : input,
-        ]);
-        let valuesAwaited = await Promise.all(values);
-        valuesAwaited = valuesAwaited.filter((write, index) => this.channels[index][1] === null || write[1] !== null);
-        ChannelWrite.doWrite(config, Object.fromEntries(valuesAwaited.filter(([_, val], i) => this.channels[i][1] ? Boolean(val) : val)));
+        const values = await this._getWriteValues(input, config);
+        ChannelWrite.doWrite(config, values);
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static doWrite(config, values) {
         const write = config.configurable?.[CONFIG_KEY_SEND];
-        write(Object.entries(values));
+        write(Object.entries(values).filter(([_channel, value]) => value !== SKIP_WRITE));
+    }
+    static isWriter(runnable) {
+        return (
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        runnable instanceof ChannelWrite ||
+            (IS_WRITER in runnable && !!runnable[IS_WRITER]));
+    }
+    static registerWriter(runnable) {
+        return Object.defineProperty(runnable, IS_WRITER, { value: true });
     }
 }

package/dist/serde/base.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/serde/base.d.ts

@@ -0,0 +1,4 @@
+export interface SerializerProtocol<D> {
+    stringify(obj: D): string;
+    parse(data: string): D;
+}

package/dist/serde/base.js

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

package/dist/setup/async_local_storage.cjs

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initializeAsyncLocalStorageSingleton = void 0;
 const singletons_1 = require("@langchain/core/singletons");
-const async_hooks_1 = require("async_hooks");
+const node_async_hooks_1 = require("node:async_hooks");
 function initializeAsyncLocalStorageSingleton() {
-    singletons_1.AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new async_hooks_1.AsyncLocalStorage());
+    singletons_1.AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new node_async_hooks_1.AsyncLocalStorage());
 }
 exports.initializeAsyncLocalStorageSingleton = initializeAsyncLocalStorageSingleton;

package/dist/setup/async_local_storage.js

@@ -1,5 +1,5 @@
 import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
-import { AsyncLocalStorage } from "async_hooks";
+import { AsyncLocalStorage } from "node:async_hooks";
 export function initializeAsyncLocalStorageSingleton() {
     AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new AsyncLocalStorage());
 }

package/dist/tests/channels.test.d.ts

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

package/dist/tests/channels.test.js

@@ -0,0 +1,151 @@
+import { describe, it, expect } from "@jest/globals";
+import { AnyValue } from "../channels/any_value.js";
+import { EphemeralValue } from "../channels/ephemeral_value.js";
+import { LastValue } from "../channels/last_value.js";
+import { EmptyChannelError, InvalidUpdateError } from "../errors.js";
+import { Topic } from "../channels/topic.js";
+import { BinaryOperatorAggregate } from "../channels/binop.js";
+describe("LastValue", () => {
+    it("should handle last value correctly", () => {
+        const channel = new LastValue();
+        expect(() => {
+            channel.get();
+        }).toThrow(EmptyChannelError);
+        expect(() => {
+            channel.update([5, 6]);
+        }).toThrow(InvalidUpdateError);
+        channel.update([3]);
+        expect(channel.get()).toBe(3);
+        channel.update([4]);
+        expect(channel.get()).toBe(4);
+    });
+    it("should handle restoring from checkpoint correctly", () => {
+        // call `.update()` to add a value to the channel
+        const channel = new LastValue();
+        channel.update([100]);
+        const checkpoint = channel.checkpoint();
+        const restoredChannel = new LastValue();
+        const channel2 = restoredChannel.fromCheckpoint(checkpoint);
+        expect(channel2.get()).toBe(100);
+    });
+});
+describe("Topic", () => {
+    const channel = new Topic();
+    it("should handle updates and get operations", () => {
+        channel.update(["a", "b"]);
+        expect(channel.get()).toEqual(["a", "b"]);
+        channel.update([["c", "d"], "d"]);
+        expect(channel.get()).toEqual(["c", "d", "d"]);
+        channel.update([]);
+        expect(channel.get()).toEqual([]);
+        channel.update(["e"]);
+        expect(channel.get()).toEqual(["e"]);
+    });
+    it("should create and use a checkpoint", () => {
+        const checkpoint = channel.checkpoint();
+        const newChannel = new Topic().fromCheckpoint(checkpoint);
+        expect(newChannel.get()).toEqual(["e"]);
+    });
+});
+describe("Topic with unique: true", () => {
+    const channel = new Topic({ unique: true });
+    it("should de-dupe updates and get the last unique value", () => {
+        channel.update(["a", "b"]);
+        expect(channel.get()).toEqual(["a", "b"]);
+        channel.update(["b", ["c", "d"], "d"]);
+        expect(channel.get()).toEqual(["c", "d"]);
+        channel.update([]);
+        expect(channel.get()).toEqual([]);
+        channel.update(["e"]);
+        expect(channel.get()).toEqual(["e"]);
+    });
+    it("should de-dupe from checkpoint", () => {
+        const checkpoint = channel.checkpoint();
+        const newChannel = new Topic({ unique: true }).fromCheckpoint(checkpoint);
+        expect(newChannel.get()).toEqual(["e"]);
+        newChannel.update(["d", "f"]);
+        expect(newChannel.get()).toEqual(["f"]);
+    });
+});
+describe("Topic with accumulate: true", () => {
+    const channel = new Topic({ accumulate: true });
+    it("should accumulate updates and get operations", () => {
+        channel.update(["a", "b"]);
+        expect(channel.get()).toEqual(["a", "b"]);
+        channel.update(["b", ["c", "d"], "d"]);
+        expect(channel.get()).toEqual(["a", "b", "b", "c", "d", "d"]);
+        channel.update([]);
+        expect(channel.get()).toEqual(["a", "b", "b", "c", "d", "d"]);
+    });
+    it("should create and use a checkpoint", () => {
+        const checkpoint = channel.checkpoint();
+        const newChannel = new Topic({ accumulate: true }).fromCheckpoint(checkpoint);
+        expect(newChannel.get()).toEqual(["a", "b", "b", "c", "d", "d"]);
+        newChannel.update(["e"]);
+        expect(newChannel.get()).toEqual(["a", "b", "b", "c", "d", "d", "e"]);
+    });
+});
+describe("Topic with accumulate and unique: true", () => {
+    const channel = new Topic({ unique: true, accumulate: true });
+    it("should handle unique and accumulate updates and get operations", () => {
+        channel.update(["a", "b"]);
+        expect(channel.get()).toEqual(["a", "b"]);
+        channel.update(["b", ["c", "d"], "d"]);
+        expect(channel.get()).toEqual(["a", "b", "c", "d"]);
+        channel.update([]);
+        expect(channel.get()).toEqual(["a", "b", "c", "d"]);
+    });
+    it("should create and use a checkpoint", () => {
+        const checkpoint = channel.checkpoint();
+        const newChannel = new Topic({
+            unique: true,
+            accumulate: true,
+        }).fromCheckpoint(checkpoint);
+        expect(newChannel.get()).toEqual(["a", "b", "c", "d"]);
+        newChannel.update(["d", "e"]);
+        expect(newChannel.get()).toEqual(["a", "b", "c", "d", "e"]);
+    });
+});
+describe("BinaryOperatorAggregate", () => {
+    it("should handle binary operator aggregation correctly", () => {
+        const channel = new BinaryOperatorAggregate((a, b) => a + b, () => 0);
+        expect(channel.get()).toBe(0);
+        channel.update([1, 2, 3]);
+        expect(channel.get()).toBe(6);
+        channel.update([4]);
+        expect(channel.get()).toBe(10);
+    });
+    it("should handle checkpointing correctly", () => {
+        const channel = new BinaryOperatorAggregate((a, b) => a + b, () => 0);
+        channel.update([1, 2, 3]);
+        channel.update([4]);
+        const checkpoint = channel.checkpoint();
+        const restoredChannel = new BinaryOperatorAggregate((a, b) => a + b, () => 10);
+        const channel2 = restoredChannel.fromCheckpoint(checkpoint);
+        expect(channel2.get()).toBe(10);
+    });
+});
+describe("AnyValue", () => {
+    it("should handle any value correctly", () => {
+        const channel = new AnyValue();
+        expect(() => {
+            channel.get();
+        }).toThrow(EmptyChannelError);
+        channel.update([3]);
+        expect(channel.get()).toBe(3);
+        channel.update([4, 5]);
+        expect(channel.get()).toBe(5);
+    });
+});
+describe("EphemeralValue with gaurd: false", () => {
+    it("should handle ephemeral value correctly", () => {
+        const channel = new EphemeralValue(false);
+        expect(() => {
+            channel.get();
+        }).toThrow(EmptyChannelError);
+        channel.update([3]);
+        expect(channel.get()).toBe(3);
+        channel.update([4, 5]);
+        expect(channel.get()).toBe(5);
+    });
+});

package/dist/tests/chatbot.int.test.d.ts

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

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

@@ -0,0 +1,61 @@
+import { describe, it } from "@jest/globals";
+import { ChatOpenAI } from "@langchain/openai";
+import { HumanMessage, ToolMessage, } from "@langchain/core/messages";
+import { Calculator } from "langchain/tools/calculator";
+import { convertToOpenAITool } from "@langchain/core/utils/function_calling";
+import { END, MessageGraph, START } from "../index.js";
+describe("Chatbot", () => {
+    it("Simple chat use-case", async () => {
+        const model = new ChatOpenAI({ temperature: 0 });
+        const graph = new MessageGraph()
+            .addNode("oracle", async (state) => model.invoke(state))
+            .addEdge("oracle", END)
+            .setEntryPoint("oracle")
+            .compile();
+        const res = await graph.invoke(new HumanMessage("What is 1 + 1?"));
+        console.log(res);
+    });
+    it("Chat use-case with tool calling", async () => {
+        const model = new ChatOpenAI({
+            temperature: 0,
+        }).bind({
+            tools: [convertToOpenAITool(new Calculator())],
+            tool_choice: "auto",
+        });
+        const router = (state) => {
+            const toolCalls = state[state.length - 1].additional_kwargs.tool_calls ?? [];
+            if (toolCalls.length) {
+                return "calculator";
+            }
+            else {
+                return "end";
+            }
+        };
+        const graph = new MessageGraph()
+            .addNode("oracle", async (state) => model.invoke(state))
+            .addNode("calculator", async (state) => {
+            const tool = new Calculator();
+            const toolCalls = state[state.length - 1].additional_kwargs.tool_calls ?? [];
+            const calculatorCall = toolCalls.find((toolCall) => toolCall.function.name === "calculator");
+            if (calculatorCall === undefined) {
+                throw new Error("No calculator input found.");
+            }
+            const result = await tool.invoke(JSON.parse(calculatorCall.function.arguments));
+            return new ToolMessage({
+                tool_call_id: calculatorCall.id,
+                content: result,
+            });
+        })
+            .addEdge("calculator", END)
+            .addEdge(START, "oracle")
+            .addConditionalEdges("oracle", router, {
+            calculator: "calculator",
+            end: END,
+        })
+            .compile();
+        const res = await graph.invoke(new HumanMessage("What is 1 + 1?"));
+        console.log(res);
+        const res2 = await graph.invoke(new HumanMessage("What is your name?"));
+        console.log(res2);
+    });
+});

package/dist/tests/checkpoints.test.d.ts

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