@langchain/langgraph 0.2.45 → 0.2.46

package/dist/graph/annotation.cjs

@@ -6,7 +6,6 @@ const last_value_js_1 = require("../channels/last_value.cjs");
 const base_js_1 = require("../managed/base.cjs");
 /**
  * Should not be instantiated directly. See {@link Annotation}.
- * @internal
  */
 class AnnotationRoot {
     constructor(s) {

package/dist/graph/annotation.d.ts

@@ -33,7 +33,6 @@ export interface AnnotationFunction {
 }
 /**
  * Should not be instantiated directly. See {@link Annotation}.
- * @internal
  */
 export declare class AnnotationRoot<SD extends StateDefinition> {
     lc_graph_name: string;

package/dist/graph/annotation.js

@@ -3,7 +3,6 @@ import { LastValue } from "../channels/last_value.js";
 import { isConfiguredManagedValue, } from "../managed/base.js";
 /**
  * Should not be instantiated directly. See {@link Annotation}.
- * @internal
  */
 export class AnnotationRoot {
     constructor(s) {

package/dist/graph/graph.cjs

@@ -220,7 +220,7 @@ class Graph {
         this.warnIfCompiled("Setting a finish point of a graph that has already been compiled. This will not be reflected in the compiled graph.");
         return this.addEdge(key, constants_js_1.END);
     }
-    compile({ checkpointer, interruptBefore, interruptAfter, } = {}) {
+    compile({ checkpointer, interruptBefore, interruptAfter, name, } = {}) {
         // validate the graph
         this.validate([
             ...(Array.isArray(interruptBefore) ? interruptBefore : []),
@@ -242,6 +242,7 @@ class Graph {
             outputChannels: constants_js_1.END,
             streamChannels: [],
             streamMode: "values",
+            name,
         });
         // attach nodes, edges and branches
         for (const [key, node] of Object.entries(this.nodes)) {

package/dist/graph/graph.d.ts

@@ -54,10 +54,11 @@ export declare class Graph<N extends string = typeof END, RunInput = any, RunOut
      * @deprecated use `addEdge(key, END)` instead
      */
     setFinishPoint(key: N): this;
-    compile({ checkpointer, interruptBefore, interruptAfter, }?: {
+    compile({ checkpointer, interruptBefore, interruptAfter, name, }?: {
         checkpointer?: BaseCheckpointSaver | false;
         interruptBefore?: N[] | All;
         interruptAfter?: N[] | All;
+        name?: string;
     }): CompiledGraph<N>;
     validate(interrupt?: string[]): void;
 }

package/dist/graph/graph.js

@@ -216,7 +216,7 @@ export class Graph {
         this.warnIfCompiled("Setting a finish point of a graph that has already been compiled. This will not be reflected in the compiled graph.");
         return this.addEdge(key, END);
     }
-    compile({ checkpointer, interruptBefore, interruptAfter, } = {}) {
+    compile({ checkpointer, interruptBefore, interruptAfter, name, } = {}) {
         // validate the graph
         this.validate([
             ...(Array.isArray(interruptBefore) ? interruptBefore : []),
@@ -238,6 +238,7 @@ export class Graph {
             outputChannels: END,
             streamChannels: [],
             streamMode: "values",
+            name,
         });
         // attach nodes, edges and branches
         for (const [key, node] of Object.entries(this.nodes)) {

package/dist/graph/state.cjs

@@ -270,7 +270,7 @@ class StateGraph extends graph_js_1.Graph {
         this.waitingEdges.add([startKey, endKey]);
         return this;
     }
-    compile({ checkpointer, store, interruptBefore, interruptAfter, } = {}) {
+    compile({ checkpointer, store, interruptBefore, interruptAfter, name, } = {}) {
         // validate the graph
         this.validate([
             ...(Array.isArray(interruptBefore) ? interruptBefore : []),
@@ -298,6 +298,7 @@ class StateGraph extends graph_js_1.Graph {
             streamChannels,
             streamMode: "updates",
             store,
+            name,
         });
         // attach nodes, edges and branches
         compiled.attachNode(constants_js_1.START);

package/dist/graph/state.d.ts

@@ -117,11 +117,12 @@ export declare class StateGraph<SD extends StateDefinition | unknown, S = SD ext
     _addSchema(stateDefinition: StateDefinition): void;
     addNode<K extends string, NodeInput = S>(key: K, action: RunnableLike<NodeInput, U extends object ? U & Record<string, any> : U, LangGraphRunnableConfig<StateType<C>>>, options?: StateGraphAddNodeOptions): StateGraph<SD, S, U, N | K, I, O, C>;
     addEdge(startKey: typeof START | N | N[], endKey: N | typeof END): this;
-    compile({ checkpointer, store, interruptBefore, interruptAfter, }?: {
+    compile({ checkpointer, store, interruptBefore, interruptAfter, name, }?: {
         checkpointer?: BaseCheckpointSaver | false;
         store?: BaseStore;
         interruptBefore?: N[] | All;
         interruptAfter?: N[] | All;
+        name?: string;
     }): CompiledStateGraph<S, U, N, I, O, C>;
 }
 /**

package/dist/graph/state.js

@@ -267,7 +267,7 @@ export class StateGraph extends Graph {
         this.waitingEdges.add([startKey, endKey]);
         return this;
     }
-    compile({ checkpointer, store, interruptBefore, interruptAfter, } = {}) {
+    compile({ checkpointer, store, interruptBefore, interruptAfter, name, } = {}) {
         // validate the graph
         this.validate([
             ...(Array.isArray(interruptBefore) ? interruptBefore : []),
@@ -295,6 +295,7 @@ export class StateGraph extends Graph {
             streamChannels,
             streamMode: "updates",
             store,
+            name,
         });
         // attach nodes, edges and branches
         compiled.attachNode(START);

package/dist/prebuilt/react_agent_executor.cjs

@@ -8,7 +8,7 @@ const tool_node_js_1 = require("./tool_node.cjs");
 const annotation_js_1 = require("../graph/annotation.cjs");
 const message_js_1 = require("../graph/message.cjs");
 const constants_js_1 = require("../constants.cjs");
-function _convertMessageModifierToStateModifier(messageModifier) {
+function _convertMessageModifierToPrompt(messageModifier) {
     // Handle string or SystemMessage
     if (typeof messageModifier === "string" ||
         ((0, messages_1.isBaseMessage)(messageModifier) && messageModifier._getType() === "system")) {
@@ -24,48 +24,99 @@ function _convertMessageModifierToStateModifier(messageModifier) {
     }
     throw new Error(`Unexpected type for messageModifier: ${typeof messageModifier}`);
 }
-function _getStateModifierRunnable(stateModifier) {
-    let stateModifierRunnable;
-    if (stateModifier == null) {
-        stateModifierRunnable = runnables_1.RunnableLambda.from((state) => state.messages).withConfig({ runName: "state_modifier" });
-    }
-    else if (typeof stateModifier === "string") {
-        const systemMessage = new messages_1.SystemMessage(stateModifier);
-        stateModifierRunnable = runnables_1.RunnableLambda.from((state) => {
+const PROMPT_RUNNABLE_NAME = "prompt";
+function _getPromptRunnable(prompt) {
+    let promptRunnable;
+    if (prompt == null) {
+        promptRunnable = runnables_1.RunnableLambda.from((state) => state.messages).withConfig({ runName: PROMPT_RUNNABLE_NAME });
+    }
+    else if (typeof prompt === "string") {
+        const systemMessage = new messages_1.SystemMessage(prompt);
+        promptRunnable = runnables_1.RunnableLambda.from((state) => {
             return [systemMessage, ...(state.messages ?? [])];
-        }).withConfig({ runName: "state_modifier" });
-    }
-    else if ((0, messages_1.isBaseMessage)(stateModifier) &&
-        stateModifier._getType() === "system") {
-        stateModifierRunnable = runnables_1.RunnableLambda.from((state) => [
-            stateModifier,
-            ...state.messages,
-        ]).withConfig({ runName: "state_modifier" });
-    }
-    else if (typeof stateModifier === "function") {
-        stateModifierRunnable = runnables_1.RunnableLambda.from(stateModifier).withConfig({
-            runName: "state_modifier",
+        }).withConfig({ runName: PROMPT_RUNNABLE_NAME });
+    }
+    else if ((0, messages_1.isBaseMessage)(prompt) && prompt._getType() === "system") {
+        promptRunnable = runnables_1.RunnableLambda.from((state) => [prompt, ...state.messages]).withConfig({ runName: PROMPT_RUNNABLE_NAME });
+    }
+    else if (typeof prompt === "function") {
+        promptRunnable = runnables_1.RunnableLambda.from(prompt).withConfig({
+            runName: PROMPT_RUNNABLE_NAME,
         });
     }
-    else if (runnables_1.Runnable.isRunnable(stateModifier)) {
-        stateModifierRunnable = stateModifier;
+    else if (runnables_1.Runnable.isRunnable(prompt)) {
+        promptRunnable = prompt;
     }
     else {
-        throw new Error(`Got unexpected type for 'stateModifier': ${typeof stateModifier}`);
+        throw new Error(`Got unexpected type for 'prompt': ${typeof prompt}`);
+    }
+    return promptRunnable;
+}
+function _getPrompt(prompt, stateModifier, messageModifier) {
+    // Check if multiple modifiers exist
+    const definedCount = [prompt, stateModifier, messageModifier].filter((x) => x != null).length;
+    if (definedCount > 1) {
+        throw new Error("Expected only one of prompt, stateModifier, or messageModifier, got multiple values");
+    }
+    let finalPrompt = prompt;
+    if (stateModifier != null) {
+        finalPrompt = stateModifier;
+    }
+    else if (messageModifier != null) {
+        finalPrompt = _convertMessageModifierToPrompt(messageModifier);
+    }
+    return _getPromptRunnable(finalPrompt);
+}
+function _shouldBindTools(llm, tools) {
+    if (!runnables_1.Runnable.isRunnable(llm) || !("kwargs" in llm)) {
+        return true;
+    }
+    if (!llm.kwargs ||
+        typeof llm.kwargs !== "object" ||
+        !("tools" in llm.kwargs)) {
+        return true;
     }
-    return stateModifierRunnable;
+    const boundTools = llm.kwargs.tools;
+    if (tools.length !== boundTools.length) {
+        throw new Error("Number of tools in the model.bindTools() and tools passed to createReactAgent must match");
+    }
+    const toolNames = new Set(tools.map((tool) => tool.name));
+    const boundToolNames = new Set();
+    for (const boundTool of boundTools) {
+        let boundToolName;
+        // OpenAI-style tool
+        if ("type" in boundTool && boundTool.type === "function") {
+            boundToolName = boundTool.function.name;
+        }
+        // Anthropic-style tool
+        else if ("name" in boundTool) {
+            boundToolName = boundTool.name;
+        }
+        // unknown tool type so we'll ignore it
+        else {
+            continue;
+        }
+        boundToolNames.add(boundToolName);
+    }
+    const missingTools = [...toolNames].filter((x) => !boundToolNames.has(x));
+    if (missingTools.length > 0) {
+        throw new Error(`Missing tools '${missingTools}' in the model.bindTools().` +
+            `Tools in the model.bindTools() must match the tools passed to createReactAgent.`);
+    }
+    return false;
 }
-function _getModelPreprocessingRunnable(stateModifier, messageModifier) {
-    // Check if both modifiers exist
-    if (stateModifier != null && messageModifier != null) {
-        throw new Error("Expected value for either stateModifier or messageModifier, got values for both");
+function _getModel(llm) {
+    // Get the underlying model from a RunnableBinding or return the model itself
+    let model = llm;
+    if (runnables_1.Runnable.isRunnable(llm) && "bound" in llm) {
+        model = llm.bound;
     }
-    // Convert message modifier to state modifier if necessary
-    if (stateModifier == null && messageModifier != null) {
-        // eslint-disable-next-line no-param-reassign
-        stateModifier = _convertMessageModifierToStateModifier(messageModifier);
+    if (!("invoke" in model &&
+        typeof model.invoke === "function" &&
+        "_modelType" in model)) {
+        throw new Error(`Expected \`llm\` to be a ChatModel or RunnableBinding (e.g. llm.bind_tools(...)) with invoke() and generate() methods, got ${model.constructor.name}`);
     }
-    return _getStateModifierRunnable(stateModifier);
+    return model;
 }
 const createReactAgentAnnotation = () => annotation_js_1.Annotation.Root({
     messages: (0, annotation_js_1.Annotation)({
@@ -118,7 +169,7 @@ exports.createReactAgentAnnotation = createReactAgentAnnotation;
  * ```
  */
 function createReactAgent(params) {
-    const { llm, tools, messageModifier, stateModifier, stateSchema, checkpointSaver, checkpointer, interruptBefore, interruptAfter, store, responseFormat, } = params;
+    const { llm, tools, messageModifier, stateModifier, prompt, stateSchema, checkpointSaver, checkpointer, interruptBefore, interruptAfter, store, responseFormat, name, } = params;
     let toolClasses;
     if (!Array.isArray(tools)) {
         toolClasses = tools.tools;
@@ -126,13 +177,17 @@ function createReactAgent(params) {
     else {
         toolClasses = tools;
     }
-    if (!("bindTools" in llm) || typeof llm.bindTools !== "function") {
-        throw new Error(`llm ${llm} must define bindTools method.`);
+    let modelWithTools;
+    if (_shouldBindTools(llm, toolClasses)) {
+        if (!("bindTools" in llm) || typeof llm.bindTools !== "function") {
+            throw new Error(`llm ${llm} must define bindTools method.`);
+        }
+        modelWithTools = llm.bindTools(toolClasses);
+    }
+    else {
+        modelWithTools = llm;
     }
-    const modelWithTools = llm.bindTools(toolClasses);
-    // we're passing store here for validation
-    const preprocessor = _getModelPreprocessingRunnable(stateModifier, messageModifier);
-    const modelRunnable = preprocessor.pipe(modelWithTools);
+    const modelRunnable = _getPrompt(prompt, stateModifier, messageModifier).pipe(modelWithTools);
     // If any of the tools are configured to return_directly after running,
     // our graph needs to check if these were called
     const shouldReturnDirect = new Set(toolClasses
@@ -161,11 +216,12 @@ function createReactAgent(params) {
             "prompt" in responseFormat &&
             "schema" in responseFormat) {
             const { prompt, schema } = responseFormat;
-            modelWithStructuredOutput = llm.withStructuredOutput(schema);
+            modelWithStructuredOutput = _getModel(llm).withStructuredOutput(schema);
             messages.unshift(new messages_1.SystemMessage({ content: prompt }));
         }
         else {
-            modelWithStructuredOutput = llm.withStructuredOutput(responseFormat);
+            modelWithStructuredOutput =
+                _getModel(llm).withStructuredOutput(responseFormat);
         }
         const response = await modelWithStructuredOutput.invoke(messages, config);
         return { structuredResponse: response };
@@ -219,6 +275,7 @@ function createReactAgent(params) {
         interruptBefore,
         interruptAfter,
         store,
+        name,
     });
 }
 exports.createReactAgent = createReactAgent;

package/dist/prebuilt/react_agent_executor.d.ts

@@ -1,7 +1,7 @@
-import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { LanguageModelLike } from "@langchain/core/language_models/base";
 import { BaseMessage, BaseMessageLike, SystemMessage } from "@langchain/core/messages";
 import { Runnable, RunnableToolLike } from "@langchain/core/runnables";
-import { StructuredToolInterface } from "@langchain/core/tools";
+import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";
 import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
 import { z } from "zod";
 import { CompiledStateGraph, AnnotationRoot } from "../graph/index.js";
@@ -19,8 +19,10 @@ export type StructuredResponseSchemaAndPrompt<StructuredResponseType> = {
     prompt: string;
     schema: z.ZodType<StructuredResponseType> | Record<string, any>;
 };
-export type StateModifier = SystemMessage | string | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => BaseMessageLike[]) | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => Promise<BaseMessageLike[]>) | Runnable;
-/** @deprecated Use StateModifier instead. */
+export type Prompt = SystemMessage | string | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => BaseMessageLike[]) | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => Promise<BaseMessageLike[]>) | Runnable;
+/** @deprecated Use Prompt instead. */
+export type StateModifier = Prompt;
+/** @deprecated Use Prompt instead. */
 export type MessageModifier = SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | ((messages: BaseMessage[]) => Promise<BaseMessage[]>) | Runnable;
 export declare const createReactAgentAnnotation: <T extends Record<string, any> = Record<string, any>>() => AnnotationRoot<{
     messages: import("../web.js").BinaryOperatorAggregate<BaseMessage[], Messages>;
@@ -32,63 +34,32 @@ export declare const createReactAgentAnnotation: <T extends Record<string, any>
 }>;
 export type CreateReactAgentParams<A extends AnnotationRoot<any> = AnnotationRoot<any>, StructuredResponseType = Record<string, any>> = {
     /** The chat model that can utilize OpenAI-style tool calling. */
-    llm: BaseChatModel;
+    llm: LanguageModelLike;
     /** A list of tools or a ToolNode. */
-    tools: ToolNode | (StructuredToolInterface | RunnableToolLike)[];
+    tools: ToolNode | (StructuredToolInterface | DynamicTool | RunnableToolLike)[];
     /**
-     * @deprecated
-     * Use stateModifier instead. stateModifier works the same as
-     * messageModifier in that it runs right before calling the chat model,
-     * but if passed as a function, it takes the full graph state as
-     * input whenever a tool is called rather than a list of messages.
-     *
-     * If a function is passed, it should return a list of messages to
-     * pass directly to the chat model.
-     *
-     * @example
-     * ```ts
-     * import { ChatOpenAI } from "@langchain/openai";
-     * import { MessagesAnnotation } from "@langchain/langgraph";
-     * import { createReactAgent } from "@langchain/langgraph/prebuilt";
-     * import { type BaseMessage, SystemMessage } from "@langchain/core/messages";
-     *
-     * const model = new ChatOpenAI({
-     *   model: "gpt-4o-mini",
-     * });
-     *
-     * const tools = [...];
-     *
-     * // Deprecated style with messageModifier
-     * const deprecated = createReactAgent({
-     *   llm,
-     *   tools,
-     *   messageModifier: async (messages: BaseMessage[]) => {
-     *     return [new SystemMessage("You are a pirate")].concat(messages);
-     *   }
-     * });
-     *
-     * // New style with stateModifier
-     * const agent = createReactAgent({
-     *   llm,
-     *   tools,
-     *   stateModifier: async (state: typeof MessagesAnnotation.State) => {
-     *     return [new SystemMessage("You are a pirate.")].concat(messages);
-     *   }
-     * });
-     * ```
+     * @deprecated Use prompt instead.
      */
     messageModifier?: MessageModifier;
     /**
-     * An optional state modifier. This takes full graph state BEFORE the LLM is called and prepares the input to LLM.
+     * @deprecated Use prompt instead.
+     */
+    stateModifier?: StateModifier;
+    /**
+     * An optional prompt for the LLM. This takes full graph state BEFORE the LLM is called and prepares the input to LLM.
      *
      * Can take a few different forms:
      *
-     * - SystemMessage: this is added to the beginning of the list of messages in state["messages"].
      * - str: This is converted to a SystemMessage and added to the beginning of the list of messages in state["messages"].
+     * - SystemMessage: this is added to the beginning of the list of messages in state["messages"].
      * - Function: This function should take in full graph state and the output is then passed to the language model.
      * - Runnable: This runnable should take in full graph state and the output is then passed to the language model.
+     *
+     * Note:
+     * Prior to `v0.2.46`, the prompt was set using `stateModifier` / `messagesModifier` parameters.
+     * This is now deprecated and will be removed in a future release.
      */
-    stateModifier?: StateModifier;
+    prompt?: Prompt;
     stateSchema?: A;
     /** An optional checkpoint saver to persist the agent's state. */
     checkpointSaver?: BaseCheckpointSaver;
@@ -112,6 +83,7 @@ export type CreateReactAgentParams<A extends AnnotationRoot<any> = AnnotationRoo
      *        The prompt will be used together with the model that is being used to generate the structured response.
      */
     responseFormat?: z.ZodType<StructuredResponseType> | StructuredResponseSchemaAndPrompt<StructuredResponseType> | Record<string, any>;
+    name?: string;
 };
 /**
  * Creates a StateGraph agent that relies on a chat model utilizing tool calling.

package/dist/prebuilt/react_agent_executor.js

@@ -5,7 +5,7 @@ import { ToolNode } from "./tool_node.js";
 import { Annotation } from "../graph/annotation.js";
 import { messagesStateReducer } from "../graph/message.js";
 import { END, START } from "../constants.js";
-function _convertMessageModifierToStateModifier(messageModifier) {
+function _convertMessageModifierToPrompt(messageModifier) {
     // Handle string or SystemMessage
     if (typeof messageModifier === "string" ||
         (isBaseMessage(messageModifier) && messageModifier._getType() === "system")) {
@@ -21,48 +21,99 @@ function _convertMessageModifierToStateModifier(messageModifier) {
     }
     throw new Error(`Unexpected type for messageModifier: ${typeof messageModifier}`);
 }
-function _getStateModifierRunnable(stateModifier) {
-    let stateModifierRunnable;
-    if (stateModifier == null) {
-        stateModifierRunnable = RunnableLambda.from((state) => state.messages).withConfig({ runName: "state_modifier" });
-    }
-    else if (typeof stateModifier === "string") {
-        const systemMessage = new SystemMessage(stateModifier);
-        stateModifierRunnable = RunnableLambda.from((state) => {
+const PROMPT_RUNNABLE_NAME = "prompt";
+function _getPromptRunnable(prompt) {
+    let promptRunnable;
+    if (prompt == null) {
+        promptRunnable = RunnableLambda.from((state) => state.messages).withConfig({ runName: PROMPT_RUNNABLE_NAME });
+    }
+    else if (typeof prompt === "string") {
+        const systemMessage = new SystemMessage(prompt);
+        promptRunnable = RunnableLambda.from((state) => {
             return [systemMessage, ...(state.messages ?? [])];
-        }).withConfig({ runName: "state_modifier" });
-    }
-    else if (isBaseMessage(stateModifier) &&
-        stateModifier._getType() === "system") {
-        stateModifierRunnable = RunnableLambda.from((state) => [
-            stateModifier,
-            ...state.messages,
-        ]).withConfig({ runName: "state_modifier" });
-    }
-    else if (typeof stateModifier === "function") {
-        stateModifierRunnable = RunnableLambda.from(stateModifier).withConfig({
-            runName: "state_modifier",
+        }).withConfig({ runName: PROMPT_RUNNABLE_NAME });
+    }
+    else if (isBaseMessage(prompt) && prompt._getType() === "system") {
+        promptRunnable = RunnableLambda.from((state) => [prompt, ...state.messages]).withConfig({ runName: PROMPT_RUNNABLE_NAME });
+    }
+    else if (typeof prompt === "function") {
+        promptRunnable = RunnableLambda.from(prompt).withConfig({
+            runName: PROMPT_RUNNABLE_NAME,
         });
     }
-    else if (Runnable.isRunnable(stateModifier)) {
-        stateModifierRunnable = stateModifier;
+    else if (Runnable.isRunnable(prompt)) {
+        promptRunnable = prompt;
     }
     else {
-        throw new Error(`Got unexpected type for 'stateModifier': ${typeof stateModifier}`);
+        throw new Error(`Got unexpected type for 'prompt': ${typeof prompt}`);
+    }
+    return promptRunnable;
+}
+function _getPrompt(prompt, stateModifier, messageModifier) {
+    // Check if multiple modifiers exist
+    const definedCount = [prompt, stateModifier, messageModifier].filter((x) => x != null).length;
+    if (definedCount > 1) {
+        throw new Error("Expected only one of prompt, stateModifier, or messageModifier, got multiple values");
+    }
+    let finalPrompt = prompt;
+    if (stateModifier != null) {
+        finalPrompt = stateModifier;
+    }
+    else if (messageModifier != null) {
+        finalPrompt = _convertMessageModifierToPrompt(messageModifier);
+    }
+    return _getPromptRunnable(finalPrompt);
+}
+function _shouldBindTools(llm, tools) {
+    if (!Runnable.isRunnable(llm) || !("kwargs" in llm)) {
+        return true;
+    }
+    if (!llm.kwargs ||
+        typeof llm.kwargs !== "object" ||
+        !("tools" in llm.kwargs)) {
+        return true;
     }
-    return stateModifierRunnable;
+    const boundTools = llm.kwargs.tools;
+    if (tools.length !== boundTools.length) {
+        throw new Error("Number of tools in the model.bindTools() and tools passed to createReactAgent must match");
+    }
+    const toolNames = new Set(tools.map((tool) => tool.name));
+    const boundToolNames = new Set();
+    for (const boundTool of boundTools) {
+        let boundToolName;
+        // OpenAI-style tool
+        if ("type" in boundTool && boundTool.type === "function") {
+            boundToolName = boundTool.function.name;
+        }
+        // Anthropic-style tool
+        else if ("name" in boundTool) {
+            boundToolName = boundTool.name;
+        }
+        // unknown tool type so we'll ignore it
+        else {
+            continue;
+        }
+        boundToolNames.add(boundToolName);
+    }
+    const missingTools = [...toolNames].filter((x) => !boundToolNames.has(x));
+    if (missingTools.length > 0) {
+        throw new Error(`Missing tools '${missingTools}' in the model.bindTools().` +
+            `Tools in the model.bindTools() must match the tools passed to createReactAgent.`);
+    }
+    return false;
 }
-function _getModelPreprocessingRunnable(stateModifier, messageModifier) {
-    // Check if both modifiers exist
-    if (stateModifier != null && messageModifier != null) {
-        throw new Error("Expected value for either stateModifier or messageModifier, got values for both");
+function _getModel(llm) {
+    // Get the underlying model from a RunnableBinding or return the model itself
+    let model = llm;
+    if (Runnable.isRunnable(llm) && "bound" in llm) {
+        model = llm.bound;
     }
-    // Convert message modifier to state modifier if necessary
-    if (stateModifier == null && messageModifier != null) {
-        // eslint-disable-next-line no-param-reassign
-        stateModifier = _convertMessageModifierToStateModifier(messageModifier);
+    if (!("invoke" in model &&
+        typeof model.invoke === "function" &&
+        "_modelType" in model)) {
+        throw new Error(`Expected \`llm\` to be a ChatModel or RunnableBinding (e.g. llm.bind_tools(...)) with invoke() and generate() methods, got ${model.constructor.name}`);
     }
-    return _getStateModifierRunnable(stateModifier);
+    return model;
 }
 export const createReactAgentAnnotation = () => Annotation.Root({
     messages: Annotation({
@@ -114,7 +165,7 @@ export const createReactAgentAnnotation = () => Annotation.Root({
  * ```
  */
 export function createReactAgent(params) {
-    const { llm, tools, messageModifier, stateModifier, stateSchema, checkpointSaver, checkpointer, interruptBefore, interruptAfter, store, responseFormat, } = params;
+    const { llm, tools, messageModifier, stateModifier, prompt, stateSchema, checkpointSaver, checkpointer, interruptBefore, interruptAfter, store, responseFormat, name, } = params;
     let toolClasses;
     if (!Array.isArray(tools)) {
         toolClasses = tools.tools;
@@ -122,13 +173,17 @@ export function createReactAgent(params) {
     else {
         toolClasses = tools;
     }
-    if (!("bindTools" in llm) || typeof llm.bindTools !== "function") {
-        throw new Error(`llm ${llm} must define bindTools method.`);
+    let modelWithTools;
+    if (_shouldBindTools(llm, toolClasses)) {
+        if (!("bindTools" in llm) || typeof llm.bindTools !== "function") {
+            throw new Error(`llm ${llm} must define bindTools method.`);
+        }
+        modelWithTools = llm.bindTools(toolClasses);
+    }
+    else {
+        modelWithTools = llm;
     }
-    const modelWithTools = llm.bindTools(toolClasses);
-    // we're passing store here for validation
-    const preprocessor = _getModelPreprocessingRunnable(stateModifier, messageModifier);
-    const modelRunnable = preprocessor.pipe(modelWithTools);
+    const modelRunnable = _getPrompt(prompt, stateModifier, messageModifier).pipe(modelWithTools);
     // If any of the tools are configured to return_directly after running,
     // our graph needs to check if these were called
     const shouldReturnDirect = new Set(toolClasses
@@ -157,11 +212,12 @@ export function createReactAgent(params) {
             "prompt" in responseFormat &&
             "schema" in responseFormat) {
             const { prompt, schema } = responseFormat;
-            modelWithStructuredOutput = llm.withStructuredOutput(schema);
+            modelWithStructuredOutput = _getModel(llm).withStructuredOutput(schema);
             messages.unshift(new SystemMessage({ content: prompt }));
         }
         else {
-            modelWithStructuredOutput = llm.withStructuredOutput(responseFormat);
+            modelWithStructuredOutput =
+                _getModel(llm).withStructuredOutput(responseFormat);
         }
         const response = await modelWithStructuredOutput.invoke(messages, config);
         return { structuredResponse: response };
@@ -215,5 +271,6 @@ export function createReactAgent(params) {
         interruptBefore,
         interruptAfter,
         store,
+        name,
     });
 }

package/dist/pregel/index.cjs

@@ -208,6 +208,7 @@ class Pregel extends runnables_1.Runnable {
         this.retryPolicy = fields.retryPolicy;
         this.config = fields.config;
         this.store = fields.store;
+        this.name = fields.name;
         if (this.autoValidate) {
             this.validate();
         }

package/dist/pregel/index.js

@@ -204,6 +204,7 @@ export class Pregel extends Runnable {
         this.retryPolicy = fields.retryPolicy;
         this.config = fields.config;
         this.store = fields.store;
+        this.name = fields.name;
         if (this.autoValidate) {
             this.validate();
         }

package/dist/pregel/messages.cjs

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamMessagesHandler = void 0;
-const uuid_1 = require("uuid");
 const base_1 = require("@langchain/core/callbacks/base");
 const messages_1 = require("@langchain/core/messages");
 const constants_js_1 = require("../constants.cjs");
@@ -47,6 +46,12 @@ class StreamMessagesHandler extends base_1.BaseCallbackHandler {
             writable: true,
             value: {}
         });
+        Object.defineProperty(this, "stableMessageIdMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
         Object.defineProperty(this, "lc_prefer_streaming", {
             enumerable: true,
             configurable: true,
@@ -55,18 +60,26 @@ class StreamMessagesHandler extends base_1.BaseCallbackHandler {
         });
         this.streamFn = streamFn;
     }
-    _emit(meta, message, dedupe = false) {
+    _emit(meta, message, runId, dedupe = false) {
         if (dedupe &&
             message.id !== undefined &&
             this.seen[message.id] !== undefined) {
             return;
         }
-        if (message.id === undefined) {
-            const id = (0, uuid_1.v4)();
+        // For instance in ChatAnthropic, the first chunk has an message ID
+        // but the subsequent chunks do not. To avoid clients seeing two messages
+        // we rename the message ID if it's being auto-set to `run-${runId}`
+        // (see https://github.com/langchain-ai/langchainjs/pull/6646).
+        let messageId = message.id;
+        if (messageId == null || messageId === `run-${runId}`) {
+            messageId = this.stableMessageIdMap[runId] ?? messageId ?? `run-${runId}`;
+        }
+        this.stableMessageIdMap[runId] ??= messageId;
+        if (messageId !== message.id) {
             // eslint-disable-next-line no-param-reassign
-            message.id = id;
+            message.id = messageId;
             // eslint-disable-next-line no-param-reassign
-            message.lc_kwargs.id = id;
+            message.lc_kwargs.id = messageId;
         }
         this.seen[message.id] = message;
         this.streamFn([meta[0], "messages", [message, meta[1]]]);
@@ -86,12 +99,10 @@ class StreamMessagesHandler extends base_1.BaseCallbackHandler {
         this.emittedChatModelRunIds[runId] = true;
         if (this.metadatas[runId] !== undefined) {
             if (isChatGenerationChunk(chunk)) {
-                this._emit(this.metadatas[runId], chunk.message);
+                this._emit(this.metadatas[runId], chunk.message, runId);
             }
             else {
-                this._emit(this.metadatas[runId], new messages_1.AIMessageChunk({
-                    content: token,
-                }));
+                this._emit(this.metadatas[runId], new messages_1.AIMessageChunk({ content: token }), runId);
             }
         }
     }
@@ -100,11 +111,12 @@ class StreamMessagesHandler extends base_1.BaseCallbackHandler {
         if (!this.emittedChatModelRunIds[runId]) {
             const chatGeneration = output.generations?.[0]?.[0];
             if ((0, messages_1.isBaseMessage)(chatGeneration?.message)) {
-                this._emit(this.metadatas[runId], chatGeneration?.message, true);
+                this._emit(this.metadatas[runId], chatGeneration?.message, runId, true);
             }
             delete this.emittedChatModelRunIds[runId];
         }
         delete this.metadatas[runId];
+        delete this.stableMessageIdMap[runId];
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     handleLLMError(_err, runId) {
@@ -125,24 +137,24 @@ class StreamMessagesHandler extends base_1.BaseCallbackHandler {
         delete this.metadatas[runId];
         if (metadata !== undefined) {
             if ((0, messages_1.isBaseMessage)(outputs)) {
-                this._emit(metadata, outputs, true);
+                this._emit(metadata, outputs, runId, true);
             }
             else if (Array.isArray(outputs)) {
                 for (const value of outputs) {
                     if ((0, messages_1.isBaseMessage)(value)) {
-                        this._emit(metadata, value, true);
+                        this._emit(metadata, value, runId, true);
                     }
                 }
             }
             else if (outputs != null && typeof outputs === "object") {
                 for (const value of Object.values(outputs)) {
                     if ((0, messages_1.isBaseMessage)(value)) {
-                        this._emit(metadata, value, true);
+                        this._emit(metadata, value, runId, true);
                     }
                     else if (Array.isArray(value)) {
                         for (const item of value) {
                             if ((0, messages_1.isBaseMessage)(item)) {
-                                this._emit(metadata, item, true);
+                                this._emit(metadata, item, runId, true);
                             }
                         }
                     }

package/dist/pregel/messages.d.ts

@@ -15,9 +15,10 @@ export declare class StreamMessagesHandler extends BaseCallbackHandler {
     metadatas: Record<string, Meta>;
     seen: Record<string, BaseMessage>;
     emittedChatModelRunIds: Record<string, boolean>;
+    stableMessageIdMap: Record<string, string>;
     lc_prefer_streaming: boolean;
     constructor(streamFn: (streamChunk: StreamChunk) => void);
-    _emit(meta: Meta, message: BaseMessage, dedupe?: boolean): void;
+    _emit(meta: Meta, message: BaseMessage, runId: string, dedupe?: boolean): void;
     handleChatModelStart(_llm: Serialized, _messages: BaseMessage[][], runId: string, _parentRunId?: string, _extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>, name?: string): void;
     handleLLMNewToken(token: string, _idx: NewTokenIndices, runId: string, _parentRunId?: string, _tags?: string[], fields?: HandleLLMNewTokenCallbackFields): void;
     handleLLMEnd(output: LLMResult, runId: string): void;

package/dist/pregel/messages.js

@@ -1,4 +1,3 @@
-import { v4 } from "uuid";
 import { BaseCallbackHandler, } from "@langchain/core/callbacks/base";
 import { AIMessageChunk, isBaseMessage, } from "@langchain/core/messages";
 import { TAG_HIDDEN, TAG_NOSTREAM } from "../constants.js";
@@ -44,6 +43,12 @@ export class StreamMessagesHandler extends BaseCallbackHandler {
             writable: true,
             value: {}
         });
+        Object.defineProperty(this, "stableMessageIdMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
         Object.defineProperty(this, "lc_prefer_streaming", {
             enumerable: true,
             configurable: true,
@@ -52,18 +57,26 @@ export class StreamMessagesHandler extends BaseCallbackHandler {
         });
         this.streamFn = streamFn;
     }
-    _emit(meta, message, dedupe = false) {
+    _emit(meta, message, runId, dedupe = false) {
         if (dedupe &&
             message.id !== undefined &&
             this.seen[message.id] !== undefined) {
             return;
         }
-        if (message.id === undefined) {
-            const id = v4();
+        // For instance in ChatAnthropic, the first chunk has an message ID
+        // but the subsequent chunks do not. To avoid clients seeing two messages
+        // we rename the message ID if it's being auto-set to `run-${runId}`
+        // (see https://github.com/langchain-ai/langchainjs/pull/6646).
+        let messageId = message.id;
+        if (messageId == null || messageId === `run-${runId}`) {
+            messageId = this.stableMessageIdMap[runId] ?? messageId ?? `run-${runId}`;
+        }
+        this.stableMessageIdMap[runId] ??= messageId;
+        if (messageId !== message.id) {
             // eslint-disable-next-line no-param-reassign
-            message.id = id;
+            message.id = messageId;
             // eslint-disable-next-line no-param-reassign
-            message.lc_kwargs.id = id;
+            message.lc_kwargs.id = messageId;
         }
         this.seen[message.id] = message;
         this.streamFn([meta[0], "messages", [message, meta[1]]]);
@@ -83,12 +96,10 @@ export class StreamMessagesHandler extends BaseCallbackHandler {
         this.emittedChatModelRunIds[runId] = true;
         if (this.metadatas[runId] !== undefined) {
             if (isChatGenerationChunk(chunk)) {
-                this._emit(this.metadatas[runId], chunk.message);
+                this._emit(this.metadatas[runId], chunk.message, runId);
             }
             else {
-                this._emit(this.metadatas[runId], new AIMessageChunk({
-                    content: token,
-                }));
+                this._emit(this.metadatas[runId], new AIMessageChunk({ content: token }), runId);
             }
         }
     }
@@ -97,11 +108,12 @@ export class StreamMessagesHandler extends BaseCallbackHandler {
         if (!this.emittedChatModelRunIds[runId]) {
             const chatGeneration = output.generations?.[0]?.[0];
             if (isBaseMessage(chatGeneration?.message)) {
-                this._emit(this.metadatas[runId], chatGeneration?.message, true);
+                this._emit(this.metadatas[runId], chatGeneration?.message, runId, true);
             }
             delete this.emittedChatModelRunIds[runId];
         }
         delete this.metadatas[runId];
+        delete this.stableMessageIdMap[runId];
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     handleLLMError(_err, runId) {
@@ -122,24 +134,24 @@ export class StreamMessagesHandler extends BaseCallbackHandler {
         delete this.metadatas[runId];
         if (metadata !== undefined) {
             if (isBaseMessage(outputs)) {
-                this._emit(metadata, outputs, true);
+                this._emit(metadata, outputs, runId, true);
             }
             else if (Array.isArray(outputs)) {
                 for (const value of outputs) {
                     if (isBaseMessage(value)) {
-                        this._emit(metadata, value, true);
+                        this._emit(metadata, value, runId, true);
                     }
                 }
             }
             else if (outputs != null && typeof outputs === "object") {
                 for (const value of Object.values(outputs)) {
                     if (isBaseMessage(value)) {
-                        this._emit(metadata, value, true);
+                        this._emit(metadata, value, runId, true);
                     }
                     else if (Array.isArray(value)) {
                         for (const item of value) {
                             if (isBaseMessage(item)) {
-                                this._emit(metadata, item, true);
+                                this._emit(metadata, item, runId, true);
                             }
                         }
                     }

package/dist/pregel/remote.cjs

@@ -41,18 +41,13 @@ const getStreamModes = (streamMode, defaultStreamMode = "updates") => {
     if (streamMode !== undefined &&
         (typeof streamMode === "string" ||
             (Array.isArray(streamMode) && streamMode.length > 0))) {
-        if (typeof streamMode === "string") {
-            updatedStreamModes.push(streamMode);
-        }
-        else {
-            reqSingle = false;
-            updatedStreamModes.push(...streamMode);
-        }
+        reqSingle = typeof streamMode === "string";
+        const mapped = Array.isArray(streamMode) ? streamMode : [streamMode];
+        updatedStreamModes.push(...mapped);
     }
     else {
         updatedStreamModes.push(defaultStreamMode);
     }
-    // TODO: Map messages to messages-tuple
     if (updatedStreamModes.includes("updates")) {
         reqUpdates = true;
     }
@@ -303,7 +298,11 @@ class RemoteGraph extends runnables_1.Runnable {
                 ...updatedStreamModes,
                 ...(streamProtocolInstance?.modes ?? new Set()),
             ]),
-        ];
+        ].map((mode) => {
+            if (mode === "messages")
+                return "messages-tuple";
+            return mode;
+        });
         let command;
         let serializedInput;
         if ((0, constants_js_1.isCommand)(input)) {

package/dist/pregel/remote.js

@@ -38,18 +38,13 @@ const getStreamModes = (streamMode, defaultStreamMode = "updates") => {
     if (streamMode !== undefined &&
         (typeof streamMode === "string" ||
             (Array.isArray(streamMode) && streamMode.length > 0))) {
-        if (typeof streamMode === "string") {
-            updatedStreamModes.push(streamMode);
-        }
-        else {
-            reqSingle = false;
-            updatedStreamModes.push(...streamMode);
-        }
+        reqSingle = typeof streamMode === "string";
+        const mapped = Array.isArray(streamMode) ? streamMode : [streamMode];
+        updatedStreamModes.push(...mapped);
     }
     else {
         updatedStreamModes.push(defaultStreamMode);
     }
-    // TODO: Map messages to messages-tuple
     if (updatedStreamModes.includes("updates")) {
         reqUpdates = true;
     }
@@ -300,7 +295,11 @@ export class RemoteGraph extends Runnable {
                 ...updatedStreamModes,
                 ...(streamProtocolInstance?.modes ?? new Set()),
             ]),
-        ];
+        ].map((mode) => {
+            if (mode === "messages")
+                return "messages-tuple";
+            return mode;
+        });
         let command;
         let serializedInput;
         if (isCommand(input)) {

package/dist/web.d.ts

@@ -5,7 +5,7 @@ export type { Pregel } from "./pregel/index.js";
 export * from "./errors.js";
 export { BaseChannel, type BinaryOperator, BinaryOperatorAggregate, type AnyValue, type WaitForNames, type DynamicBarrierValue, type LastValue, type NamedBarrierValue, type Topic, } from "./channels/index.js";
 export type { EphemeralValue } from "./channels/ephemeral_value.js";
-export { type AnnotationRoot as _INTERNAL_ANNOTATION_ROOT } from "./graph/index.js";
+export { type AnnotationRoot } from "./graph/index.js";
 export { type RetryPolicy } from "./pregel/utils/index.js";
 export { Send, Command, type CommandParams, isCommand, START, END, type Interrupt, } from "./constants.js";
 export { MemorySaver, type Checkpoint, type CheckpointMetadata, type CheckpointTuple, copyCheckpoint, emptyCheckpoint, BaseCheckpointSaver, type Item, type GetOperation, type SearchOperation, type PutOperation, type Operation, type OperationResults, BaseStore, AsyncBatchedStore, InMemoryStore, type NameSpacePath, type NamespaceMatchType, type MatchCondition, type ListNamespacesOperation, } from "@langchain/langgraph-checkpoint";

package/package.json

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