@langchain/langgraph 1.0.12 → 1.0.13

package/dist/prebuilt/react_agent_executor.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react_agent_executor.d.cts","names":["_langchain_core_messages17","_langchain_core_language_models_chat_models0","___web_js1","BaseChatModel","LanguageModelLike","BaseMessage","BaseMessageLike","SystemMessage","Runnable","RunnableToolLike","RunnableSequence","RunnableBinding","RunnableLike","DynamicTool","StructuredToolInterface","InteropZodObject","InteropZodType","All","BaseCheckpointSaver","BaseStore","CompiledStateGraph","AnnotationRoot","MessagesAnnotation","ToolNode","LangGraphRunnableConfig","Runtime","Messages","START","InteropZodToStateDefinition","AgentState","Record","StructuredResponseType","N","StructuredResponseSchemaOptions","ServerTool","ClientTool","ConfigurableModelInterface","Promise","_shouldBindTools","_bindTools","_langchain_core_language_models_base0","BaseLanguageModelInput","MessageToolSet","MessageStructure","AIMessageChunk","BaseChatModelCallOptions","_getModel","Prompt","State","StateModifier","MessageModifier","createReactAgentAnnotation","MessageType","BinaryOperatorAggregate","T","LastValue","SingleReducer","StateDefinition","S","PreHookAnnotation","AnyAnnotationRoot","ToAnnotationRoot","A","CreateReactAgentParams","C","createReactAgent","StructuredResponseFormat","spec","ReturnType"],"sources":["../../src/prebuilt/react_agent_executor.d.ts"],"sourcesContent":["import { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { BaseMessage, BaseMessageLike, SystemMessage } from \"@langchain/core/messages\";\nimport { Runnable, RunnableToolLike, RunnableSequence, RunnableBinding, type RunnableLike } from \"@langchain/core/runnables\";\nimport { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport { All, BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport { type CompiledStateGraph, AnnotationRoot } from \"../graph/index.js\";\nimport { MessagesAnnotation } from \"../graph/messages_annotation.js\";\nimport { ToolNode } from \"./tool_node.js\";\nimport { LangGraphRunnableConfig, Runtime } from \"../pregel/runnable_types.js\";\nimport { Messages } from \"../graph/message.js\";\nimport { START } from \"../constants.js\";\nimport type { InteropZodToStateDefinition } from \"../graph/zod/meta.js\";\n/**\n * @deprecated `AgentState` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { AgentState } from \"langchain\";`\n */\nexport interface AgentState<StructuredResponseType extends Record<string, any> = Record<string, any>> {\n    messages: BaseMessage[];\n    structuredResponse: StructuredResponseType;\n}\nexport type N = typeof START | \"agent\" | \"tools\";\ntype StructuredResponseSchemaOptions<StructuredResponseType> = {\n    schema: InteropZodType<StructuredResponseType> | Record<string, any>;\n    prompt?: string;\n    strict?: boolean;\n    [key: string]: unknown;\n};\ntype ServerTool = Record<string, unknown>;\ntype ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;\ninterface ConfigurableModelInterface {\n    _queuedMethodOperations: Record<string, any>;\n    _model: () => Promise<BaseChatModel>;\n}\nexport declare function _shouldBindTools(llm: LanguageModelLike, tools: (ClientTool | ServerTool)[]): Promise<boolean>;\nexport declare function _bindTools(llm: LanguageModelLike, toolClasses: (ClientTool | ServerTool)[]): Promise<Runnable<import(\"@langchain/core/language_models/base\").BaseLanguageModelInput, import(\"@langchain/core/messages\").AIMessageChunk<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>>, import(\"@langchain/core/language_models/chat_models\").BaseChatModelCallOptions> | RunnableBinding<any, any, any> | RunnableSequence<any, any>>;\nexport declare function _getModel(llm: LanguageModelLike | ConfigurableModelInterface): Promise<LanguageModelLike>;\nexport type Prompt = SystemMessage | string | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => BaseMessageLike[]) | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => Promise<BaseMessageLike[]>) | Runnable;\n/** @deprecated Use Prompt instead. */\nexport type StateModifier = Prompt;\n/** @deprecated Use Prompt instead. */\nexport type MessageModifier = SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | ((messages: BaseMessage[]) => Promise<BaseMessage[]>) | Runnable;\nexport declare const createReactAgentAnnotation: <T extends Record<string, any> = Record<string, any>>() => AnnotationRoot<{\n    messages: import(\"../web.js\").BinaryOperatorAggregate<BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[], Messages>;\n    structuredResponse: {\n        (): import(\"../web.js\").LastValue<T>;\n        (annotation: import(\"../web.js\").SingleReducer<T, T>): import(\"../web.js\").BinaryOperatorAggregate<T, T>;\n        Root: <S extends import(\"../web.js\").StateDefinition>(sd: S) => AnnotationRoot<S>;\n    };\n}>;\ndeclare const PreHookAnnotation: AnnotationRoot<{\n    llmInputMessages: import(\"../web.js\").BinaryOperatorAggregate<BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[], Messages>;\n}>;\ntype PreHookAnnotation = typeof PreHookAnnotation;\ntype AnyAnnotationRoot = AnnotationRoot<any>;\ntype ToAnnotationRoot<A extends AnyAnnotationRoot | InteropZodObject> = A extends AnyAnnotationRoot ? A : A extends InteropZodObject ? AnnotationRoot<InteropZodToStateDefinition<A>> : never;\n/**\n * @deprecated `CreateReactAgentParams` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { CreateAgentParams } from \"langchain\";`\n */\nexport type CreateReactAgentParams<A extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, StructuredResponseType extends Record<string, any> = Record<string, any>, C extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = {\n    /** The chat model that can utilize OpenAI-style tool calling. */\n    llm: LanguageModelLike | ((state: ToAnnotationRoot<A>[\"State\"] & PreHookAnnotation[\"State\"], runtime: Runtime<ToAnnotationRoot<C>[\"State\"]>) => Promise<LanguageModelLike> | LanguageModelLike);\n    /** A list of tools or a ToolNode. */\n    tools: ToolNode | (ServerTool | ClientTool)[];\n    /**\n     * @deprecated Use prompt instead.\n     */\n    messageModifier?: MessageModifier;\n    /**\n     * @deprecated Use prompt instead.\n     */\n    stateModifier?: StateModifier;\n    /**\n     * An optional prompt for the LLM. This takes full graph state BEFORE the LLM is called and prepares the input to LLM.\n     *\n     * Can take a few different forms:\n     *\n     * - str: This is converted to a SystemMessage and added to the beginning of the list of messages in state[\"messages\"].\n     * - SystemMessage: this is added to the beginning of the list of messages in state[\"messages\"].\n     * - Function: This function should take in full graph state and the output is then passed to the language model.\n     * - Runnable: This runnable should take in full graph state and the output is then passed to the language model.\n     *\n     * Note:\n     * Prior to `v0.2.46`, the prompt was set using `stateModifier` / `messagesModifier` parameters.\n     * This is now deprecated and will be removed in a future release.\n     */\n    prompt?: Prompt;\n    /**\n     * Additional state schema for the agent.\n     */\n    stateSchema?: A;\n    /**\n     * An optional schema for the context.\n     */\n    contextSchema?: C;\n    /** An optional checkpoint saver to persist the agent's state. */\n    checkpointSaver?: BaseCheckpointSaver | boolean;\n    /** An optional checkpoint saver to persist the agent's state. Alias of \"checkpointSaver\". */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /** An optional list of node names to interrupt before running. */\n    interruptBefore?: N[] | All;\n    /** An optional list of node names to interrupt after running. */\n    interruptAfter?: N[] | All;\n    store?: BaseStore;\n    /**\n     * An optional schema for the final agent output.\n     *\n     * If provided, output will be formatted to match the given schema and returned in the 'structuredResponse' state key.\n     * If not provided, `structuredResponse` will not be present in the output state.\n     *\n     * Can be passed in as:\n     *   - Zod schema\n     *   - JSON schema\n     *   - { prompt, schema }, where schema is one of the above.\n     *        The prompt will be used together with the model that is being used to generate the structured response.\n     *\n     * @remarks\n     * **Important**: `responseFormat` requires the model to support `.withStructuredOutput()`.\n     *\n     * **Note**: The graph will make a separate call to the LLM to generate the structured response after the agent loop is finished.\n     * This is not the only strategy to get structured responses, see more options in [this guide](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output/).\n     */\n    responseFormat?: InteropZodType<StructuredResponseType> | StructuredResponseSchemaOptions<StructuredResponseType> | Record<string, any>;\n    /**\n     * An optional name for the agent.\n     */\n    name?: string;\n    /**\n     * An optional description for the agent.\n     * This can be used to describe the agent to the underlying supervisor LLM.\n     */\n    description?: string | undefined;\n    /**\n     * Use to specify how to expose the agent name to the underlying supervisor LLM.\n  \n        - undefined: Relies on the LLM provider {@link AIMessage#name}. Currently, only OpenAI supports this.\n        - `\"inline\"`: Add the agent name directly into the content field of the {@link AIMessage} using XML-style tags.\n            Example: `\"How can I help you\"` -> `\"<name>agent_name</name><content>How can I help you?</content>\"`\n     */\n    includeAgentName?: \"inline\" | undefined;\n    /**\n     * An optional node to add before the `agent` node (i.e., the node that calls the LLM).\n     * Useful for managing long message histories (e.g., message trimming, summarization, etc.).\n     */\n    preModelHook?: RunnableLike<ToAnnotationRoot<A>[\"State\"] & PreHookAnnotation[\"State\"], ToAnnotationRoot<A>[\"Update\"] & PreHookAnnotation[\"Update\"], LangGraphRunnableConfig>;\n    /**\n     * An optional node to add after the `agent` node (i.e., the node that calls the LLM).\n     * Useful for implementing human-in-the-loop, guardrails, validation, or other post-processing.\n     */\n    postModelHook?: RunnableLike<ToAnnotationRoot<A>[\"State\"], ToAnnotationRoot<A>[\"Update\"], LangGraphRunnableConfig>;\n    /**\n     * Determines the version of the graph to create.\n     *\n     * Can be one of\n     * - `\"v1\"`: The tool node processes a single message. All tool calls in the message are\n     *           executed in parallel within the tool node.\n     * - `\"v2\"`: The tool node processes a single tool call. Tool calls are distributed across\n     *           multiple instances of the tool node using the Send API.\n     *\n     * @default `\"v1\"`\n     */\n    version?: \"v1\" | \"v2\";\n};\n/**\n * @deprecated `createReactAgent` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { createAgent } from \"langchain\";`\n *\n * Creates a StateGraph agent that relies on a chat model utilizing tool calling.\n *\n * @example\n * ```ts\n * import { ChatOpenAI } from \"@langchain/openai\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n * import { createReactAgent } from \"@langchain/langgraph/prebuilt\";\n *\n * const model = new ChatOpenAI({\n *   model: \"gpt-4o\",\n * });\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   })\n * })\n *\n * const agent = createReactAgent({ llm: model, tools: [getWeather] });\n *\n * const inputs = {\n *   messages: [{ role: \"user\", content: \"what is the weather in SF?\" }],\n * };\n *\n * const stream = await agent.stream(inputs, { streamMode: \"values\" });\n *\n * for await (const { messages } of stream) {\n *   console.log(messages);\n * }\n * // Returns the messages in the state at each step of execution\n * ```\n */\nexport declare function createReactAgent<A extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, StructuredResponseFormat extends Record<string, any> = Record<string, any>, C extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateReactAgentParams<A, StructuredResponseFormat, C>): CompiledStateGraph<ToAnnotationRoot<A>[\"State\"], ToAnnotationRoot<A>[\"Update\"], any, typeof MessagesAnnotation.spec & ToAnnotationRoot<A>[\"spec\"], ReturnType<typeof createReactAgentAnnotation<StructuredResponseFormat>>[\"spec\"] & ToAnnotationRoot<A>[\"spec\"]>;\nexport {};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;UAkBiB6B,0CAA0CC,sBAAsBA;EAAhED,QAAAA,EACHxB,WADa,EAAA;EAAA,kBAAA,EAEH0B,sBAFG;;AAAsDD,KAIrEE,CAAAA,GAJqEF,OAI1DH,KAJ0DG,GAAAA,OAAAA,GAAAA,OAAAA;KAK5EG,+BAJS5B,CAAAA,sBAAAA,CAAAA,GAAAA;QACU0B,EAIZf,cAJYe,CAIGA,sBAJHA,CAAAA,GAI6BD,MAJ7BC,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAAsB,MAAA,CAAA,EAAA,MAAA;EAElCC,MAAC,CAAA,EAAA,OAAUL;EAClBM,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAAAA,OAAAA;CAA+B;KAM/BC,UAAAA,GAAaJ,MALSC,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;KAMtBI,UAAAA,GAAarB,uBANNE,GAMgCH,WANhCG,GAM8CP,gBAN9CO;AAM8CP,KAQ9CsC,MAAAA,GAASxC,aARqCE,GAAAA,MAAAA,GAAAA,CAAAA,CAAAA,KAAAA,EAAAA,OAQIa,kBAAAA,CAAmB0B,KARvBvC,EAAAA,MAAAA,EAQsCe,uBARtCf,EAAAA,GAQkEH,eARlEG,EAAAA,CAAAA,GAAAA,CAAAA,CAAAA,KAAAA,EAAAA,OAQuGa,kBAAAA,CAAmB0B,KAR1HvC,EAAAA,MAAAA,EAQyIe,uBARzIf,EAAAA,GAQqK4B,OARrK5B,CAQ6KH,eAR7KG,EAAAA,CAAAA,CAAAA,GAQmMD,QARnMC;;AAQ9CsC,KAEAE,aAAAA,GAAgBF,MAFV;;AAAGxC,KAIT2C,eAAAA,GAAkB3C,aAJTA,GAAAA,MAAAA,GAAAA,CAAAA,CAAAA,QAAAA,EAI8CF,WAJ9CE,EAAAA,EAAAA,GAIgEF,WAJhEE,EAAAA,CAAAA,GAAAA,CAAAA,CAAAA,QAAAA,EAI6FF,WAJ7FE,EAAAA,EAAAA,GAI+G8B,OAJ/G9B,CAIuHF,WAJvHE,EAAAA,CAAAA,CAAAA,GAIyIC,QAJzID;AAAyCe,cAKzC6B,0BAL4DH,EAAAA,CAAAA,UAKrBlB,MALqBkB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAKClB,MALDkB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,CAAAA,GAAAA,GAK2B3B,cAL3B2B,CAAAA;UAAexB,EAMyItB,uBANzIsB,CAMtCnB,WANsCmB,CAM2ExB,0BAAAA,CAAlE2C,gBANTnB,CAKRxB,0BAAAA,CACqE0C,cAAAA,CAN7DlB,EAMyBxB,0BAAAA,CAAwFoD,WAAAA,CANjH5B,EAAAA,EAMiIE,QANjIF,CAAAA;oBAA4BlB,EAAAA;IAAqCgB,EAAAA,EAQtHpB,SARyI8C,CAQ1IM,CAR0IN,CAAAA;IAAexB,CAAAA,UAAAA,EASxItB,aATwIsB,CAS5I8B,CAT4I9B,EASzI8B,CATyI9B,CAAAA,CAAAA,EASpFtB,uBAToFsB,CASxF8B,CATwF9B,EASrF8B,CATqF9B,CAAAA;IAAoClB,IAAAA,EAAAA,CAAAA,UAS7HJ,eAT6HI,CAAAA,CAAAA,EAAAA,EAUrKoD,CAVqKpD,EAAAA,GAU/Je,cAV+Jf,CAUhJoD,CAVgJpD,CAAAA;;;cAazNqD,iBAbuP,EAapOtC,cAboO,CAAA;EAEzP4B,gBAAa,EAYwN/C,uBAZ/M,CAYgCG,WAZhC,CAYiJL,0BAAAA,CAAlE2C,gBAZ/E,CAahC3C,0BAAAA,CADmK0C,cAAAA,CAZnI,EAY+F1C,0BAAAA,CAAwFoD,WAAAA,CAZvL,EAAA,EAYuM1B,QAZvM,CAAA;AAElC,CAAA,CAAA;KAYKiC,iBAAAA,GAZsB,OAYKA,iBAZL;KAatBC,iBAAAA,GAAoBvC,cAbKd,CAAAA,GAAAA,CAAAA;KAczBsD,gBAd8DxD,CAAAA,UAcnCuD,iBAdmCvD,GAcfU,gBAdeV,CAAAA,GAcKyD,CAdLzD,SAceuD,iBAdfvD,GAcmCyD,CAdnCzD,GAcuCyD,CAdvCzD,SAciDU,gBAdjDV,GAcoEgB,cAdpEhB,CAcmFuB,2BAdnFvB,CAc+GyD,CAd/GzD,CAAAA,CAAAA,GAAAA,KAAAA;;;;;AAA2FG,KAmBlJuD,sBAnBkJvD,CAAAA,UAmBjHoD,iBAnBiHpD,GAmB7FO,gBAnB6FP,GAmB1EoD,iBAnB0EpD,EAAAA,+BAmBxBsB,MAnBwBtB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAmBFsB,MAnBEtB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAAAA,UAmB6BoD,iBAnB7BpD,GAmBiDO,gBAnBjDP,GAmBoEoD,iBAnBpEpD,CAAAA,GAAAA;EAAQ;EACjJ2C,GAAAA,EAoBZ/C,iBApBY+C,GAAAA,CAAAA,CAAAA,KAOnB,EAaoCU,gBAbpC,CAaqDC,CAbrD,CAAA,CAAA,OAAA,CAAA,GAamEH,iBAbnE,CAAA,OAAA,CAAA,EAAA,OAAA,EAawGlC,OAbxG,CAagHoC,gBAbhH,CAaiIG,CAbjI,CAAA,CAAA,OAAA,CAAA,CAAA,EAAA,GAakJ3B,OAblJ,CAa0JjC,iBAb1J,CAAA,GAa+KA,iBAb/K,CAAA;EAAA;OAP0D0B,EAsBjDP,QAtBiDO,GAAAA,CAsBrCI,UAtBqCJ,GAsBxBK,UAtBwBL,CAAAA,EAAAA;;;;iBAC6D9B,CAAAA,EAyBnGkD,eAzB2LE;;;;eAEvKE,CAAAA,EA2BtBL,aA3BsBK;;;;;;;;;;;;;;AAIvC;EAGD,MAAA,CAAA,EAmCWP,MAnCX;;;;aADgE1C,CAAAA,EAwChDyD,CAxCgDzD;;;;EADnB,aAAA,CAAA,EA6C3B2D,CA7C2B;EAG1CL;EACAC,eAAAA,CAAAA,EA2CiB1C,mBA3CGG,GAAAA,OAAc;EAClCwC;EAAgB,YAAA,CAAA,EA4CF3C,mBA5CE,GAAA,OAAA;;iBAA+BH,CAAAA,EA8C9BiB,CA9C8BjB,EAAAA,GA8CxBE,GA9CwBF;;gBAA8B6C,CAAAA,EAgD7D5B,CAhD6D4B,EAAAA,GAgDvD3C,GAhDuD2C;OAAoBE,CAAAA,EAiD1F3C,SAjD0F2C;;;;;;;AAKtG;;;;;;;;;;;;gBAEsCD,CAAAA,EA6DjB7C,cA7DiB6C,CA6DF9B,sBA7DE8B,CAAAA,GA6DwB5B,+BA7DxB4B,CA6DwD9B,sBA7DxD8B,CAAAA,GA6DkF/B,MA7DlF+B,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;;;;MAAoEpC,CAAAA,EAAAA,MAAAA;;;;;aAEnFS,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;;;;;;;kBAmCJhB,CAAAA,EAAAA,QAAAA,GAAAA,SAAAA;;;;;cAKPC,CAAAA,EAyCOP,YAzCPO,CAyCoB0C,gBAzCpB1C,CAyCqC2C,CAzCrC3C,CAAAA,CAAAA,OAAAA,CAAAA,GAyCmDwC,iBAzCnDxC,CAAAA,OAAAA,CAAAA,EAyC+E0C,gBAzC/E1C,CAyCgG2C,CAzChG3C,CAAAA,CAAAA,QAAAA,CAAAA,GAyC+GwC,iBAzC/GxC,CAAAA,QAAAA,CAAAA,EAyC4IK,uBAzC5IL,CAAAA;;;;;eAmB4GW,CAAAA,EA2BpGlB,YA3BoGkB,CA2BvF+B,gBA3BuF/B,CA2BtEgC,CA3BsEhC,CAAAA,CAAAA,OAAAA,CAAAA,EA2BzD+B,gBA3ByD/B,CA2BxCgC,CA3BwChC,CAAAA,CAAAA,QAAAA,CAAAA,EA2B1BN,uBA3B0BM,CAAAA;;;;;;;;;;;;SA2BzD+B,CAAAA,EAAAA,IAAAA,GAAAA,IAAAA;;;;AA2D/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAwBI,2BAA2BL,oBAAoB7C,0BAA0BO,qDAAqDQ,sBAAsBA,+BAA+B8B,oBAAoB7C,mBAAmB6C,2BAA2BG,uBAAuBD,GAAGI,0BAA0BF,KAAK5C,mBAAmByC,iBAAiBC,aAAaD,iBAAiBC,0BAA0BxC,kBAAAA,CAAmB6C,OAAON,iBAAiBC,YAAYM,kBAAkBjB,2BAA2Be,qCAAqCL,iBAAiBC"}

package/dist/prebuilt/react_agent_executor.d.ts

@@ -0,0 +1,211 @@
+import { BinaryOperatorAggregate } from "../channels/binop.js";
+import { LastValue } from "../channels/last_value.js";
+import { InteropZodToStateDefinition } from "../graph/zod/meta.js";
+import { LangGraphRunnableConfig, Runtime } from "../pregel/runnable_types.js";
+import { AnnotationRoot, SingleReducer, StateDefinition } from "../graph/annotation.js";
+import { START } from "../constants.js";
+import { CompiledStateGraph } from "../graph/state.js";
+import { Messages } from "../graph/message.js";
+import { MessagesAnnotation } from "../graph/messages_annotation.js";
+import { ToolNode } from "./tool_node.js";
+import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
+import { Runnable, RunnableBinding, RunnableLike, RunnableSequence, RunnableToolLike } from "@langchain/core/runnables";
+import * as _langchain_core_messages17 from "@langchain/core/messages";
+import { BaseMessage, BaseMessageLike, SystemMessage } from "@langchain/core/messages";
+import { InteropZodObject, InteropZodType } from "@langchain/core/utils/types";
+import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";
+import { LanguageModelLike } from "@langchain/core/language_models/base";
+
+//#region src/prebuilt/react_agent_executor.d.ts
+/**
+ * @deprecated `AgentState` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.
+ * Update your import to `import { AgentState } from "langchain";`
+ */
+interface AgentState<StructuredResponseType extends Record<string, any> = Record<string, any>> {
+  messages: BaseMessage[];
+  structuredResponse: StructuredResponseType;
+}
+type N = typeof START | "agent" | "tools";
+type StructuredResponseSchemaOptions<StructuredResponseType> = {
+  schema: InteropZodType<StructuredResponseType> | Record<string, any>;
+  prompt?: string;
+  strict?: boolean;
+  [key: string]: unknown;
+};
+type ServerTool = Record<string, unknown>;
+type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;
+type Prompt = SystemMessage | string | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => BaseMessageLike[]) | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => Promise<BaseMessageLike[]>) | Runnable;
+/** @deprecated Use Prompt instead. */
+type StateModifier = Prompt;
+/** @deprecated Use Prompt instead. */
+type MessageModifier = SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | ((messages: BaseMessage[]) => Promise<BaseMessage[]>) | Runnable;
+declare const createReactAgentAnnotation: <T extends Record<string, any> = Record<string, any>>() => AnnotationRoot<{
+  messages: BinaryOperatorAggregate<BaseMessage<_langchain_core_messages17.MessageStructure<_langchain_core_messages17.MessageToolSet>, _langchain_core_messages17.MessageType>[], Messages>;
+  structuredResponse: {
+    (): LastValue<T>;
+    (annotation: SingleReducer<T, T>): BinaryOperatorAggregate<T, T>;
+    Root: <S extends StateDefinition>(sd: S) => AnnotationRoot<S>;
+  };
+}>;
+declare const PreHookAnnotation: AnnotationRoot<{
+  llmInputMessages: BinaryOperatorAggregate<BaseMessage<_langchain_core_messages17.MessageStructure<_langchain_core_messages17.MessageToolSet>, _langchain_core_messages17.MessageType>[], Messages>;
+}>;
+type PreHookAnnotation = typeof PreHookAnnotation;
+type AnyAnnotationRoot = AnnotationRoot<any>;
+type ToAnnotationRoot<A extends AnyAnnotationRoot | InteropZodObject> = A extends AnyAnnotationRoot ? A : A extends InteropZodObject ? AnnotationRoot<InteropZodToStateDefinition<A>> : never;
+/**
+ * @deprecated `CreateReactAgentParams` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.
+ * Update your import to `import { CreateAgentParams } from "langchain";`
+ */
+type CreateReactAgentParams<A extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, StructuredResponseType extends Record<string, any> = Record<string, any>, C extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = {
+  /** The chat model that can utilize OpenAI-style tool calling. */
+  llm: LanguageModelLike | ((state: ToAnnotationRoot<A>["State"] & PreHookAnnotation["State"], runtime: Runtime<ToAnnotationRoot<C>["State"]>) => Promise<LanguageModelLike> | LanguageModelLike);
+  /** A list of tools or a ToolNode. */
+  tools: ToolNode | (ServerTool | ClientTool)[];
+  /**
+   * @deprecated Use prompt instead.
+   */
+  messageModifier?: MessageModifier;
+  /**
+   * @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:
+   *
+   * - 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.
+   */
+  prompt?: Prompt;
+  /**
+   * Additional state schema for the agent.
+   */
+  stateSchema?: A;
+  /**
+   * An optional schema for the context.
+   */
+  contextSchema?: C;
+  /** An optional checkpoint saver to persist the agent's state. */
+  checkpointSaver?: BaseCheckpointSaver | boolean;
+  /** An optional checkpoint saver to persist the agent's state. Alias of "checkpointSaver". */
+  checkpointer?: BaseCheckpointSaver | boolean;
+  /** An optional list of node names to interrupt before running. */
+  interruptBefore?: N[] | All;
+  /** An optional list of node names to interrupt after running. */
+  interruptAfter?: N[] | All;
+  store?: BaseStore;
+  /**
+   * An optional schema for the final agent output.
+   *
+   * If provided, output will be formatted to match the given schema and returned in the 'structuredResponse' state key.
+   * If not provided, `structuredResponse` will not be present in the output state.
+   *
+   * Can be passed in as:
+   *   - Zod schema
+   *   - JSON schema
+   *   - { prompt, schema }, where schema is one of the above.
+   *        The prompt will be used together with the model that is being used to generate the structured response.
+   *
+   * @remarks
+   * **Important**: `responseFormat` requires the model to support `.withStructuredOutput()`.
+   *
+   * **Note**: The graph will make a separate call to the LLM to generate the structured response after the agent loop is finished.
+   * This is not the only strategy to get structured responses, see more options in [this guide](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output/).
+   */
+  responseFormat?: InteropZodType<StructuredResponseType> | StructuredResponseSchemaOptions<StructuredResponseType> | Record<string, any>;
+  /**
+   * An optional name for the agent.
+   */
+  name?: string;
+  /**
+   * An optional description for the agent.
+   * This can be used to describe the agent to the underlying supervisor LLM.
+   */
+  description?: string | undefined;
+  /**
+   * Use to specify how to expose the agent name to the underlying supervisor LLM.
+         - undefined: Relies on the LLM provider {@link AIMessage#name}. Currently, only OpenAI supports this.
+      - `"inline"`: Add the agent name directly into the content field of the {@link AIMessage} using XML-style tags.
+          Example: `"How can I help you"` -> `"<name>agent_name</name><content>How can I help you?</content>"`
+   */
+  includeAgentName?: "inline" | undefined;
+  /**
+   * An optional node to add before the `agent` node (i.e., the node that calls the LLM).
+   * Useful for managing long message histories (e.g., message trimming, summarization, etc.).
+   */
+  preModelHook?: RunnableLike<ToAnnotationRoot<A>["State"] & PreHookAnnotation["State"], ToAnnotationRoot<A>["Update"] & PreHookAnnotation["Update"], LangGraphRunnableConfig>;
+  /**
+   * An optional node to add after the `agent` node (i.e., the node that calls the LLM).
+   * Useful for implementing human-in-the-loop, guardrails, validation, or other post-processing.
+   */
+  postModelHook?: RunnableLike<ToAnnotationRoot<A>["State"], ToAnnotationRoot<A>["Update"], LangGraphRunnableConfig>;
+  /**
+   * Determines the version of the graph to create.
+   *
+   * Can be one of
+   * - `"v1"`: The tool node processes a single message. All tool calls in the message are
+   *           executed in parallel within the tool node.
+   * - `"v2"`: The tool node processes a single tool call. Tool calls are distributed across
+   *           multiple instances of the tool node using the Send API.
+   *
+   * @default `"v1"`
+   */
+  version?: "v1" | "v2";
+};
+/**
+ * @deprecated `createReactAgent` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.
+ * Update your import to `import { createAgent } from "langchain";`
+ *
+ * Creates a StateGraph agent that relies on a chat model utilizing tool calling.
+ *
+ * @example
+ * ```ts
+ * import { ChatOpenAI } from "@langchain/openai";
+ * import { tool } from "@langchain/core/tools";
+ * import { z } from "zod";
+ * import { createReactAgent } from "@langchain/langgraph/prebuilt";
+ *
+ * const model = new ChatOpenAI({
+ *   model: "gpt-4o",
+ * });
+ *
+ * const getWeather = tool((input) => {
+ *   if (["sf", "san francisco"].includes(input.location.toLowerCase())) {
+ *     return "It's 60 degrees and foggy.";
+ *   } else {
+ *     return "It's 90 degrees and sunny.";
+ *   }
+ * }, {
+ *   name: "get_weather",
+ *   description: "Call to get the current weather.",
+ *   schema: z.object({
+ *     location: z.string().describe("Location to get the weather for."),
+ *   })
+ * })
+ *
+ * const agent = createReactAgent({ llm: model, tools: [getWeather] });
+ *
+ * const inputs = {
+ *   messages: [{ role: "user", content: "what is the weather in SF?" }],
+ * };
+ *
+ * const stream = await agent.stream(inputs, { streamMode: "values" });
+ *
+ * for await (const { messages } of stream) {
+ *   console.log(messages);
+ * }
+ * // Returns the messages in the state at each step of execution
+ * ```
+ */
+declare function createReactAgent<A extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, StructuredResponseFormat extends Record<string, any> = Record<string, any>, C extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateReactAgentParams<A, StructuredResponseFormat, C>): CompiledStateGraph<ToAnnotationRoot<A>["State"], ToAnnotationRoot<A>["Update"], any, typeof MessagesAnnotation.spec & ToAnnotationRoot<A>["spec"], ReturnType<typeof createReactAgentAnnotation<StructuredResponseFormat>>["spec"] & ToAnnotationRoot<A>["spec"]>;
+//#endregion
+export { AgentState, CreateReactAgentParams, createReactAgent, createReactAgentAnnotation };
+//# sourceMappingURL=react_agent_executor.d.ts.map

package/dist/prebuilt/react_agent_executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react_agent_executor.d.ts","names":["_langchain_core_messages17","_langchain_core_language_models_chat_models0","___web_js1","BaseChatModel","LanguageModelLike","BaseMessage","BaseMessageLike","SystemMessage","Runnable","RunnableToolLike","RunnableSequence","RunnableBinding","RunnableLike","DynamicTool","StructuredToolInterface","InteropZodObject","InteropZodType","All","BaseCheckpointSaver","BaseStore","CompiledStateGraph","AnnotationRoot","MessagesAnnotation","ToolNode","LangGraphRunnableConfig","Runtime","Messages","START","InteropZodToStateDefinition","AgentState","Record","StructuredResponseType","N","StructuredResponseSchemaOptions","ServerTool","ClientTool","ConfigurableModelInterface","Promise","_shouldBindTools","_bindTools","_langchain_core_language_models_base0","BaseLanguageModelInput","MessageToolSet","MessageStructure","AIMessageChunk","BaseChatModelCallOptions","_getModel","Prompt","State","StateModifier","MessageModifier","createReactAgentAnnotation","MessageType","BinaryOperatorAggregate","T","LastValue","SingleReducer","StateDefinition","S","PreHookAnnotation","AnyAnnotationRoot","ToAnnotationRoot","A","CreateReactAgentParams","C","createReactAgent","StructuredResponseFormat","spec","ReturnType"],"sources":["../../src/prebuilt/react_agent_executor.d.ts"],"sourcesContent":["import { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { BaseMessage, BaseMessageLike, SystemMessage } from \"@langchain/core/messages\";\nimport { Runnable, RunnableToolLike, RunnableSequence, RunnableBinding, type RunnableLike } from \"@langchain/core/runnables\";\nimport { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport { All, BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport { type CompiledStateGraph, AnnotationRoot } from \"../graph/index.js\";\nimport { MessagesAnnotation } from \"../graph/messages_annotation.js\";\nimport { ToolNode } from \"./tool_node.js\";\nimport { LangGraphRunnableConfig, Runtime } from \"../pregel/runnable_types.js\";\nimport { Messages } from \"../graph/message.js\";\nimport { START } from \"../constants.js\";\nimport type { InteropZodToStateDefinition } from \"../graph/zod/meta.js\";\n/**\n * @deprecated `AgentState` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { AgentState } from \"langchain\";`\n */\nexport interface AgentState<StructuredResponseType extends Record<string, any> = Record<string, any>> {\n    messages: BaseMessage[];\n    structuredResponse: StructuredResponseType;\n}\nexport type N = typeof START | \"agent\" | \"tools\";\ntype StructuredResponseSchemaOptions<StructuredResponseType> = {\n    schema: InteropZodType<StructuredResponseType> | Record<string, any>;\n    prompt?: string;\n    strict?: boolean;\n    [key: string]: unknown;\n};\ntype ServerTool = Record<string, unknown>;\ntype ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;\ninterface ConfigurableModelInterface {\n    _queuedMethodOperations: Record<string, any>;\n    _model: () => Promise<BaseChatModel>;\n}\nexport declare function _shouldBindTools(llm: LanguageModelLike, tools: (ClientTool | ServerTool)[]): Promise<boolean>;\nexport declare function _bindTools(llm: LanguageModelLike, toolClasses: (ClientTool | ServerTool)[]): Promise<Runnable<import(\"@langchain/core/language_models/base\").BaseLanguageModelInput, import(\"@langchain/core/messages\").AIMessageChunk<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>>, import(\"@langchain/core/language_models/chat_models\").BaseChatModelCallOptions> | RunnableBinding<any, any, any> | RunnableSequence<any, any>>;\nexport declare function _getModel(llm: LanguageModelLike | ConfigurableModelInterface): Promise<LanguageModelLike>;\nexport type Prompt = SystemMessage | string | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => BaseMessageLike[]) | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => Promise<BaseMessageLike[]>) | Runnable;\n/** @deprecated Use Prompt instead. */\nexport type StateModifier = Prompt;\n/** @deprecated Use Prompt instead. */\nexport type MessageModifier = SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | ((messages: BaseMessage[]) => Promise<BaseMessage[]>) | Runnable;\nexport declare const createReactAgentAnnotation: <T extends Record<string, any> = Record<string, any>>() => AnnotationRoot<{\n    messages: import(\"../web.js\").BinaryOperatorAggregate<BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[], Messages>;\n    structuredResponse: {\n        (): import(\"../web.js\").LastValue<T>;\n        (annotation: import(\"../web.js\").SingleReducer<T, T>): import(\"../web.js\").BinaryOperatorAggregate<T, T>;\n        Root: <S extends import(\"../web.js\").StateDefinition>(sd: S) => AnnotationRoot<S>;\n    };\n}>;\ndeclare const PreHookAnnotation: AnnotationRoot<{\n    llmInputMessages: import(\"../web.js\").BinaryOperatorAggregate<BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[], Messages>;\n}>;\ntype PreHookAnnotation = typeof PreHookAnnotation;\ntype AnyAnnotationRoot = AnnotationRoot<any>;\ntype ToAnnotationRoot<A extends AnyAnnotationRoot | InteropZodObject> = A extends AnyAnnotationRoot ? A : A extends InteropZodObject ? AnnotationRoot<InteropZodToStateDefinition<A>> : never;\n/**\n * @deprecated `CreateReactAgentParams` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { CreateAgentParams } from \"langchain\";`\n */\nexport type CreateReactAgentParams<A extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, StructuredResponseType extends Record<string, any> = Record<string, any>, C extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = {\n    /** The chat model that can utilize OpenAI-style tool calling. */\n    llm: LanguageModelLike | ((state: ToAnnotationRoot<A>[\"State\"] & PreHookAnnotation[\"State\"], runtime: Runtime<ToAnnotationRoot<C>[\"State\"]>) => Promise<LanguageModelLike> | LanguageModelLike);\n    /** A list of tools or a ToolNode. */\n    tools: ToolNode | (ServerTool | ClientTool)[];\n    /**\n     * @deprecated Use prompt instead.\n     */\n    messageModifier?: MessageModifier;\n    /**\n     * @deprecated Use prompt instead.\n     */\n    stateModifier?: StateModifier;\n    /**\n     * An optional prompt for the LLM. This takes full graph state BEFORE the LLM is called and prepares the input to LLM.\n     *\n     * Can take a few different forms:\n     *\n     * - str: This is converted to a SystemMessage and added to the beginning of the list of messages in state[\"messages\"].\n     * - SystemMessage: this is added to the beginning of the list of messages in state[\"messages\"].\n     * - Function: This function should take in full graph state and the output is then passed to the language model.\n     * - Runnable: This runnable should take in full graph state and the output is then passed to the language model.\n     *\n     * Note:\n     * Prior to `v0.2.46`, the prompt was set using `stateModifier` / `messagesModifier` parameters.\n     * This is now deprecated and will be removed in a future release.\n     */\n    prompt?: Prompt;\n    /**\n     * Additional state schema for the agent.\n     */\n    stateSchema?: A;\n    /**\n     * An optional schema for the context.\n     */\n    contextSchema?: C;\n    /** An optional checkpoint saver to persist the agent's state. */\n    checkpointSaver?: BaseCheckpointSaver | boolean;\n    /** An optional checkpoint saver to persist the agent's state. Alias of \"checkpointSaver\". */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /** An optional list of node names to interrupt before running. */\n    interruptBefore?: N[] | All;\n    /** An optional list of node names to interrupt after running. */\n    interruptAfter?: N[] | All;\n    store?: BaseStore;\n    /**\n     * An optional schema for the final agent output.\n     *\n     * If provided, output will be formatted to match the given schema and returned in the 'structuredResponse' state key.\n     * If not provided, `structuredResponse` will not be present in the output state.\n     *\n     * Can be passed in as:\n     *   - Zod schema\n     *   - JSON schema\n     *   - { prompt, schema }, where schema is one of the above.\n     *        The prompt will be used together with the model that is being used to generate the structured response.\n     *\n     * @remarks\n     * **Important**: `responseFormat` requires the model to support `.withStructuredOutput()`.\n     *\n     * **Note**: The graph will make a separate call to the LLM to generate the structured response after the agent loop is finished.\n     * This is not the only strategy to get structured responses, see more options in [this guide](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output/).\n     */\n    responseFormat?: InteropZodType<StructuredResponseType> | StructuredResponseSchemaOptions<StructuredResponseType> | Record<string, any>;\n    /**\n     * An optional name for the agent.\n     */\n    name?: string;\n    /**\n     * An optional description for the agent.\n     * This can be used to describe the agent to the underlying supervisor LLM.\n     */\n    description?: string | undefined;\n    /**\n     * Use to specify how to expose the agent name to the underlying supervisor LLM.\n  \n        - undefined: Relies on the LLM provider {@link AIMessage#name}. Currently, only OpenAI supports this.\n        - `\"inline\"`: Add the agent name directly into the content field of the {@link AIMessage} using XML-style tags.\n            Example: `\"How can I help you\"` -> `\"<name>agent_name</name><content>How can I help you?</content>\"`\n     */\n    includeAgentName?: \"inline\" | undefined;\n    /**\n     * An optional node to add before the `agent` node (i.e., the node that calls the LLM).\n     * Useful for managing long message histories (e.g., message trimming, summarization, etc.).\n     */\n    preModelHook?: RunnableLike<ToAnnotationRoot<A>[\"State\"] & PreHookAnnotation[\"State\"], ToAnnotationRoot<A>[\"Update\"] & PreHookAnnotation[\"Update\"], LangGraphRunnableConfig>;\n    /**\n     * An optional node to add after the `agent` node (i.e., the node that calls the LLM).\n     * Useful for implementing human-in-the-loop, guardrails, validation, or other post-processing.\n     */\n    postModelHook?: RunnableLike<ToAnnotationRoot<A>[\"State\"], ToAnnotationRoot<A>[\"Update\"], LangGraphRunnableConfig>;\n    /**\n     * Determines the version of the graph to create.\n     *\n     * Can be one of\n     * - `\"v1\"`: The tool node processes a single message. All tool calls in the message are\n     *           executed in parallel within the tool node.\n     * - `\"v2\"`: The tool node processes a single tool call. Tool calls are distributed across\n     *           multiple instances of the tool node using the Send API.\n     *\n     * @default `\"v1\"`\n     */\n    version?: \"v1\" | \"v2\";\n};\n/**\n * @deprecated `createReactAgent` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { createAgent } from \"langchain\";`\n *\n * Creates a StateGraph agent that relies on a chat model utilizing tool calling.\n *\n * @example\n * ```ts\n * import { ChatOpenAI } from \"@langchain/openai\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n * import { createReactAgent } from \"@langchain/langgraph/prebuilt\";\n *\n * const model = new ChatOpenAI({\n *   model: \"gpt-4o\",\n * });\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   })\n * })\n *\n * const agent = createReactAgent({ llm: model, tools: [getWeather] });\n *\n * const inputs = {\n *   messages: [{ role: \"user\", content: \"what is the weather in SF?\" }],\n * };\n *\n * const stream = await agent.stream(inputs, { streamMode: \"values\" });\n *\n * for await (const { messages } of stream) {\n *   console.log(messages);\n * }\n * // Returns the messages in the state at each step of execution\n * ```\n */\nexport declare function createReactAgent<A extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, StructuredResponseFormat extends Record<string, any> = Record<string, any>, C extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateReactAgentParams<A, StructuredResponseFormat, C>): CompiledStateGraph<ToAnnotationRoot<A>[\"State\"], ToAnnotationRoot<A>[\"Update\"], any, typeof MessagesAnnotation.spec & ToAnnotationRoot<A>[\"spec\"], ReturnType<typeof createReactAgentAnnotation<StructuredResponseFormat>>[\"spec\"] & ToAnnotationRoot<A>[\"spec\"]>;\nexport {};\n"],"mappings":"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"}

package/dist/prebuilt/react_agent_executor.js

@@ -0,0 +1,338 @@
+import { Annotation } from "../graph/annotation.js";
+import { END, START, Send } from "../constants.js";
+import { StateGraph } from "../graph/state.js";
+import { messagesStateReducer } from "../graph/message.js";
+import "../graph/index.js";
+import { ToolNode } from "./tool_node.js";
+import { withAgentName } from "./agentName.js";
+import { Runnable, RunnableBinding, RunnableLambda, RunnableSequence } from "@langchain/core/runnables";
+import { SystemMessage, isAIMessage, isBaseMessage, isToolMessage } from "@langchain/core/messages";
+
+//#region src/prebuilt/react_agent_executor.ts
+function _convertMessageModifierToPrompt(messageModifier) {
+	if (typeof messageModifier === "string" || isBaseMessage(messageModifier) && messageModifier._getType() === "system") return messageModifier;
+	if (typeof messageModifier === "function") return async (state) => messageModifier(state.messages);
+	if (Runnable.isRunnable(messageModifier)) return RunnableLambda.from((state) => state.messages).pipe(messageModifier);
+	throw new Error(`Unexpected type for messageModifier: ${typeof messageModifier}`);
+}
+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: 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(prompt)) promptRunnable = prompt;
+	else throw new Error(`Got unexpected type for 'prompt': ${typeof prompt}`);
+	return promptRunnable;
+}
+function isClientTool(tool) {
+	return Runnable.isRunnable(tool);
+}
+function _getPrompt(prompt, stateModifier, messageModifier) {
+	if ([
+		prompt,
+		stateModifier,
+		messageModifier
+	].filter((x) => x != null).length > 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 _isBaseChatModel(model) {
+	return "invoke" in model && typeof model.invoke === "function" && "_modelType" in model;
+}
+function _isConfigurableModel(model) {
+	return "_queuedMethodOperations" in model && "_model" in model && typeof model._model === "function";
+}
+function _isChatModelWithBindTools(llm) {
+	if (!_isBaseChatModel(llm)) return false;
+	return "bindTools" in llm && typeof llm.bindTools === "function";
+}
+async function _shouldBindTools(llm, tools) {
+	let model = llm;
+	if (RunnableSequence.isRunnableSequence(model)) model = model.steps.find((step) => RunnableBinding.isRunnableBinding(step) || _isBaseChatModel(step) || _isConfigurableModel(step)) || model;
+	if (_isConfigurableModel(model)) model = await model._model();
+	if (!RunnableBinding.isRunnableBinding(model)) return true;
+	let boundTools = (() => {
+		if (model.kwargs != null && typeof model.kwargs === "object" && "tools" in model.kwargs && Array.isArray(model.kwargs.tools)) return model.kwargs.tools ?? null;
+		if (model.config != null && typeof model.config === "object" && "tools" in model.config && Array.isArray(model.config.tools)) return model.config.tools ?? null;
+		return null;
+	})();
+	if (boundTools != null && boundTools.length === 1 && "functionDeclarations" in boundTools[0]) boundTools = boundTools[0].functionDeclarations;
+	if (boundTools == null) return true;
+	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.flatMap((tool) => isClientTool(tool) ? tool.name : []));
+	const boundToolNames = /* @__PURE__ */ new Set();
+	for (const boundTool of boundTools) {
+		let boundToolName;
+		if ("type" in boundTool && boundTool.type === "function") boundToolName = boundTool.function.name;
+		else if ("name" in boundTool) boundToolName = boundTool.name;
+		else if ("toolSpec" in boundTool && "name" in boundTool.toolSpec) boundToolName = boundTool.toolSpec.name;
+		else continue;
+		if (boundToolName) 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;
+}
+const _simpleBindTools = (llm, toolClasses) => {
+	if (_isChatModelWithBindTools(llm)) return llm.bindTools(toolClasses);
+	if (RunnableBinding.isRunnableBinding(llm) && _isChatModelWithBindTools(llm.bound)) {
+		const newBound = llm.bound.bindTools(toolClasses);
+		if (RunnableBinding.isRunnableBinding(newBound)) return new RunnableBinding({
+			bound: newBound.bound,
+			config: {
+				...llm.config,
+				...newBound.config
+			},
+			kwargs: {
+				...llm.kwargs,
+				...newBound.kwargs
+			},
+			configFactories: newBound.configFactories ?? llm.configFactories
+		});
+		return new RunnableBinding({
+			bound: newBound,
+			config: llm.config,
+			kwargs: llm.kwargs,
+			configFactories: llm.configFactories
+		});
+	}
+	return null;
+};
+async function _bindTools(llm, toolClasses) {
+	const model = _simpleBindTools(llm, toolClasses);
+	if (model) return model;
+	if (_isConfigurableModel(llm)) {
+		const model$1 = _simpleBindTools(await llm._model(), toolClasses);
+		if (model$1) return model$1;
+	}
+	if (RunnableSequence.isRunnableSequence(llm)) {
+		const modelStep = llm.steps.findIndex((step) => RunnableBinding.isRunnableBinding(step) || _isBaseChatModel(step) || _isConfigurableModel(step));
+		if (modelStep >= 0) {
+			const model$1 = _simpleBindTools(llm.steps[modelStep], toolClasses);
+			if (model$1) {
+				const nextSteps = llm.steps.slice();
+				nextSteps.splice(modelStep, 1, model$1);
+				return RunnableSequence.from(nextSteps);
+			}
+		}
+	}
+	throw new Error(`llm ${llm} must define bindTools method.`);
+}
+async function _getModel(llm) {
+	let model = llm;
+	if (RunnableSequence.isRunnableSequence(model)) model = model.steps.find((step) => RunnableBinding.isRunnableBinding(step) || _isBaseChatModel(step) || _isConfigurableModel(step)) || model;
+	if (_isConfigurableModel(model)) model = await model._model();
+	if (RunnableBinding.isRunnableBinding(model)) model = model.bound;
+	if (!_isBaseChatModel(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 model;
+}
+const createReactAgentAnnotation = () => Annotation.Root({
+	messages: Annotation({
+		reducer: messagesStateReducer,
+		default: () => []
+	}),
+	structuredResponse: Annotation
+});
+const PreHookAnnotation = Annotation.Root({ llmInputMessages: Annotation({
+	reducer: (_, update) => messagesStateReducer([], update),
+	default: () => []
+}) });
+/**
+* @deprecated `createReactAgent` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.
+* Update your import to `import { createAgent } from "langchain";`
+*
+* Creates a StateGraph agent that relies on a chat model utilizing tool calling.
+*
+* @example
+* ```ts
+* import { ChatOpenAI } from "@langchain/openai";
+* import { tool } from "@langchain/core/tools";
+* import { z } from "zod";
+* import { createReactAgent } from "@langchain/langgraph/prebuilt";
+*
+* const model = new ChatOpenAI({
+*   model: "gpt-4o",
+* });
+*
+* const getWeather = tool((input) => {
+*   if (["sf", "san francisco"].includes(input.location.toLowerCase())) {
+*     return "It's 60 degrees and foggy.";
+*   } else {
+*     return "It's 90 degrees and sunny.";
+*   }
+* }, {
+*   name: "get_weather",
+*   description: "Call to get the current weather.",
+*   schema: z.object({
+*     location: z.string().describe("Location to get the weather for."),
+*   })
+* })
+*
+* const agent = createReactAgent({ llm: model, tools: [getWeather] });
+*
+* const inputs = {
+*   messages: [{ role: "user", content: "what is the weather in SF?" }],
+* };
+*
+* const stream = await agent.stream(inputs, { streamMode: "values" });
+*
+* for await (const { messages } of stream) {
+*   console.log(messages);
+* }
+* // Returns the messages in the state at each step of execution
+* ```
+*/
+function createReactAgent(params) {
+	const { llm, tools, messageModifier, stateModifier, prompt, stateSchema, contextSchema, checkpointSaver, checkpointer, interruptBefore, interruptAfter, store, responseFormat, preModelHook, postModelHook, name, description, version = "v1", includeAgentName } = params;
+	let toolClasses;
+	let toolNode;
+	if (!Array.isArray(tools)) {
+		toolClasses = tools.tools;
+		toolNode = tools;
+	} else {
+		toolClasses = tools;
+		toolNode = new ToolNode(toolClasses.filter(isClientTool));
+	}
+	let cachedStaticModel = null;
+	const _getStaticModel = async (llm$1) => {
+		if (cachedStaticModel) return cachedStaticModel;
+		let modelWithTools;
+		if (await _shouldBindTools(llm$1, toolClasses)) modelWithTools = await _bindTools(llm$1, toolClasses);
+		else modelWithTools = llm$1;
+		const promptRunnable = _getPrompt(prompt, stateModifier, messageModifier);
+		const modelRunnable = includeAgentName === "inline" ? withAgentName(modelWithTools, includeAgentName) : modelWithTools;
+		cachedStaticModel = promptRunnable.pipe(modelRunnable);
+		return cachedStaticModel;
+	};
+	const _getDynamicModel = async (llm$1, state, config) => {
+		const model = await llm$1(state, config);
+		return _getPrompt(prompt, stateModifier, messageModifier).pipe(includeAgentName === "inline" ? withAgentName(model, includeAgentName) : model);
+	};
+	const shouldReturnDirect = new Set(toolClasses.filter(isClientTool).filter((tool) => "returnDirect" in tool && tool.returnDirect).map((tool) => tool.name));
+	function getModelInputState(state) {
+		const { messages, llmInputMessages, ...rest } = state;
+		if (llmInputMessages != null && llmInputMessages.length > 0) return {
+			messages: llmInputMessages,
+			...rest
+		};
+		return {
+			messages,
+			...rest
+		};
+	}
+	const generateStructuredResponse = async (state, config) => {
+		if (responseFormat == null) throw new Error("Attempted to generate structured output with no passed response schema. Please contact us for help.");
+		const messages = [...state.messages];
+		let modelWithStructuredOutput;
+		const model = typeof llm === "function" ? await llm(state, config) : await _getModel(llm);
+		if (!_isBaseChatModel(model)) throw new Error(`Expected \`llm\` to be a ChatModel with .withStructuredOutput() method, got ${model.constructor.name}`);
+		if (typeof responseFormat === "object" && "schema" in responseFormat) {
+			const { prompt: prompt$1, schema, ...options } = responseFormat;
+			modelWithStructuredOutput = model.withStructuredOutput(schema, options);
+			if (prompt$1 != null) messages.unshift(new SystemMessage({ content: prompt$1 }));
+		} else modelWithStructuredOutput = model.withStructuredOutput(responseFormat);
+		return { structuredResponse: await modelWithStructuredOutput.invoke(messages, config) };
+	};
+	const callModel = async (state, config) => {
+		const response = await (typeof llm === "function" ? await _getDynamicModel(llm, state, config) : await _getStaticModel(llm)).invoke(getModelInputState(state), config);
+		response.name = name;
+		response.lc_kwargs.name = name;
+		return { messages: [response] };
+	};
+	const workflow = new StateGraph(stateSchema ?? createReactAgentAnnotation(), contextSchema).addNode("tools", toolNode);
+	if (!("messages" in workflow._schemaDefinition)) throw new Error("Missing required `messages` key in state schema.");
+	const allNodeWorkflows = workflow;
+	const conditionalMap = (map) => {
+		return Object.fromEntries(Object.entries(map).filter(([_, v]) => v != null));
+	};
+	let entrypoint = "agent";
+	let inputSchema;
+	if (preModelHook != null) {
+		allNodeWorkflows.addNode("pre_model_hook", preModelHook).addEdge("pre_model_hook", "agent");
+		entrypoint = "pre_model_hook";
+		inputSchema = Annotation.Root({
+			...workflow._schemaDefinition,
+			...PreHookAnnotation.spec
+		});
+	} else entrypoint = "agent";
+	allNodeWorkflows.addNode("agent", callModel, { input: inputSchema }).addEdge(START, entrypoint);
+	if (postModelHook != null) allNodeWorkflows.addNode("post_model_hook", postModelHook).addEdge("agent", "post_model_hook").addConditionalEdges("post_model_hook", (state) => {
+		const { messages } = state;
+		const toolMessageIds = new Set(messages.filter(isToolMessage).map((msg) => msg.tool_call_id));
+		let lastAiMessage;
+		for (let i = messages.length - 1; i >= 0; i -= 1) {
+			const message = messages[i];
+			if (isAIMessage(message)) {
+				lastAiMessage = message;
+				break;
+			}
+		}
+		const pendingToolCalls = lastAiMessage?.tool_calls?.filter((i) => i.id == null || !toolMessageIds.has(i.id)) ?? [];
+		const lastMessage = messages.at(-1);
+		if (pendingToolCalls.length > 0) {
+			if (version === "v2") return pendingToolCalls.map((toolCall) => new Send("tools", {
+				...state,
+				lg_tool_call: toolCall
+			}));
+			return "tools";
+		}
+		if (lastMessage && isToolMessage(lastMessage)) return entrypoint;
+		if (responseFormat != null) return "generate_structured_response";
+		return END;
+	}, conditionalMap({
+		tools: "tools",
+		[entrypoint]: entrypoint,
+		generate_structured_response: responseFormat != null ? "generate_structured_response" : null,
+		[END]: responseFormat != null ? null : END
+	}));
+	if (responseFormat !== void 0) workflow.addNode("generate_structured_response", generateStructuredResponse).addEdge("generate_structured_response", END);
+	if (postModelHook == null) allNodeWorkflows.addConditionalEdges("agent", (state) => {
+		const { messages } = state;
+		const lastMessage = messages[messages.length - 1];
+		if (!isAIMessage(lastMessage) || !lastMessage.tool_calls?.length) {
+			if (responseFormat != null) return "generate_structured_response";
+			return END;
+		}
+		if (version === "v2") return lastMessage.tool_calls.map((toolCall) => new Send("tools", {
+			...state,
+			lg_tool_call: toolCall
+		}));
+		return "tools";
+	}, conditionalMap({
+		tools: "tools",
+		generate_structured_response: responseFormat != null ? "generate_structured_response" : null,
+		[END]: responseFormat != null ? null : END
+	}));
+	if (shouldReturnDirect.size > 0) allNodeWorkflows.addConditionalEdges("tools", (state) => {
+		for (let i = state.messages.length - 1; i >= 0; i -= 1) {
+			const message = state.messages[i];
+			if (!isToolMessage(message)) break;
+			if (message.name !== void 0 && shouldReturnDirect.has(message.name)) return END;
+		}
+		return entrypoint;
+	}, conditionalMap({
+		[entrypoint]: entrypoint,
+		[END]: END
+	}));
+	else allNodeWorkflows.addEdge("tools", entrypoint);
+	return allNodeWorkflows.compile({
+		checkpointer: checkpointer ?? checkpointSaver,
+		interruptBefore,
+		interruptAfter,
+		store,
+		name,
+		description
+	});
+}
+
+//#endregion
+export { createReactAgent, createReactAgentAnnotation };
+//# sourceMappingURL=react_agent_executor.js.map