@langchain/langgraph 0.2.45 → 0.2.47

package/dist/func/index.cjs

@@ -12,11 +12,6 @@ const utils_js_1 = require("../utils.cjs");
 /**
  * Define a LangGraph task using the `task` function.
  *
- * !!! warning "Beta"
- *     The Functional API is currently in beta and is subject to change.
- *
- * @beta
- *
  * Tasks can only be called from within an {@link entrypoint} or from within a StateGraph.
  * A task can be called like a regular function with the following differences:
  *
@@ -75,11 +70,6 @@ exports.task = task;
 /**
  * Define a LangGraph workflow using the `entrypoint` function.
  *
- * !!! warning "Beta"
- *     The Functional API is currently in beta and is subject to change.
- *
- * @beta
- *
  * ### Function signature
  *
  * The wrapped function must accept at most **two parameters**. The first parameter
@@ -251,11 +241,6 @@ exports.entrypoint.final = function final({ value, save, }) {
  * This function allows workflows to access state that was saved in previous runs
  * using {@link entrypoint.final}.
  *
- * !!! warning "Beta"
- *     The Functional API is currently in beta and is subject to change.
- *
- * @beta
- *
  * @typeParam StateT - The type of the state that was previously saved
  * @returns The previous saved state from the last invocation of the current thread
  *

package/dist/func/index.d.ts

@@ -8,35 +8,21 @@ import { LastValue } from "../channels/last_value.js";
 import { EntrypointFinal, EntrypointReturnT, EntrypointFinalSaveT, EntrypointFunc, TaskFunc } from "./types.js";
 /**
  * Options for the {@link task} function
- *
- * !!! warning "Beta"
- *     The Functional API is currently in beta and is subject to change.
- *
- * @beta
  */
 export type TaskOptions = {
     /**
      * The name of the task, analogous to the node name in {@link StateGraph}.
-     *
-     * @beta
      */
     name: string;
     /**
      * The retry policy for the task. Configures how many times and under what conditions
      * the task should be retried if it fails.
-     *
-     * @beta
      */
     retry?: RetryPolicy;
 };
 /**
  * Define a LangGraph task using the `task` function.
  *
- * !!! warning "Beta"
- *     The Functional API is currently in beta and is subject to change.
- *
- * @beta
- *
  * Tasks can only be called from within an {@link entrypoint} or from within a StateGraph.
  * A task can be called like a regular function with the following differences:
  *
@@ -83,31 +69,20 @@ export type TaskOptions = {
 export declare function task<ArgsT extends unknown[], OutputT>(optionsOrName: TaskOptions | string, func: TaskFunc<ArgsT, OutputT>): (...args: ArgsT) => Promise<OutputT>;
 /**
  * Options for the {@link entrypoint} function
- *
- * !!! warning "Beta"
- *     The Functional API is currently in beta and is subject to change.
- *
- * @beta
  */
 export type EntrypointOptions = {
     /**
      * The name of the {@link entrypoint}, analogous to the node name in {@link StateGraph}.
      * This name is used for logging, debugging, and checkpoint identification.
-     *
-     * @beta
      */
     name: string;
     /**
      * The checkpointer for the {@link entrypoint}. Used to save and restore state between
      * invocations of the workflow.
-     *
-     * @beta
      */
     checkpointer?: BaseCheckpointSaver;
     /**
      * The store for the {@link entrypoint}. Used to persist data across workflow runs.
-     *
-     * @beta
      */
     store?: BaseStore;
 };
@@ -125,11 +100,6 @@ export interface EntrypointFunction {
      * as well as a separate state value to persist to the checkpoint. This allows workflows
      * to maintain state between runs while returning different values to the caller.
      *
-     * !!! warning "Beta"
-     *     The Functional API is currently in beta and is subject to change.
-     *
-     * @beta
-     *
      * @typeParam ValueT - The type of the value to return to the caller
      * @typeParam SaveT - The type of the state to save to the checkpoint
      * @param value - The value to return to the caller
@@ -152,11 +122,6 @@ export interface EntrypointFunction {
 /**
  * Define a LangGraph workflow using the `entrypoint` function.
  *
- * !!! warning "Beta"
- *     The Functional API is currently in beta and is subject to change.
- *
- * @beta
- *
  * ### Function signature
  *
  * The wrapped function must accept at most **two parameters**. The first parameter
@@ -293,11 +258,6 @@ export declare const entrypoint: EntrypointFunction;
  * This function allows workflows to access state that was saved in previous runs
  * using {@link entrypoint.final}.
  *
- * !!! warning "Beta"
- *     The Functional API is currently in beta and is subject to change.
- *
- * @beta
- *
  * @typeParam StateT - The type of the state that was previously saved
  * @returns The previous saved state from the last invocation of the current thread
  *

package/dist/func/index.js

@@ -9,11 +9,6 @@ import { isAsyncGeneratorFunction, isGeneratorFunction } from "../utils.js";
 /**
  * Define a LangGraph task using the `task` function.
  *
- * !!! warning "Beta"
- *     The Functional API is currently in beta and is subject to change.
- *
- * @beta
- *
  * Tasks can only be called from within an {@link entrypoint} or from within a StateGraph.
  * A task can be called like a regular function with the following differences:
  *
@@ -71,11 +66,6 @@ export function task(optionsOrName, func) {
 /**
  * Define a LangGraph workflow using the `entrypoint` function.
  *
- * !!! warning "Beta"
- *     The Functional API is currently in beta and is subject to change.
- *
- * @beta
- *
  * ### Function signature
  *
  * The wrapped function must accept at most **two parameters**. The first parameter
@@ -247,11 +237,6 @@ entrypoint.final = function final({ value, save, }) {
  * This function allows workflows to access state that was saved in previous runs
  * using {@link entrypoint.final}.
  *
- * !!! warning "Beta"
- *     The Functional API is currently in beta and is subject to change.
- *
- * @beta
- *
  * @typeParam StateT - The type of the state that was previously saved
  * @returns The previous saved state from the last invocation of the current thread
  *

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/index.cjs

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toolsCondition = exports.ToolNode = exports.ToolExecutor = exports.createReactAgent = exports.createFunctionCallingExecutor = exports.createAgentExecutor = void 0;
+exports.toolsCondition = exports.ToolNode = exports.ToolExecutor = exports.createReactAgentAnnotation = exports.createReactAgent = exports.createFunctionCallingExecutor = exports.createAgentExecutor = void 0;
 var agent_executor_js_1 = require("./agent_executor.cjs");
 Object.defineProperty(exports, "createAgentExecutor", { enumerable: true, get: function () { return agent_executor_js_1.createAgentExecutor; } });
 var chat_agent_executor_js_1 = require("./chat_agent_executor.cjs");
 Object.defineProperty(exports, "createFunctionCallingExecutor", { enumerable: true, get: function () { return chat_agent_executor_js_1.createFunctionCallingExecutor; } });
 var react_agent_executor_js_1 = require("./react_agent_executor.cjs");
 Object.defineProperty(exports, "createReactAgent", { enumerable: true, get: function () { return react_agent_executor_js_1.createReactAgent; } });
+Object.defineProperty(exports, "createReactAgentAnnotation", { enumerable: true, get: function () { return react_agent_executor_js_1.createReactAgentAnnotation; } });
 var tool_executor_js_1 = require("./tool_executor.cjs");
 Object.defineProperty(exports, "ToolExecutor", { enumerable: true, get: function () { return tool_executor_js_1.ToolExecutor; } });
 var tool_node_js_1 = require("./tool_node.cjs");

package/dist/prebuilt/index.d.ts

@@ -1,6 +1,6 @@
 export { type AgentExecutorState, createAgentExecutor, } from "./agent_executor.js";
 export { type FunctionCallingExecutorState, createFunctionCallingExecutor, } from "./chat_agent_executor.js";
-export { type AgentState, type CreateReactAgentParams, createReactAgent, } from "./react_agent_executor.js";
+export { type AgentState, type CreateReactAgentParams, createReactAgent, createReactAgentAnnotation, } from "./react_agent_executor.js";
 export { type ToolExecutorArgs, type ToolInvocationInterface, ToolExecutor, } from "./tool_executor.js";
 export { ToolNode, toolsCondition, type ToolNodeOptions } from "./tool_node.js";
 export type { HumanInterruptConfig, ActionRequest, HumanInterrupt, HumanResponse, } from "./interrupt.js";

package/dist/prebuilt/index.js

@@ -1,5 +1,5 @@
 export { createAgentExecutor, } from "./agent_executor.js";
 export { createFunctionCallingExecutor, } from "./chat_agent_executor.js";
-export { createReactAgent, } from "./react_agent_executor.js";
+export { createReactAgent, createReactAgentAnnotation, } from "./react_agent_executor.js";
 export { ToolExecutor, } from "./tool_executor.js";
 export { ToolNode, toolsCondition } from "./tool_node.js";

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,18 +216,22 @@ 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 };
     };
     const callModel = async (state, config) => {
         // TODO: Auto-promote streaming.
-        return { messages: [await modelRunnable.invoke(state, config)] };
+        const response = (await modelRunnable.invoke(state, config));
+        // add agent name to the AIMessage
+        response.name = name;
+        return { messages: [response] };
     };
     const workflow = new index_js_1.StateGraph(stateSchema ?? (0, exports.createReactAgentAnnotation)())
         .addNode("agent", callModel)
@@ -219,6 +278,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.