langchain 0.3.31 → 1.0.0-alpha.2

package/dist/agents/types.d.cts

@@ -0,0 +1,261 @@
+import { JsonSchemaFormat, ProviderStrategy, ResponseFormat, ResponseFormatUndefined, ToolStrategy, TypedToolStrategy } from "./responses.cjs";
+import { AnyAnnotationRoot, PreHookAnnotation, ToAnnotationRoot } from "./annotation.cjs";
+import { ToolNode } from "./nodes/ToolNode.cjs";
+import { LanguageModelLike } from "@langchain/core/language_models/base";
+import { Runnable, RunnableLike, RunnableToolLike } from "@langchain/core/runnables";
+import { InteropZodObject, InteropZodType } from "@langchain/core/utils/types";
+import { BaseMessage, BaseMessageLike, SystemMessage } from "@langchain/core/messages";
+import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";
+import { LangGraphRunnableConfig, Runtime, START } from "@langchain/langgraph";
+import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
+
+//#region src/agents/types.d.ts
+type N = typeof START | "agent" | "tools";
+/**
+ * Information about a tool call that has been executed.
+ */
+
+/**
+ * Type helper to extract union type from an array of Zod schemas
+ */
+type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> = T extends readonly [InteropZodType<infer A>, ...infer Rest] ? Rest extends readonly InteropZodType<any>[] ? A | ExtractZodArrayTypes<Rest> : A : never;
+/**
+ * Type helper to extract the structured response type from responseFormat
+ */
+
+type ServerTool = Record<string, unknown>;
+type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;
+type Prompt<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = SystemMessage | string | ((state: ToAnnotationRoot<StateSchema>["State"] & PreHookAnnotation["State"], config: LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>["State"]>) => BaseMessageLike[] | Promise<BaseMessageLike[]>) | Runnable;
+type AgentState<AnnotationRoot extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = ToAnnotationRoot<AnnotationRoot>["State"] & PreHookAnnotation["State"];
+type CreateReactAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot,
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+StructuredResponseType extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {
+  /** The chat model that can utilize OpenAI-style tool calling. */
+  llm?: LanguageModelLike | DynamicLLMFunction<StateSchema, ContextSchema>;
+  /**
+   * Initializes a ChatModel based on the provided model name and provider.
+   * It supports various model providers and allows for runtime configuration of model parameters.
+   *
+   * @uses {@link initChatModel}
+   * @example
+   * ```ts
+   * const agent = createReactAgent({
+   *   model: "anthropic:claude-3-7-sonnet-latest",
+   *   // ...
+   * });
+   * ```
+   */
+  model?: string;
+  /** A list of tools or a ToolNode. */
+  tools: ToolNode | (ServerTool | ClientTool)[];
+  /**
+   * 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.
+   *
+   * Cannot be used together with `prepareCall`.
+   */
+  prompt?: Prompt<StateSchema, ContextSchema>;
+  /**
+   * Additional state schema for the agent. It allows to define additional state keys that will be
+   * persisted between agent invocations.
+   *
+   * @example
+   * ```ts
+   * // State schema defines data that persists across agent invocations
+   * const stateSchema = z.object({
+   *   userPreferences: z.object({
+   *     theme: z.enum(["light", "dark"]),
+   *     language: z.string(),
+   *   }),
+   *   taskHistory: z.array(z.string()),
+   *   currentWorkflow: z.string().optional(),
+   * });
+   *
+   * // Context schema defines runtime parameters passed per invocation
+   * const contextSchema = z.object({ ... });
+   *
+   * const agent = createReactAgent({
+   *   llm: model,
+   *   tools: [updatePreferences, addTask],
+   *   stateSchema,    // Persisted: preferences, e.g. task history, workflow state
+   *   contextSchema,  // Per-invocation: user ID, session, API keys, etc.
+   *   prompt: (state, config) => {
+   *     // ...
+   *   },
+   * });
+   *
+   * // First invocation - state starts empty, context provided
+   * await agent.invoke({
+   *   messages: [new HumanMessage("Set my theme to dark")],
+   * }, {
+   *   context: { userId: "user123", sessionId: "sess456", apiKeys: {...} }
+   * });
+   *
+   * // Second invocation - state persists, new context
+   * await agent.invoke({
+   *   messages: [new HumanMessage("Add a task to review code")],
+   * }, {
+   *   context: { userId: "user123", sessionId: "sess789", apiKeys: {...} }
+   * });
+   * // State now contains: userPreferences.theme="dark", taskHistory=["review code"]
+   * ```
+   */
+  stateSchema?: StateSchema;
+  /**
+   * An optional schema for the context. It allows to pass in a typed context object into the agent
+   * invocation and allows to access it in hooks such as `prompt`, `preModelHook`, `postModelHook`, etc.
+   * As opposed to the agent state, defined in `stateSchema`, the context is not persisted between
+   * agent invocations.
+   *
+   * @example
+   * ```ts
+   * const agent = createReactAgent({
+   *   llm: model,
+   *   tools: [getWeather],
+   *   contextSchema: z.object({
+   *     capital: z.string(),
+   *   }),
+   *   prompt: (state, config) => {
+   *     return [
+   *       new SystemMessage(`You are a helpful assistant. The capital of France is ${config.context.capital}.`),
+   *     ];
+   *   },
+   * });
+   *
+   * const result = await agent.invoke({
+   *   messages: [
+   *     new SystemMessage("You are a helpful assistant."),
+   *     new HumanMessage("What is the capital of France?"),
+   *   ],
+   * }, {
+   *   context: {
+   *     capital: "Paris",
+   *   },
+   * });
+   * ```
+   */
+  contextSchema?: ContextSchema;
+  /** 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
+   *     ```ts
+   *     const agent = createReactAgent({
+   *       responseFormat: z.object({
+   *         capital: z.string(),
+   *       }),
+   *       // ...
+   *     });
+   *     ```
+   *   - JSON schema
+   *     ```ts
+   *     const agent = createReactAgent({
+   *       responseFormat: {
+   *         type: "json_schema",
+   *         schema: {
+   *           type: "object",
+   *           properties: {
+   *             capital: { type: "string" },
+   *           },
+   *           required: ["capital"],
+   *         },
+   *       },
+   *       // ...
+   *     });
+   *     ```
+   *   - Create React Agent ResponseFormat
+   *     ```ts
+   *     import { providerStrategy, toolStrategy } from "langchain";
+   *     const agent = createReactAgent({
+   *       responseFormat: providerStrategy(
+   *         z.object({
+   *           capital: z.string(),
+   *         })
+   *       ),
+   *       // or
+   *       responseFormat: [
+   *         toolStrategy({ ... }),
+   *         toolStrategy({ ... }),
+   *       ]
+   *       // ...
+   *     });
+   *     ```
+   *
+   * **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?: ResponseFormatType;
+  /**
+   * 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;
+  /**
+   * 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<StateSchema>["State"] & PreHookAnnotation["State"], ToAnnotationRoot<StateSchema>["Update"] & PreHookAnnotation["Update"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>["State"]>>;
+  /**
+   * 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<StateSchema>["State"] & PreHookAnnotation["State"], ToAnnotationRoot<StateSchema>["Update"] & PreHookAnnotation["Update"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>["State"]>>;
+  /**
+   * An optional abort signal that indicates that the overall operation should be aborted.
+   */
+  signal?: AbortSignal;
+  /**
+   * 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 `"v2"`
+   */
+  version?: "v1" | "v2";
+};
+/**
+ * @deprecated likely to be removed in the next version of the agent
+ */
+type DynamicLLMFunction<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = (state: ToAnnotationRoot<StateSchema>["State"] & PreHookAnnotation["State"], runtime: Runtime<ToAnnotationRoot<ContextSchema>["State"]>) => Promise<LanguageModelLike> | LanguageModelLike;
+//#endregion
+export { AgentState, ClientTool, CreateReactAgentParams, ExtractZodArrayTypes, N, Prompt, ServerTool };
+//# sourceMappingURL=types.d.cts.map

package/dist/agents/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":["InteropZodObject","InteropZodType","LangGraphRunnableConfig","START","Runtime","StateGraph","LanguageModelLike","BaseChatModel","SystemMessage","BaseMessageLike","BaseMessage","All","BaseCheckpointSaver","BaseStore","DynamicTool","StructuredToolInterface","Runnable","RunnableLike","RunnableToolLike","ToolNode","PreHookAnnotation","AnyAnnotationRoot","ToAnnotationRoot","ResponseFormat","ToolStrategy","TypedToolStrategy","ProviderStrategy","ResponseFormatUndefined","JsonSchemaFormat","META_EXTRAS_DESCRIPTION_PREFIX","N","ExecutedToolCall","Record","LLMCall","ExtractZodType","T","U","ExtractZodArrayTypes","Rest","A","InferResponseFormatType","ReducedZodChannel","TReducerSchema","ServerTool","ClientTool","Prompt","StateSchema","ContextSchema","Promise","AgentState","AnnotationRoot","AgentRuntime","CreateReactAgentParams","StructuredResponseType","DynamicLLMFunction","ResponseFormatType","AbortSignal","ConfigurableModelInterface","InternalAgentState","WithStateGraphNodes","Graph","SD","S","K","I","O","C"],"sources":["../../src/agents/types.d.ts"],"sourcesContent":["import type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport type { LangGraphRunnableConfig, START, Runtime, StateGraph } from \"@langchain/langgraph\";\nimport type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport type { SystemMessage, BaseMessageLike, BaseMessage } from \"@langchain/core/messages\";\nimport type { All, BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport type { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { Runnable, RunnableLike, RunnableToolLike } from \"@langchain/core/runnables\";\nimport type { ToolNode } from \"./nodes/ToolNode.js\";\nimport type { PreHookAnnotation, AnyAnnotationRoot, ToAnnotationRoot } from \"./annotation.js\";\nimport type { ResponseFormat, ToolStrategy, TypedToolStrategy, ProviderStrategy, ResponseFormatUndefined, JsonSchemaFormat } from \"./responses.js\";\nexport declare const META_EXTRAS_DESCRIPTION_PREFIX = \"lg:\";\nexport type N = typeof START | \"agent\" | \"tools\";\n/**\n * Information about a tool call that has been executed.\n */\nexport interface ExecutedToolCall {\n    /**\n     * The name of the tool that was called.\n     */\n    name: string;\n    /**\n     * The arguments that were passed to the tool.\n     */\n    args: Record<string, unknown>;\n    /**\n     * The ID of the tool call.\n     */\n    tool_id: string;\n    /**\n     * The result of the tool call (if available).\n     */\n    result?: unknown;\n}\n/**\n * Information about an LLM invocation.\n */\nexport interface LLMCall {\n    /**\n     * The messages that were sent to the LLM.\n     */\n    messages: BaseMessage[];\n    /**\n     * The response from the LLM.\n     */\n    response?: BaseMessage;\n}\n/**\n * Type helper to extract the inferred type from a single Zod schema or array of schemas\n */\nexport type ExtractZodType<T> = T extends InteropZodType<infer U> ? U : T extends readonly InteropZodType<any>[] ? ExtractZodArrayTypes<T> : never;\n/**\n * Type helper to extract union type from an array of Zod schemas\n */\nexport type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> = T extends readonly [InteropZodType<infer A>, ...infer Rest] ? Rest extends readonly InteropZodType<any>[] ? A | ExtractZodArrayTypes<Rest> : A : never;\n/**\n * Type helper to extract the structured response type from responseFormat\n */\nexport type InferResponseFormatType<T> = T extends InteropZodType<infer U> ? U extends Record<string, any> ? U : Record<string, any> : T extends readonly InteropZodType<any>[] ? ExtractZodArrayTypes<T> : T extends ToolStrategy[] ? Record<string, any> // ToolStrategy arrays will be handled at runtime\n : T extends ResponseFormat ? Record<string, any> // Single ResponseFormat will be handled at runtime\n : Record<string, any>;\n/** @internal */\nexport type ReducedZodChannel<T extends InteropZodType, TReducerSchema extends InteropZodType> = T & {\n    lg_reducer_schema: TReducerSchema;\n};\nexport type ServerTool = Record<string, unknown>;\nexport type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;\nexport type Prompt<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = SystemMessage | string | ((state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], config: LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>) => BaseMessageLike[] | Promise<BaseMessageLike[]>) | Runnable;\nexport type AgentState<AnnotationRoot extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = ToAnnotationRoot<AnnotationRoot>[\"State\"] & PreHookAnnotation[\"State\"];\nexport type AgentRuntime<AnnotationRoot extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = Runtime<ToAnnotationRoot<AnnotationRoot>[\"State\"]>;\nexport type CreateReactAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nStructuredResponseType extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {\n    /** The chat model that can utilize OpenAI-style tool calling. */\n    llm?: LanguageModelLike | DynamicLLMFunction<StateSchema, ContextSchema>;\n    /**\n     * Initializes a ChatModel based on the provided model name and provider.\n     * It supports various model providers and allows for runtime configuration of model parameters.\n     *\n     * @uses {@link initChatModel}\n     * @example\n     * ```ts\n     * const agent = createReactAgent({\n     *   model: \"anthropic:claude-3-7-sonnet-latest\",\n     *   // ...\n     * });\n     * ```\n     */\n    model?: string;\n    /** A list of tools or a ToolNode. */\n    tools: ToolNode | (ServerTool | ClientTool)[];\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     * Cannot be used together with `prepareCall`.\n     */\n    prompt?: Prompt<StateSchema, ContextSchema>;\n    /**\n     * Additional state schema for the agent. It allows to define additional state keys that will be\n     * persisted between agent invocations.\n     *\n     * @example\n     * ```ts\n     * // State schema defines data that persists across agent invocations\n     * const stateSchema = z.object({\n     *   userPreferences: z.object({\n     *     theme: z.enum([\"light\", \"dark\"]),\n     *     language: z.string(),\n     *   }),\n     *   taskHistory: z.array(z.string()),\n     *   currentWorkflow: z.string().optional(),\n     * });\n     *\n     * // Context schema defines runtime parameters passed per invocation\n     * const contextSchema = z.object({ ... });\n     *\n     * const agent = createReactAgent({\n     *   llm: model,\n     *   tools: [updatePreferences, addTask],\n     *   stateSchema,    // Persisted: preferences, e.g. task history, workflow state\n     *   contextSchema,  // Per-invocation: user ID, session, API keys, etc.\n     *   prompt: (state, config) => {\n     *     // ...\n     *   },\n     * });\n     *\n     * // First invocation - state starts empty, context provided\n     * await agent.invoke({\n     *   messages: [new HumanMessage(\"Set my theme to dark\")],\n     * }, {\n     *   context: { userId: \"user123\", sessionId: \"sess456\", apiKeys: {...} }\n     * });\n     *\n     * // Second invocation - state persists, new context\n     * await agent.invoke({\n     *   messages: [new HumanMessage(\"Add a task to review code\")],\n     * }, {\n     *   context: { userId: \"user123\", sessionId: \"sess789\", apiKeys: {...} }\n     * });\n     * // State now contains: userPreferences.theme=\"dark\", taskHistory=[\"review code\"]\n     * ```\n     */\n    stateSchema?: StateSchema;\n    /**\n     * An optional schema for the context. It allows to pass in a typed context object into the agent\n     * invocation and allows to access it in hooks such as `prompt`, `preModelHook`, `postModelHook`, etc.\n     * As opposed to the agent state, defined in `stateSchema`, the context is not persisted between\n     * agent invocations.\n     *\n     * @example\n     * ```ts\n     * const agent = createReactAgent({\n     *   llm: model,\n     *   tools: [getWeather],\n     *   contextSchema: z.object({\n     *     capital: z.string(),\n     *   }),\n     *   prompt: (state, config) => {\n     *     return [\n     *       new SystemMessage(`You are a helpful assistant. The capital of France is ${config.context.capital}.`),\n     *     ];\n     *   },\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [\n     *     new SystemMessage(\"You are a helpful assistant.\"),\n     *     new HumanMessage(\"What is the capital of France?\"),\n     *   ],\n     * }, {\n     *   context: {\n     *     capital: \"Paris\",\n     *   },\n     * });\n     * ```\n     */\n    contextSchema?: ContextSchema;\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     *     ```ts\n     *     const agent = createReactAgent({\n     *       responseFormat: z.object({\n     *         capital: z.string(),\n     *       }),\n     *       // ...\n     *     });\n     *     ```\n     *   - JSON schema\n     *     ```ts\n     *     const agent = createReactAgent({\n     *       responseFormat: {\n     *         type: \"json_schema\",\n     *         schema: {\n     *           type: \"object\",\n     *           properties: {\n     *             capital: { type: \"string\" },\n     *           },\n     *           required: [\"capital\"],\n     *         },\n     *       },\n     *       // ...\n     *     });\n     *     ```\n     *   - Create React Agent ResponseFormat\n     *     ```ts\n     *     import { providerStrategy, toolStrategy } from \"langchain\";\n     *     const agent = createReactAgent({\n     *       responseFormat: providerStrategy(\n     *         z.object({\n     *           capital: z.string(),\n     *         })\n     *       ),\n     *       // or\n     *       responseFormat: [\n     *         toolStrategy({ ... }),\n     *         toolStrategy({ ... }),\n     *       ]\n     *       // ...\n     *     });\n     *     ```\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?: ResponseFormatType;\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;\n    /**\n     * Use to specify how to expose the agent name to the underlying supervisor LLM.\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<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], ToAnnotationRoot<StateSchema>[\"Update\"] & PreHookAnnotation[\"Update\"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>>;\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<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], ToAnnotationRoot<StateSchema>[\"Update\"] & PreHookAnnotation[\"Update\"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>[\"State\"]>>;\n    /**\n     * An optional abort signal that indicates that the overall operation should be aborted.\n     */\n    signal?: AbortSignal;\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 `\"v2\"`\n     */\n    version?: \"v1\" | \"v2\";\n};\nexport interface ConfigurableModelInterface {\n    _queuedMethodOperations: Record<string, unknown>;\n    _model: () => Promise<BaseChatModel>;\n}\nexport type InternalAgentState<StructuredResponseType extends Record<string, unknown> | undefined = Record<string, unknown>> = {\n    messages: BaseMessage[];\n} & (StructuredResponseType extends ResponseFormatUndefined ? Record<string, never> : {\n    structuredResponse: StructuredResponseType;\n});\nexport type WithStateGraphNodes<K extends string, Graph> = Graph extends StateGraph<infer SD, infer S, infer U, infer N, infer I, infer O, infer C> ? StateGraph<SD, S, U, N | K, I, O, C> : never;\n/**\n * @deprecated likely to be removed in the next version of the agent\n */\ntype DynamicLLMFunction<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = (state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"], runtime: Runtime<ToAnnotationRoot<ContextSchema>[\"State\"]>) => Promise<LanguageModelLike> | LanguageModelLike;\nexport {};\n"],"mappings":"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"}

package/dist/agents/types.d.ts

@@ -1,93 +1,261 @@
-import type { Runnable } from "@langchain/core/runnables";
-import { BaseOutputParser } from "@langchain/core/output_parsers";
-import type { AgentAction, AgentFinish } from "@langchain/core/agents";
-import type { BaseMessage } from "@langchain/core/messages";
-import type { ChainValues } from "@langchain/core/utils/types";
-import { SerializedLLMChain } from "../chains/serde.js";
-import { LLMChain } from "../chains/llm_chain.js";
+import { JsonSchemaFormat, ProviderStrategy, ResponseFormat, ResponseFormatUndefined, ToolStrategy, TypedToolStrategy } from "./responses.js";
+import { AnyAnnotationRoot, PreHookAnnotation, ToAnnotationRoot } from "./annotation.js";
+import { ToolNode } from "./nodes/ToolNode.js";
+import { BaseMessage, BaseMessageLike, SystemMessage } from "@langchain/core/messages";
+import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { Runnable, RunnableLike, RunnableToolLike } from "@langchain/core/runnables";
+import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";
+import { LangGraphRunnableConfig, Runtime, START, StateGraph } from "@langchain/langgraph";
+import { InteropZodObject, InteropZodType } from "@langchain/core/utils/types";
+import { LanguageModelLike } from "@langchain/core/language_models/base";
+import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
+
+//#region src/agents/types.d.ts
+type N = typeof START | "agent" | "tools";
 /**
- * Interface defining the input for creating an agent. It includes the
- * LLMChain instance, an optional output parser, and an optional list of
- * allowed tools.
+ * Information about a tool call that has been executed.
  */
-export interface AgentInput {
-    llmChain: LLMChain;
-    outputParser: AgentActionOutputParser | undefined;
-    allowedTools?: string[];
-}
+
 /**
- * Interface defining the input for creating a single action agent
- * that uses runnables.
+ * Type helper to extract union type from an array of Zod schemas
  */
-export interface RunnableSingleActionAgentInput {
-    runnable: Runnable<ChainValues & {
-        agent_scratchpad?: string | BaseMessage[];
-        stop?: string[];
-    }, AgentAction | AgentFinish>;
-    streamRunnable?: boolean;
-    defaultRunName?: string;
-}
+type ExtractZodArrayTypes<T extends readonly InteropZodType<any>[]> = T extends readonly [InteropZodType<infer A>, ...infer Rest] ? Rest extends readonly InteropZodType<any>[] ? A | ExtractZodArrayTypes<Rest> : A : never;
 /**
- * Interface defining the input for creating a multi-action agent that uses
- * runnables. It includes the Runnable instance, and an optional list of
- * stop strings.
+ * Type helper to extract the structured response type from responseFormat
  */
-export interface RunnableMultiActionAgentInput {
-    runnable: Runnable<ChainValues & {
-        agent_scratchpad?: string | BaseMessage[];
-        stop?: string[];
-    }, AgentAction[] | AgentAction | AgentFinish>;
-    streamRunnable?: boolean;
-    defaultRunName?: string;
-    stop?: string[];
-}
-/** @deprecated Renamed to RunnableMultiActionAgentInput. */
-export interface RunnableAgentInput extends RunnableMultiActionAgentInput {
-}
-/**
- * Abstract class representing an output parser specifically for agent
- * actions and finishes in LangChain. It extends the `BaseOutputParser`
- * class.
- */
-export declare abstract class AgentActionOutputParser extends BaseOutputParser<AgentAction | AgentFinish> {
-}
-/**
- * Abstract class representing an output parser specifically for agents
- * that return multiple actions.
- */
-export declare abstract class AgentMultiActionOutputParser extends BaseOutputParser<AgentAction[] | AgentFinish> {
-}
-/**
- * Type representing the stopping method for an agent. It can be either
- * 'force' or 'generate'.
- */
-export type StoppingMethod = "force" | "generate";
-/**
- * Generic type representing a serialized agent in LangChain. It includes
- * the type of the agent, the serialized form of the LLMChain, and
- * additional properties specific to the agent type.
- */
-export type SerializedAgentT<TType extends string = string, FromLLMInput extends Record<string, unknown> = Record<string, unknown>, ConstructorInput extends AgentInput = AgentInput> = {
-    _type: TType;
-    llm_chain?: SerializedLLMChain;
-} & (({
-    load_from_llm_and_tools: true;
-} & FromLLMInput) | ({
-    load_from_llm_and_tools?: false;
-} & ConstructorInput));
-export type SerializedFromLLMAndTools = {
-    suffix?: string;
-    prefix?: string;
-    input_variables?: string[];
+
+type ServerTool = Record<string, unknown>;
+type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;
+type Prompt<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = SystemMessage | string | ((state: ToAnnotationRoot<StateSchema>["State"] & PreHookAnnotation["State"], config: LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>["State"]>) => BaseMessageLike[] | Promise<BaseMessageLike[]>) | Runnable;
+type AgentState<AnnotationRoot extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = ToAnnotationRoot<AnnotationRoot>["State"] & PreHookAnnotation["State"];
+type CreateReactAgentParams<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot,
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+StructuredResponseType extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ResponseFormatType = InteropZodType<StructuredResponseType> | InteropZodType<unknown>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | TypedToolStrategy<StructuredResponseType> | ToolStrategy<StructuredResponseType> | ProviderStrategy<StructuredResponseType> | ResponseFormatUndefined> = {
+  /** The chat model that can utilize OpenAI-style tool calling. */
+  llm?: LanguageModelLike | DynamicLLMFunction<StateSchema, ContextSchema>;
+  /**
+   * Initializes a ChatModel based on the provided model name and provider.
+   * It supports various model providers and allows for runtime configuration of model parameters.
+   *
+   * @uses {@link initChatModel}
+   * @example
+   * ```ts
+   * const agent = createReactAgent({
+   *   model: "anthropic:claude-3-7-sonnet-latest",
+   *   // ...
+   * });
+   * ```
+   */
+  model?: string;
+  /** A list of tools or a ToolNode. */
+  tools: ToolNode | (ServerTool | ClientTool)[];
+  /**
+   * 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.
+   *
+   * Cannot be used together with `prepareCall`.
+   */
+  prompt?: Prompt<StateSchema, ContextSchema>;
+  /**
+   * Additional state schema for the agent. It allows to define additional state keys that will be
+   * persisted between agent invocations.
+   *
+   * @example
+   * ```ts
+   * // State schema defines data that persists across agent invocations
+   * const stateSchema = z.object({
+   *   userPreferences: z.object({
+   *     theme: z.enum(["light", "dark"]),
+   *     language: z.string(),
+   *   }),
+   *   taskHistory: z.array(z.string()),
+   *   currentWorkflow: z.string().optional(),
+   * });
+   *
+   * // Context schema defines runtime parameters passed per invocation
+   * const contextSchema = z.object({ ... });
+   *
+   * const agent = createReactAgent({
+   *   llm: model,
+   *   tools: [updatePreferences, addTask],
+   *   stateSchema,    // Persisted: preferences, e.g. task history, workflow state
+   *   contextSchema,  // Per-invocation: user ID, session, API keys, etc.
+   *   prompt: (state, config) => {
+   *     // ...
+   *   },
+   * });
+   *
+   * // First invocation - state starts empty, context provided
+   * await agent.invoke({
+   *   messages: [new HumanMessage("Set my theme to dark")],
+   * }, {
+   *   context: { userId: "user123", sessionId: "sess456", apiKeys: {...} }
+   * });
+   *
+   * // Second invocation - state persists, new context
+   * await agent.invoke({
+   *   messages: [new HumanMessage("Add a task to review code")],
+   * }, {
+   *   context: { userId: "user123", sessionId: "sess789", apiKeys: {...} }
+   * });
+   * // State now contains: userPreferences.theme="dark", taskHistory=["review code"]
+   * ```
+   */
+  stateSchema?: StateSchema;
+  /**
+   * An optional schema for the context. It allows to pass in a typed context object into the agent
+   * invocation and allows to access it in hooks such as `prompt`, `preModelHook`, `postModelHook`, etc.
+   * As opposed to the agent state, defined in `stateSchema`, the context is not persisted between
+   * agent invocations.
+   *
+   * @example
+   * ```ts
+   * const agent = createReactAgent({
+   *   llm: model,
+   *   tools: [getWeather],
+   *   contextSchema: z.object({
+   *     capital: z.string(),
+   *   }),
+   *   prompt: (state, config) => {
+   *     return [
+   *       new SystemMessage(`You are a helpful assistant. The capital of France is ${config.context.capital}.`),
+   *     ];
+   *   },
+   * });
+   *
+   * const result = await agent.invoke({
+   *   messages: [
+   *     new SystemMessage("You are a helpful assistant."),
+   *     new HumanMessage("What is the capital of France?"),
+   *   ],
+   * }, {
+   *   context: {
+   *     capital: "Paris",
+   *   },
+   * });
+   * ```
+   */
+  contextSchema?: ContextSchema;
+  /** 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
+   *     ```ts
+   *     const agent = createReactAgent({
+   *       responseFormat: z.object({
+   *         capital: z.string(),
+   *       }),
+   *       // ...
+   *     });
+   *     ```
+   *   - JSON schema
+   *     ```ts
+   *     const agent = createReactAgent({
+   *       responseFormat: {
+   *         type: "json_schema",
+   *         schema: {
+   *           type: "object",
+   *           properties: {
+   *             capital: { type: "string" },
+   *           },
+   *           required: ["capital"],
+   *         },
+   *       },
+   *       // ...
+   *     });
+   *     ```
+   *   - Create React Agent ResponseFormat
+   *     ```ts
+   *     import { providerStrategy, toolStrategy } from "langchain";
+   *     const agent = createReactAgent({
+   *       responseFormat: providerStrategy(
+   *         z.object({
+   *           capital: z.string(),
+   *         })
+   *       ),
+   *       // or
+   *       responseFormat: [
+   *         toolStrategy({ ... }),
+   *         toolStrategy({ ... }),
+   *       ]
+   *       // ...
+   *     });
+   *     ```
+   *
+   * **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?: ResponseFormatType;
+  /**
+   * 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;
+  /**
+   * 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<StateSchema>["State"] & PreHookAnnotation["State"], ToAnnotationRoot<StateSchema>["Update"] & PreHookAnnotation["Update"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>["State"]>>;
+  /**
+   * 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<StateSchema>["State"] & PreHookAnnotation["State"], ToAnnotationRoot<StateSchema>["Update"] & PreHookAnnotation["Update"], LangGraphRunnableConfig<ToAnnotationRoot<ContextSchema>["State"]>>;
+  /**
+   * An optional abort signal that indicates that the overall operation should be aborted.
+   */
+  signal?: AbortSignal;
+  /**
+   * 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 `"v2"`
+   */
+  version?: "v1" | "v2";
 };
 /**
- * Type representing a serialized ZeroShotAgent in LangChain. It extends
- * the `SerializedAgentT` type and includes additional properties specific
- * to the ZeroShotAgent.
- */
-export type SerializedZeroShotAgent = SerializedAgentT<"zero-shot-react-description", SerializedFromLLMAndTools, AgentInput>;
-/**
- * Type representing a serialized agent in LangChain. It is currently
- * synonymous with `SerializedZeroShotAgent`.
+ * @deprecated likely to be removed in the next version of the agent
  */
-export type SerializedAgent = SerializedZeroShotAgent;
+type DynamicLLMFunction<StateSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = (state: ToAnnotationRoot<StateSchema>["State"] & PreHookAnnotation["State"], runtime: Runtime<ToAnnotationRoot<ContextSchema>["State"]>) => Promise<LanguageModelLike> | LanguageModelLike;
+//#endregion
+export { AgentState, ClientTool, CreateReactAgentParams, ExtractZodArrayTypes, N, Prompt, ServerTool };
+//# sourceMappingURL=types.d.ts.map