@langchain/langgraph 0.0.31 → 0.0.32

package/dist/tests/tracing.test.js

@@ -1,332 +0,0 @@
-import { expect, it } from "@jest/globals";
-import { AIMessage, HumanMessage } from "@langchain/core/messages";
-import { FakeToolCallingChatModel } from "./utils.js";
-// Import from main `@langchain/langgraph` endpoint to turn on automatic config passing
-import { END, START, StateGraph } from "../index.js";
-it("should pass config through if importing from the primary entrypoint", async () => {
-    const stateGraph = new StateGraph({
-        channels: { messages: null },
-    });
-    const graph = stateGraph
-        .addNode("testnode", async (_) => {
-        const model = new FakeToolCallingChatModel({
-            responses: [new AIMessage("hey!")],
-        }).withConfig({ runName: "model_call" });
-        // Don't explicitly pass config here
-        const res = await model.invoke("hello!");
-        return { messages: [res] };
-    })
-        .addEdge(START, "testnode")
-        .addConditionalEdges("testnode", async (_state) => {
-        const model = new FakeToolCallingChatModel({
-            responses: [new AIMessage("hey!")],
-        }).withConfig({ runName: "conditional_edge_call" });
-        await model.invoke("testing but should be traced");
-        return END;
-    })
-        .compile();
-    const eventStream = graph.streamEvents({ messages: [] }, { version: "v2" });
-    const events = [];
-    for await (const event of eventStream) {
-        events.push(event);
-    }
-    expect(events).toEqual([
-        {
-            event: "on_chain_start",
-            data: {
-                input: {
-                    messages: [],
-                },
-            },
-            name: "LangGraph",
-            tags: [],
-            run_id: expect.any(String),
-            metadata: {},
-        },
-        {
-            event: "on_chain_start",
-            data: {
-                input: {
-                    messages: [],
-                },
-            },
-            name: "__start__",
-            tags: ["graph:step:0", "langsmith:hidden"],
-            run_id: expect.any(String),
-            metadata: {
-                langgraph_node: "__start__",
-                langgraph_step: 0,
-                langgraph_task_idx: 0,
-                langgraph_triggers: ["__pregel_tasks"],
-            },
-        },
-        {
-            event: "on_chain_end",
-            data: {
-                output: { output: undefined },
-                input: {
-                    messages: [],
-                },
-            },
-            run_id: expect.any(String),
-            name: "__start__",
-            tags: ["graph:step:0", "langsmith:hidden"],
-            metadata: {
-                langgraph_node: "__start__",
-                langgraph_step: 0,
-                langgraph_task_idx: 0,
-                langgraph_triggers: ["__pregel_tasks"],
-            },
-        },
-        {
-            event: "on_chain_start",
-            data: {
-                input: {
-                    messages: [],
-                },
-            },
-            name: "testnode",
-            tags: ["graph:step:1"],
-            run_id: expect.any(String),
-            metadata: {
-                langgraph_node: "testnode",
-                langgraph_step: 1,
-                langgraph_task_idx: 0,
-                langgraph_triggers: ["__pregel_tasks"],
-            },
-        },
-        {
-            event: "on_chain_start",
-            data: {
-                input: {
-                    messages: [],
-                },
-            },
-            name: "RunnableLambda",
-            tags: ["seq:step:1"],
-            run_id: expect.any(String),
-            metadata: {
-                langgraph_node: "testnode",
-                langgraph_step: 1,
-                langgraph_task_idx: 0,
-                langgraph_triggers: ["__pregel_tasks"],
-            },
-        },
-        {
-            event: "on_chat_model_start",
-            data: {
-                input: {
-                    messages: [[new HumanMessage("hello!")]],
-                },
-            },
-            name: "model_call",
-            tags: [],
-            run_id: expect.any(String),
-            metadata: {
-                langgraph_node: "testnode",
-                langgraph_step: 1,
-                langgraph_task_idx: 0,
-                langgraph_triggers: ["__pregel_tasks"],
-                ls_model_type: "chat",
-                ls_stop: undefined,
-            },
-        },
-        {
-            event: "on_chat_model_end",
-            data: {
-                output: new AIMessage("hey!"),
-                input: {
-                    messages: [[new HumanMessage("hello!")]],
-                },
-            },
-            run_id: expect.any(String),
-            name: "model_call",
-            tags: [],
-            metadata: {
-                langgraph_node: "testnode",
-                langgraph_step: 1,
-                langgraph_task_idx: 0,
-                langgraph_triggers: ["__pregel_tasks"],
-                ls_model_type: "chat",
-                ls_stop: undefined,
-            },
-        },
-        {
-            event: "on_chain_end",
-            data: {
-                output: {
-                    messages: [new AIMessage("hey!")],
-                },
-                input: {
-                    messages: [],
-                },
-            },
-            run_id: expect.any(String),
-            name: "RunnableLambda",
-            tags: ["seq:step:1"],
-            metadata: {
-                langgraph_node: "testnode",
-                langgraph_step: 1,
-                langgraph_task_idx: 0,
-                langgraph_triggers: ["__pregel_tasks"],
-            },
-        },
-        {
-            event: "on_chain_start",
-            data: {
-                input: {
-                    messages: [new AIMessage("hey!")],
-                },
-            },
-            name: "ChannelWrite<messages,testnode>",
-            tags: ["seq:step:2", "langsmith:hidden"],
-            run_id: expect.any(String),
-            metadata: {
-                langgraph_node: "testnode",
-                langgraph_step: 1,
-                langgraph_task_idx: 0,
-                langgraph_triggers: ["__pregel_tasks"],
-            },
-        },
-        {
-            event: "on_chain_end",
-            data: {
-                output: { output: undefined },
-                input: {
-                    messages: [new AIMessage("hey!")],
-                },
-            },
-            run_id: expect.any(String),
-            name: "ChannelWrite<messages,testnode>",
-            tags: ["seq:step:2", "langsmith:hidden"],
-            metadata: {
-                langgraph_node: "testnode",
-                langgraph_step: 1,
-                langgraph_task_idx: 0,
-                langgraph_triggers: ["__pregel_tasks"],
-            },
-        },
-        {
-            event: "on_chain_start",
-            data: {
-                input: {
-                    input: undefined,
-                },
-            },
-            name: "func",
-            tags: ["seq:step:3"],
-            run_id: expect.any(String),
-            metadata: {
-                langgraph_node: "testnode",
-                langgraph_step: 1,
-                langgraph_task_idx: 0,
-                langgraph_triggers: ["__pregel_tasks"],
-            },
-        },
-        {
-            event: "on_chat_model_start",
-            data: {
-                input: {
-                    messages: [[new HumanMessage("testing but should be traced")]],
-                },
-            },
-            name: "conditional_edge_call",
-            tags: [],
-            run_id: expect.any(String),
-            metadata: {
-                langgraph_node: "testnode",
-                langgraph_step: 1,
-                langgraph_task_idx: 0,
-                langgraph_triggers: ["__pregel_tasks"],
-                ls_model_type: "chat",
-                ls_stop: undefined,
-            },
-        },
-        {
-            event: "on_chat_model_end",
-            data: {
-                output: new AIMessage("hey!"),
-                input: {
-                    messages: [[new HumanMessage("testing but should be traced")]],
-                },
-            },
-            run_id: expect.any(String),
-            name: "conditional_edge_call",
-            tags: [],
-            metadata: {
-                langgraph_node: "testnode",
-                langgraph_step: 1,
-                langgraph_task_idx: 0,
-                langgraph_triggers: ["__pregel_tasks"],
-                ls_model_type: "chat",
-                ls_stop: undefined,
-            },
-        },
-        {
-            event: "on_chain_end",
-            data: {
-                output: {
-                    output: undefined,
-                },
-                input: {
-                    input: undefined,
-                },
-            },
-            run_id: expect.any(String),
-            name: "func",
-            tags: ["seq:step:3"],
-            metadata: {
-                langgraph_node: "testnode",
-                langgraph_step: 1,
-                langgraph_task_idx: 0,
-                langgraph_triggers: ["__pregel_tasks"],
-            },
-        },
-        {
-            event: "on_chain_end",
-            data: {
-                output: { output: undefined },
-                input: {
-                    messages: [],
-                },
-            },
-            run_id: expect.any(String),
-            name: "testnode",
-            tags: ["graph:step:1"],
-            metadata: {
-                langgraph_node: "testnode",
-                langgraph_step: 1,
-                langgraph_task_idx: 0,
-                langgraph_triggers: ["__pregel_tasks"],
-            },
-        },
-        {
-            event: "on_chain_stream",
-            run_id: expect.any(String),
-            name: "LangGraph",
-            tags: [],
-            metadata: {},
-            data: {
-                chunk: {
-                    testnode: {
-                        messages: [new AIMessage("hey!")],
-                    },
-                },
-            },
-        },
-        {
-            event: "on_chain_end",
-            data: {
-                output: {
-                    testnode: {
-                        messages: [new AIMessage("hey!")],
-                    },
-                },
-            },
-            run_id: expect.any(String),
-            name: "LangGraph",
-            tags: [],
-            metadata: {},
-        },
-    ]);
-});

package/dist/tests/utils.d.ts

@@ -1,53 +0,0 @@
-import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
-import { BaseChatModel, BaseChatModelParams } from "@langchain/core/language_models/chat_models";
-import { BaseMessage } from "@langchain/core/messages";
-import { ChatResult } from "@langchain/core/outputs";
-import { RunnableConfig } from "@langchain/core/runnables";
-import { Tool } from "@langchain/core/tools";
-import { z } from "zod";
-import { MemorySaver } from "../checkpoint/memory.js";
-import { Checkpoint, CheckpointMetadata } from "../checkpoint/base.js";
-export interface FakeChatModelArgs extends BaseChatModelParams {
-    responses: BaseMessage[];
-}
-export declare class FakeChatModel extends BaseChatModel {
-    responses: BaseMessage[];
-    constructor(fields: FakeChatModelArgs);
-    _combineLLMOutput(): never[];
-    _llmType(): string;
-    _generate(messages: BaseMessage[], options?: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-}
-export declare class FakeToolCallingChatModel extends BaseChatModel {
-    sleep?: number;
-    responses?: BaseMessage[];
-    thrownErrorString?: string;
-    idx: number;
-    constructor(fields: {
-        sleep?: number;
-        responses?: BaseMessage[];
-        thrownErrorString?: string;
-    } & BaseChatModelParams);
-    _llmType(): string;
-    _generate(messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-    bindTools(_: Tool[]): FakeToolCallingChatModel;
-}
-export declare class MemorySaverAssertImmutable extends MemorySaver {
-    storageForCopies: Record<string, Record<string, string>>;
-    constructor();
-    put(config: RunnableConfig, checkpoint: Checkpoint, metadata: CheckpointMetadata): Promise<RunnableConfig>;
-}
-export declare class FakeSearchTool extends Tool {
-    name: string;
-    description: string;
-    schema: z.ZodEffects<z.ZodObject<{
-        input: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        input?: string | undefined;
-    }, {
-        input?: string | undefined;
-    }>, string | undefined, {
-        input?: string | undefined;
-    }>;
-    constructor();
-    _call(query: string): Promise<string>;
-}

package/dist/tests/utils.js

@@ -1,167 +0,0 @@
-import assert from "node:assert";
-import { BaseChatModel, } from "@langchain/core/language_models/chat_models";
-import { AIMessage } from "@langchain/core/messages";
-import { Tool } from "@langchain/core/tools";
-import { z } from "zod";
-import { MemorySaver } from "../checkpoint/memory.js";
-export class FakeChatModel extends BaseChatModel {
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "responses", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.responses = fields.responses;
-    }
-    _combineLLMOutput() {
-        return [];
-    }
-    _llmType() {
-        return "fake";
-    }
-    async _generate(messages, options, runManager) {
-        if (options?.stop?.length) {
-            return {
-                generations: [
-                    {
-                        message: new AIMessage(options.stop[0]),
-                        text: options.stop[0],
-                    },
-                ],
-            };
-        }
-        const response = this.responses.shift();
-        const text = messages.map((m) => m.content).join("\n");
-        await runManager?.handleLLMNewToken(text);
-        return {
-            generations: [
-                {
-                    message: response ?? new AIMessage(text),
-                    text: response ? response.content : text,
-                },
-            ],
-            llmOutput: {},
-        };
-    }
-}
-export class FakeToolCallingChatModel extends BaseChatModel {
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "sleep", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 50
-        });
-        Object.defineProperty(this, "responses", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "thrownErrorString", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "idx", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.sleep = fields.sleep ?? this.sleep;
-        this.responses = fields.responses;
-        this.thrownErrorString = fields.thrownErrorString;
-        this.idx = 0;
-    }
-    _llmType() {
-        return "fake";
-    }
-    async _generate(messages, _options, _runManager) {
-        if (this.thrownErrorString) {
-            throw new Error(this.thrownErrorString);
-        }
-        const msg = this.responses?.[this.idx] ?? messages[this.idx];
-        const generation = {
-            generations: [
-                {
-                    text: "",
-                    message: msg,
-                },
-            ],
-        };
-        this.idx += 1;
-        return generation;
-    }
-    bindTools(_) {
-        return new FakeToolCallingChatModel({
-            sleep: this.sleep,
-            responses: this.responses,
-            thrownErrorString: this.thrownErrorString,
-        });
-    }
-}
-export class MemorySaverAssertImmutable extends MemorySaver {
-    constructor() {
-        super();
-        Object.defineProperty(this, "storageForCopies", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-        this.storageForCopies = {};
-    }
-    async put(config, checkpoint, metadata) {
-        const thread_id = config.configurable?.thread_id;
-        if (!this.storageForCopies[thread_id]) {
-            this.storageForCopies[thread_id] = {};
-        }
-        // assert checkpoint hasn't been modified since last written
-        const saved = await super.get(config);
-        if (saved) {
-            const savedId = saved.id;
-            if (this.storageForCopies[thread_id][savedId]) {
-                assert(JSON.stringify(saved) === this.storageForCopies[thread_id][savedId], "Checkpoint has been modified since last written");
-            }
-        }
-        // save a copy of the checkpoint
-        this.storageForCopies[thread_id][checkpoint.id] =
-            this.serde.stringify(checkpoint);
-        return super.put(config, checkpoint, metadata);
-    }
-}
-export class FakeSearchTool extends Tool {
-    constructor() {
-        super();
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "search_api"
-        });
-        Object.defineProperty(this, "description", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "A simple API that returns the input string."
-        });
-        Object.defineProperty(this, "schema", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: z
-                .object({
-                input: z.string().optional(),
-            })
-                .transform((data) => data.input)
-        });
-    }
-    async _call(query) {
-        return `result for ${query}`;
-    }
-}