@langchain/langgraph 0.0.23 → 0.0.24

package/README.md

@@ -46,7 +46,7 @@ And now we're ready! The graph below contains a single node called `"oracle"` th
 ```ts
 import { ChatOpenAI } from "@langchain/openai";
 import { HumanMessage, BaseMessage, } from "@langchain/core/messages";
-import { END, MessageGraph } from "@langchain/langgraph";
+import { START, END, MessageGraph } from "@langchain/langgraph";
 
 const model = new ChatOpenAI({ temperature: 0 });
 
@@ -58,7 +58,7 @@ graph.addNode("oracle", async (state: BaseMessage[]) => {
 
 graph.addEdge("oracle", END);
 
-graph.setEntryPoint("oracle");
+graph.addEdge(START, "oracle");
 
 const runnable = graph.compile();
 ```
@@ -90,7 +90,7 @@ So what did we do here? Let's break it down step by step:
 1. First, we initialize our model and a `MessageGraph`.
 2. Next, we add a single node to the graph, called `"oracle"`, which simply calls the model with the given input.
 3. We add an edge from this `"oracle"` node to the special value `END`. This means that execution will end after current node.
-4. We set `"oracle"` as the entrypoint to the graph.
+4. We set `"oracle"` as the entrypoint to the graph by adding an edge from the special `START` value to it.
 5. We compile the graph, ensuring that no more modifications to it can be made.
 
 Then, when we execute the graph:
@@ -185,7 +185,7 @@ graph.addNode("calculator", async (state: BaseMessage[]) => {
 
 graph.addEdge("calculator", END);
 
-graph.setEntryPoint("oracle");
+graph.addEdge(START, "oracle");
 ```
 
 Now let's think - what do we want to have happen?
@@ -477,7 +477,7 @@ const callTool = async (
 We can now put it all together and define the graph!
 
 ```typescript
-import { StateGraph, END } from "@langchain/langgraph";
+import { StateGraph, START, END } from "@langchain/langgraph";
 import { RunnableLambda } from "@langchain/core/runnables";
 
 // Define a new graph
@@ -491,7 +491,7 @@ workflow.addNode("action", callTool);
 
 // Set the entrypoint as `agent`
 // This means that this node is the first one called
-workflow.setEntryPoint("agent");
+workflow.addEdge(START, "agent");
 
 // We now add a conditional edge
 workflow.addConditionalEdges(
@@ -723,31 +723,14 @@ This takes three arguments:
 - `condition`: A function to call to decide what to do next. The input will be the output of the start node. It should return a string that is present in `conditionalEdgeMapping` and represents the edge to take.
 - `conditionalEdgeMapping`: A mapping of string to string. The keys should be strings that may be returned by `condition`. The values should be the downstream node to call if that condition is returned.
 
-### `.setEntryPoint`
+### `START`
 
 ```typescript
-setEntryPoint(key: string): void
+import { START } from "@langchain/langgraph";
 ```
 
-The entrypoint to the graph.
-This is the node that is first called.
-It only takes one argument:
-
-- `key`: The name of the node that should be called first.
-
-### `.setFinishPoint`
-
-```typescript
-setFinishPoint(key: string): void
-```
-
-This is the exit point of the graph.
-When this node is called, the results will be the final result from the graph.
-It only has one argument:
-
-- `key`: The name of the node that, when called, will return the results of calling it as the final output
-
-Note: This does not need to be called if at any point you previously created an edge (conditional or normal) to `END`
+This is a special node representing the start of the graph.
+This means that anything with an edge from this node will be the entrypoint of the graph.
 
 ### `END`
 
@@ -827,7 +810,7 @@ workflow.addNode("agent", agent);
 workflow.addNode("tools", executeTools);
 
 // We now set the entry point to be this first agent
-workflow.setEntryPoint("firstAgent");
+workflow.addEdge(START, "firstAgent");
 
 // We define the same edges as before
 workflow.addConditionalEdges("agent", shouldContinue, {

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

@@ -15,7 +15,7 @@ describe("Chatbot", () => {
         const graph = new MessageGraph()
             .addNode("oracle", async (state) => model.invoke(state))
             .addEdge("oracle", END)
-            .setEntryPoint("oracle")
+            .addEdge(START, "oracle")
             .compile();
         const res = await graph.invoke(new HumanMessage("What is 1 + 1?"));
         console.log(res);

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

@@ -15,7 +15,7 @@ import { z } from "zod";
 import { ToolExecutor } from "../prebuilt/tool_executor.js";
 import { createAgentExecutor } from "../prebuilt/agent_executor.js";
 // Import from main `@langchain/langgraph` endpoint to turn on automatic config passing
-import { StateGraph, END } from "../index.js";
+import { StateGraph, END, START } from "../index.js";
 test.skip("Can invoke with tracing", async () => {
     const tools = [new TavilySearchResults({ maxResults: 1 })];
     // Get the prompt to use - you can modify this!
@@ -73,7 +73,7 @@ test.skip("Can invoke with tracing", async () => {
         .addNode("action", new RunnableLambda({ func: executeTools }))
         // Set the entrypoint as `agent`
         // This means that this node is the first one called
-        .setEntryPoint("agent")
+        .addEdge(START, "agent")
         // We now add a conditional edge
         .addConditionalEdges(
     // First, we define the start node. We use `agent`.
@@ -188,7 +188,7 @@ test.skip("Can nest an agent executor", async () => {
         // Or end work if done
         FINISH: END,
     })
-        .setEntryPoint("supervisor");
+        .addEdge(START, "supervisor");
     const graph = workflow.compile();
     const streamResults = graph.stream({
         messages: [
@@ -287,7 +287,7 @@ test.skip("Can nest a graph within a graph", async () => {
         researcher: "researcher",
         FINISH: END,
     })
-        .setEntryPoint("supervisor");
+        .addEdge(START, "supervisor");
     const graph = workflow.compile();
     const streamResults = graph.stream({
         messages: [
@@ -425,7 +425,7 @@ Only add steps to the plan that still NEED to be done. Do not return previously
         .addNode("agent", executeStep)
         // Add a replan node
         .addNode("replan", replanStep)
-        .setEntryPoint("planner")
+        .addEdge(START, "planner")
         // From plan we go to agent
         .addEdge("planner", "agent")
         // From agent, we replan

package/dist/tests/tracing.test.js

@@ -17,7 +17,13 @@ it("should pass config through if importing from the primary entrypoint", async
         return { messages: [res] };
     })
         .addEdge(START, "testnode")
-        .addEdge("testnode", END)
+        .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 = [];
@@ -157,6 +163,64 @@ it("should pass config through if importing from the primary entrypoint", async
             tags: ["seq:step:2", "langsmith:hidden"],
             metadata: {},
         },
+        {
+            event: "on_chain_start",
+            data: {
+                input: {
+                    input: undefined,
+                },
+            },
+            name: "func",
+            tags: ["seq:step:3"],
+            run_id: expect.any(String),
+            metadata: {},
+        },
+        {
+            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: {
+                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: {
+                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: {},
+        },
         {
             event: "on_chain_end",
             data: {

package/dist/utils.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RunnableCallable = void 0;
 const runnables_1 = require("@langchain/core/runnables");
+const singletons_1 = require("@langchain/core/singletons");
 class RunnableCallable extends runnables_1.Runnable {
     constructor(fields) {
         super();
@@ -48,24 +49,36 @@ class RunnableCallable extends runnables_1.Runnable {
         this.trace = fields.trace ?? this.trace;
         this.recurse = fields.recurse ?? this.recurse;
     }
+    async _tracedInvoke(input, config, runManager) {
+        return new Promise((resolve, reject) => {
+            const childConfig = (0, runnables_1.patchConfig)(config, {
+                callbacks: runManager?.getChild(),
+            });
+            void singletons_1.AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
+                try {
+                    const output = await this.func(input, childConfig);
+                    resolve(output);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+    }
     async invoke(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input, options
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) {
-        if (this.func === undefined) {
-            return this.invoke(input, options);
-        }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let returnValue;
         if (this.trace) {
-            returnValue = await this._callWithConfig(this.func, input, (0, runnables_1.mergeConfigs)(this.config, options));
+            returnValue = await this._callWithConfig(this._tracedInvoke, input, (0, runnables_1.mergeConfigs)(this.config, options));
         }
         else {
             returnValue = await this.func(input, (0, runnables_1.mergeConfigs)(this.config, options));
         }
-        // eslint-disable-next-line no-instanceof/no-instanceof
-        if (returnValue instanceof runnables_1.Runnable && this.recurse) {
+        if (runnables_1.Runnable.isRunnable(returnValue) && this.recurse) {
             return await returnValue.invoke(input, options);
         }
         return returnValue;

package/dist/utils.d.ts

@@ -1,3 +1,4 @@
+import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
 import { Runnable, RunnableConfig } from "@langchain/core/runnables";
 export interface RunnableCallableArgs extends Partial<any> {
     name?: string;
@@ -14,5 +15,6 @@ export declare class RunnableCallable<I = unknown, O = unknown> extends Runnable
     trace: boolean;
     recurse: boolean;
     constructor(fields: RunnableCallableArgs);
+    protected _tracedInvoke(input: I, config?: Partial<RunnableConfig>, runManager?: CallbackManagerForChainRun): Promise<O>;
     invoke(input: any, options?: Partial<RunnableConfig> | undefined): Promise<any>;
 }

package/dist/utils.js

@@ -1,4 +1,5 @@
-import { mergeConfigs, Runnable, } from "@langchain/core/runnables";
+import { mergeConfigs, patchConfig, Runnable, } from "@langchain/core/runnables";
+import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
 export class RunnableCallable extends Runnable {
     constructor(fields) {
         super();
@@ -45,24 +46,36 @@ export class RunnableCallable extends Runnable {
         this.trace = fields.trace ?? this.trace;
         this.recurse = fields.recurse ?? this.recurse;
     }
+    async _tracedInvoke(input, config, runManager) {
+        return new Promise((resolve, reject) => {
+            const childConfig = patchConfig(config, {
+                callbacks: runManager?.getChild(),
+            });
+            void AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
+                try {
+                    const output = await this.func(input, childConfig);
+                    resolve(output);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+    }
     async invoke(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input, options
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) {
-        if (this.func === undefined) {
-            return this.invoke(input, options);
-        }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let returnValue;
         if (this.trace) {
-            returnValue = await this._callWithConfig(this.func, input, mergeConfigs(this.config, options));
+            returnValue = await this._callWithConfig(this._tracedInvoke, input, mergeConfigs(this.config, options));
         }
         else {
             returnValue = await this.func(input, mergeConfigs(this.config, options));
         }
-        // eslint-disable-next-line no-instanceof/no-instanceof
-        if (returnValue instanceof Runnable && this.recurse) {
+        if (Runnable.isRunnable(returnValue) && this.recurse) {
             return await returnValue.invoke(input, options);
         }
         return returnValue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "description": "LangGraph",
   "type": "module",
   "engines": {