langchain 1.0.0-alpha.6 → 1.0.0-alpha.8

package/dist/agents/middlewareAgent/ReactAgent.d.ts

@@ -1,32 +1,173 @@
-import { ResponseFormatUndefined } from "../responses.js";
-import { AnyAnnotationRoot, ToAnnotationRoot } from "../annotation.js";
-import { AgentMiddleware, BuiltInState, CreateAgentParams, InferContextInput, InferMiddlewareContextInputs, InferMiddlewareInputStates, InferMiddlewareStates, IsAllOptional } from "./types.js";
-import { Command, CompiledStateGraph, LangGraphRunnableConfig } from "@langchain/langgraph";
+import { AnyAnnotationRoot, ResponseFormatUndefined, ToAnnotationRoot } from "../annotation.js";
+import { AgentMiddleware, BuiltInState, CreateAgentParams, InferContextInput, InferMiddlewareContextInputs, InferMiddlewareInputStates, InferMiddlewareStates, InvokeConfiguration, StreamConfiguration, UserInput } from "./types.js";
+import { RunnableConfig } from "@langchain/core/runnables";
+import { IterableReadableStream } from "@langchain/core/utils/stream";
+import { Command, CompiledStateGraph, GetStateOptions } from "@langchain/langgraph";
 import { InteropZodObject } from "@langchain/core/utils/types";
+import { CheckpointListOptions } from "@langchain/langgraph-checkpoint";
 
 //#region src/agents/middlewareAgent/ReactAgent.d.ts
 
 // Helper type to get the state definition with middleware states
-type MergedAgentState<StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined, TMiddleware extends readonly AgentMiddleware<any, any, any>[]> = (StructuredResponseFormat extends ResponseFormatUndefined ? BuiltInState : BuiltInState & {
+type MergedAgentState<StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined, TMiddleware extends readonly AgentMiddleware<any, any, any>[]> = (StructuredResponseFormat extends ResponseFormatUndefined ? Omit<BuiltInState, "jumpTo"> : Omit<BuiltInState, "jumpTo"> & {
   structuredResponse: StructuredResponseFormat;
 }) & InferMiddlewareStates<TMiddleware>;
-type InvokeStateParameter<TMiddleware extends readonly AgentMiddleware<any, any, any>[]> = (BuiltInState & InferMiddlewareInputStates<TMiddleware>) | Command<any, any, any> | null;
+type InvokeStateParameter<TMiddleware extends readonly AgentMiddleware<any, any, any>[]> = (UserInput & InferMiddlewareInputStates<TMiddleware>) | Command<any, any, any> | null;
 type AgentGraph<StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = []> = CompiledStateGraph<any, any, any, any, MergedAgentState<StructuredResponseFormat, TMiddleware>, ToAnnotationRoot<ContextSchema>["spec"], unknown>;
-declare class ReactAgent<StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = []> {
+declare class ReactAgent<StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]> {
   #private;
   options: CreateAgentParams<StructuredResponseFormat, ContextSchema>;
   constructor(options: CreateAgentParams<StructuredResponseFormat, ContextSchema>);
   /**
-   * Get the compiled graph.
+   * Get the compiled {@link https://docs.langchain.com/oss/javascript/langgraph/use-graph-api | StateGraph}.
    */
   get graph(): AgentGraph<StructuredResponseFormat, ContextSchema, TMiddleware>;
   /**
-   * @inheritdoc
+   * Executes the agent with the given state and returns the final state after all processing.
+   *
+   * This method runs the agent's entire workflow synchronously, including:
+   * - Processing the input messages through any configured middleware
+   * - Calling the language model to generate responses
+   * - Executing any tool calls made by the model
+   * - Running all middleware hooks (beforeModel, afterModel, etc.)
+   *
+   * @param state - The initial state for the agent execution. Can be:
+   *   - An object containing `messages` array and any middleware-specific state properties
+   *   - A Command object for more advanced control flow
+   *
+   * @param config - Optional runtime configuration including:
+   * @param config.context - The context for the agent execution.
+   * @param config.configurable - LangGraph configuration options like `thread_id`, `run_id`, etc.
+   * @param config.store - The store for the agent execution for persisting state, see more in {@link https://docs.langchain.com/oss/javascript/langgraph/memory#memory-storage | Memory storage}.
+   * @param config.signal - An optional {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | `AbortSignal`} for the agent execution.
+   * @param config.recursionLimit - The recursion limit for the agent execution.
+   *
+   * @returns A Promise that resolves to the final agent state after execution completes.
+   *          The returned state includes:
+   *          - a `messages` property containing an array with all messages (input, AI responses, tool calls/results)
+   *          - a `structuredResponse` property containing the structured response (if configured)
+   *          - all state values defined in the middleware
+   *
+   * @example
+   * ```typescript
+   * const agent = new ReactAgent({
+   *   llm: myModel,
+   *   tools: [calculator, webSearch],
+   *   responseFormat: z.object({
+   *     weather: z.string(),
+   *   }),
+   * });
+   *
+   * const result = await agent.invoke({
+   *   messages: [{ role: "human", content: "What's the weather in Paris?" }]
+   * });
+   *
+   * console.log(result.structuredResponse.weather); // outputs: "It's sunny and 75°F."
+   * ```
    */
-  get invoke(): IsAllOptional<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>> extends true ? (state: InvokeStateParameter<TMiddleware>, config?: LangGraphRunnableConfig<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>> | undefined) => Promise<MergedAgentState<StructuredResponseFormat, TMiddleware>> : (state: InvokeStateParameter<TMiddleware>, config?: LangGraphRunnableConfig<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>> | undefined) => Promise<MergedAgentState<StructuredResponseFormat, TMiddleware>>;
+  invoke(state: InvokeStateParameter<TMiddleware>, config?: InvokeConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>>): Promise<MergedAgentState<StructuredResponseFormat, TMiddleware>>;
   /**
-   * ToDo(@christian-bromann): Add stream and streamEvents methods
+   * Executes the agent with streaming, returning an async iterable of state updates as they occur.
+   *
+   * This method runs the agent's workflow similar to `invoke`, but instead of waiting for
+   * completion, it streams high-level state updates in real-time. This allows you to:
+   * - Display intermediate results to users as they're generated
+   * - Monitor the agent's progress through each step
+   * - React to state changes as nodes complete
+   *
+   * For more granular event-level streaming (like individual LLM tokens), use `streamEvents` instead.
+   *
+   * @param state - The initial state for the agent execution. Can be:
+   *   - An object containing `messages` array and any middleware-specific state properties
+   *   - A Command object for more advanced control flow
+   *
+   * @param config - Optional runtime configuration including:
+   * @param config.context - The context for the agent execution.
+   * @param config.configurable - LangGraph configuration options like `thread_id`, `run_id`, etc.
+   * @param config.store - The store for the agent execution for persisting state, see more in {@link https://docs.langchain.com/oss/javascript/langgraph/memory#memory-storage | Memory storage}.
+   * @param config.signal - An optional {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | `AbortSignal`} for the agent execution.
+   * @param config.streamMode - The streaming mode for the agent execution, see more in {@link https://docs.langchain.com/oss/javascript/langgraph/streaming#supported-stream-modes | Supported stream modes}.
+   * @param config.recursionLimit - The recursion limit for the agent execution.
+   *
+   * @returns A Promise that resolves to an IterableReadableStream of state updates.
+   *          Each update contains the current state after a node completes.
+   *
+   * @example
+   * ```typescript
+   * const agent = new ReactAgent({
+   *   llm: myModel,
+   *   tools: [calculator, webSearch]
+   * });
+   *
+   * const stream = await agent.stream({
+   *   messages: [{ role: "human", content: "What's 2+2 and the weather in NYC?" }]
+   * });
+   *
+   * for await (const chunk of stream) {
+   *   console.log(chunk); // State update from each node
+   * }
+   * ```
    */
+  stream(state: InvokeStateParameter<TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>>): Promise<IterableReadableStream<any>>;
+  /**
+   * Executes the agent with low-level event streaming, returning detailed events as they occur.
+   *
+   * This method provides fine-grained control over streaming, emitting events for every
+   * operation during execution. This is useful when you need to:
+   * - Stream individual LLM tokens as they're generated
+   * - Monitor detailed execution flow with timing information
+   * - Handle specific event types (model start/end, tool calls, etc.)
+   * - Debug or trace agent behavior at a granular level
+   *
+   * For simpler state-based streaming, use `stream` instead.
+   *
+   * @param state - The initial state for the agent execution. Can be:
+   *   - An object containing `messages` array and any middleware-specific state properties
+   *   - A Command object for more advanced control flow
+   *
+   * @param config - Optional runtime configuration including:
+   * @param config.context - The context for the agent execution.
+   * @param config.configurable - LangGraph configuration options like `thread_id`, `run_id`, etc.
+   * @param config.store - The store for the agent execution for persisting state, see more in {@link https://docs.langchain.com/oss/javascript/langgraph/memory#memory-storage | Memory storage}.
+   * @param config.signal - An optional {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | `AbortSignal`} for the agent execution.
+   * @param config.recursionLimit - The recursion limit for the agent execution.
+   * @param config.streamMode - The streaming mode for the agent execution, see more in {@link https://docs.langchain.com/oss/javascript/langgraph/streaming#supported-stream-modes | Supported stream modes}.
+   *
+   * @param streamOptions - Additional streaming options (passed to LangGraph's streamEvents).
+   *
+   * @returns An IterableReadableStream of detailed events including:
+   *          - `on_chat_model_start`: When the LLM begins processing
+   *          - `on_chat_model_stream`: Streaming tokens from the LLM
+   *          - `on_chat_model_end`: When the LLM completes
+   *          - `on_tool_start`: When a tool execution begins
+   *          - `on_tool_end`: When a tool execution completes
+   *          - `on_chain_start`: When middleware chains begin
+   *          - `on_chain_end`: When middleware chains complete
+   *          - And other LangGraph v2 stream events
+   *
+   * @example
+   * ```typescript
+   * const agent = new ReactAgent({
+   *   llm: myModel,
+   *   tools: [calculator, webSearch]
+   * });
+   *
+   * const stream = await agent.streamEvents({
+   *   messages: [{ role: "human", content: "What's 2+2 and the weather in NYC?" }]
+   * }, {
+   *   version: "v2"
+   * });
+   *
+   * for await (const event of stream) {
+   *   if (event.event === "on_chat_model_stream") {
+   *     process.stdout.write(event.data.chunk.content); // Stream tokens
+   *   }
+   * }
+   * ```
+   */
+  streamEvents(state: InvokeStateParameter<TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>> & {
+    version?: "v1" | "v2";
+  }, streamOptions?: any): Promise<IterableReadableStream<any>>;
   /**
    * Visualize the graph as a PNG image.
    * @param params - Parameters for the drawMermaidPng method.
@@ -61,6 +202,32 @@ declare class ReactAgent<StructuredResponseFormat extends Record<string, any> |
     wrapLabelNWords?: number;
     backgroundColor?: string;
   }): Promise<string>;
+  /**
+   * The following are internal methods to enable support for LangGraph Platform.
+   * They are not part of the createAgent public API.
+   *
+   * Note: we intentionally return as `never` to avoid type errors due to type inference.
+   */
+  /**
+   * @internal
+   */
+  getGraphAsync(config?: RunnableConfig): never;
+  /**
+   * @internal
+   */
+  getState(config: RunnableConfig, options?: GetStateOptions): never;
+  /**
+   * @internal
+   */
+  getStateHistory(config: RunnableConfig, options?: CheckpointListOptions): never;
+  /**
+   * @internal
+   */
+  getSubgraphs(namespace?: string, recurse?: boolean): never;
+  /**
+   * @internal
+   */
+  getSubgraphAsync(namespace?: string, recurse?: boolean): never;
 }
 //#endregion
 export { ReactAgent };

package/dist/agents/middlewareAgent/ReactAgent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactAgent.d.ts","names":["InteropZodObject","Command","CompiledStateGraph","LangGraphRunnableConfig","CreateAgentParams","AgentMiddleware","InferMiddlewareStates","InferMiddlewareInputStates","BuiltInState","InferMiddlewareContextInputs","IsAllOptional","InferContextInput","AnyAnnotationRoot","ToAnnotationRoot","ResponseFormatUndefined","MergedAgentState","Record","StructuredResponseFormat","TMiddleware","InvokeStateParameter","AgentGraph","ContextSchema","ReactAgent","Promise","ArrayBuffer","Uint8Array"],"sources":["../../../src/agents/middlewareAgent/ReactAgent.d.ts"],"sourcesContent":["/* eslint-disable no-instanceof/no-instanceof */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { InteropZodObject } from \"@langchain/core/utils/types\";\nimport { Command, CompiledStateGraph, type LangGraphRunnableConfig } from \"@langchain/langgraph\";\nimport { CreateAgentParams, AgentMiddleware, InferMiddlewareStates, InferMiddlewareInputStates, BuiltInState, InferMiddlewareContextInputs, IsAllOptional, InferContextInput } from \"./types.js\";\nimport { type AnyAnnotationRoot, type ToAnnotationRoot } from \"../annotation.js\";\nimport type { ResponseFormatUndefined } from \"../responses.js\";\n// Helper type to get the state definition with middleware states\ntype MergedAgentState<StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined, TMiddleware extends readonly AgentMiddleware<any, any, any>[]> = (StructuredResponseFormat extends ResponseFormatUndefined ? BuiltInState : BuiltInState & {\n    structuredResponse: StructuredResponseFormat;\n}) & InferMiddlewareStates<TMiddleware>;\ntype InvokeStateParameter<TMiddleware extends readonly AgentMiddleware<any, any, any>[]> = (BuiltInState & InferMiddlewareInputStates<TMiddleware>) | Command<any, any, any> | null;\ntype AgentGraph<StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = []> = CompiledStateGraph<any, any, any, any, MergedAgentState<StructuredResponseFormat, TMiddleware>, ToAnnotationRoot<ContextSchema>[\"spec\"], unknown>;\nexport declare class ReactAgent<StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = []> {\n    #private;\n    options: CreateAgentParams<StructuredResponseFormat, ContextSchema>;\n    constructor(options: CreateAgentParams<StructuredResponseFormat, ContextSchema>);\n    /**\n     * Get the compiled graph.\n     */\n    get graph(): AgentGraph<StructuredResponseFormat, ContextSchema, TMiddleware>;\n    /**\n     * @inheritdoc\n     */\n    get invoke(): IsAllOptional<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>> extends true ? (state: InvokeStateParameter<TMiddleware>, config?: LangGraphRunnableConfig<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>> | undefined) => Promise<MergedAgentState<StructuredResponseFormat, TMiddleware>> : (state: InvokeStateParameter<TMiddleware>, config?: LangGraphRunnableConfig<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>> | undefined) => Promise<MergedAgentState<StructuredResponseFormat, TMiddleware>>;\n    /**\n     * ToDo(@christian-bromann): Add stream and streamEvents methods\n     */\n    /**\n     * Visualize the graph as a PNG image.\n     * @param params - Parameters for the drawMermaidPng method.\n     * @param params.withStyles - Whether to include styles in the graph.\n     * @param params.curveStyle - The style of the graph's curves.\n     * @param params.nodeColors - The colors of the graph's nodes.\n     * @param params.wrapLabelNWords - The maximum number of words to wrap in a node's label.\n     * @param params.backgroundColor - The background color of the graph.\n     * @returns PNG image as a buffer\n     */\n    drawMermaidPng(params?: {\n        withStyles?: boolean;\n        curveStyle?: string;\n        nodeColors?: Record<string, string>;\n        wrapLabelNWords?: number;\n        backgroundColor?: string;\n    }): Promise<Uint8Array<ArrayBuffer>>;\n    /**\n     * Draw the graph as a Mermaid string.\n     * @param params - Parameters for the drawMermaid method.\n     * @param params.withStyles - Whether to include styles in the graph.\n     * @param params.curveStyle - The style of the graph's curves.\n     * @param params.nodeColors - The colors of the graph's nodes.\n     * @param params.wrapLabelNWords - The maximum number of words to wrap in a node's label.\n     * @param params.backgroundColor - The background color of the graph.\n     * @returns Mermaid string\n     */\n    drawMermaid(params?: {\n        withStyles?: boolean;\n        curveStyle?: string;\n        nodeColors?: Record<string, string>;\n        wrapLabelNWords?: number;\n        backgroundColor?: string;\n    }): Promise<string>;\n}\nexport {};\n"],"mappings":"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"}
+{"version":3,"file":"ReactAgent.d.ts","names":["InteropZodObject","Command","CompiledStateGraph","GetStateOptions","CheckpointListOptions","IterableReadableStream","RunnableConfig","CreateAgentParams","AgentMiddleware","InferMiddlewareStates","InferMiddlewareInputStates","BuiltInState","InferMiddlewareContextInputs","InferContextInput","InvokeConfiguration","StreamConfiguration","UserInput","AnyAnnotationRoot","ToAnnotationRoot","ResponseFormatUndefined","MergedAgentState","Record","StructuredResponseFormat","Omit","TMiddleware","InvokeStateParameter","AgentGraph","ContextSchema","ReactAgent","Promise","ArrayBuffer","Uint8Array"],"sources":["../../../src/agents/middlewareAgent/ReactAgent.d.ts"],"sourcesContent":["/* eslint-disable no-instanceof/no-instanceof */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { InteropZodObject } from \"@langchain/core/utils/types\";\nimport { Command, CompiledStateGraph, type GetStateOptions } from \"@langchain/langgraph\";\nimport type { CheckpointListOptions } from \"@langchain/langgraph-checkpoint\";\nimport { IterableReadableStream } from \"@langchain/core/utils/stream\";\nimport type { RunnableConfig } from \"@langchain/core/runnables\";\nimport type { CreateAgentParams, AgentMiddleware, InferMiddlewareStates, InferMiddlewareInputStates, BuiltInState, InferMiddlewareContextInputs, InferContextInput, InvokeConfiguration, StreamConfiguration, UserInput } from \"./types.js\";\nimport { type AnyAnnotationRoot, type ToAnnotationRoot, type ResponseFormatUndefined } from \"../annotation.js\";\n// Helper type to get the state definition with middleware states\ntype MergedAgentState<StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined, TMiddleware extends readonly AgentMiddleware<any, any, any>[]> = (StructuredResponseFormat extends ResponseFormatUndefined ? Omit<BuiltInState, \"jumpTo\"> : Omit<BuiltInState, \"jumpTo\"> & {\n    structuredResponse: StructuredResponseFormat;\n}) & InferMiddlewareStates<TMiddleware>;\ntype InvokeStateParameter<TMiddleware extends readonly AgentMiddleware<any, any, any>[]> = (UserInput & InferMiddlewareInputStates<TMiddleware>) | Command<any, any, any> | null;\ntype AgentGraph<StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = []> = CompiledStateGraph<any, any, any, any, MergedAgentState<StructuredResponseFormat, TMiddleware>, ToAnnotationRoot<ContextSchema>[\"spec\"], unknown>;\nexport declare class ReactAgent<StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]> {\n    #private;\n    options: CreateAgentParams<StructuredResponseFormat, ContextSchema>;\n    constructor(options: CreateAgentParams<StructuredResponseFormat, ContextSchema>);\n    /**\n     * Get the compiled {@link https://docs.langchain.com/oss/javascript/langgraph/use-graph-api | StateGraph}.\n     */\n    get graph(): AgentGraph<StructuredResponseFormat, ContextSchema, TMiddleware>;\n    /**\n     * Executes the agent with the given state and returns the final state after all processing.\n     *\n     * This method runs the agent's entire workflow synchronously, including:\n     * - Processing the input messages through any configured middleware\n     * - Calling the language model to generate responses\n     * - Executing any tool calls made by the model\n     * - Running all middleware hooks (beforeModel, afterModel, etc.)\n     *\n     * @param state - The initial state for the agent execution. Can be:\n     *   - An object containing `messages` array and any middleware-specific state properties\n     *   - A Command object for more advanced control flow\n     *\n     * @param config - Optional runtime configuration including:\n     * @param config.context - The context for the agent execution.\n     * @param config.configurable - LangGraph configuration options like `thread_id`, `run_id`, etc.\n     * @param config.store - The store for the agent execution for persisting state, see more in {@link https://docs.langchain.com/oss/javascript/langgraph/memory#memory-storage | Memory storage}.\n     * @param config.signal - An optional {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | `AbortSignal`} for the agent execution.\n     * @param config.recursionLimit - The recursion limit for the agent execution.\n     *\n     * @returns A Promise that resolves to the final agent state after execution completes.\n     *          The returned state includes:\n     *          - a `messages` property containing an array with all messages (input, AI responses, tool calls/results)\n     *          - a `structuredResponse` property containing the structured response (if configured)\n     *          - all state values defined in the middleware\n     *\n     * @example\n     * ```typescript\n     * const agent = new ReactAgent({\n     *   llm: myModel,\n     *   tools: [calculator, webSearch],\n     *   responseFormat: z.object({\n     *     weather: z.string(),\n     *   }),\n     * });\n     *\n     * const result = await agent.invoke({\n     *   messages: [{ role: \"human\", content: \"What's the weather in Paris?\" }]\n     * });\n     *\n     * console.log(result.structuredResponse.weather); // outputs: \"It's sunny and 75°F.\"\n     * ```\n     */\n    invoke(state: InvokeStateParameter<TMiddleware>, config?: InvokeConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>>): Promise<MergedAgentState<StructuredResponseFormat, TMiddleware>>;\n    /**\n     * Executes the agent with streaming, returning an async iterable of state updates as they occur.\n     *\n     * This method runs the agent's workflow similar to `invoke`, but instead of waiting for\n     * completion, it streams high-level state updates in real-time. This allows you to:\n     * - Display intermediate results to users as they're generated\n     * - Monitor the agent's progress through each step\n     * - React to state changes as nodes complete\n     *\n     * For more granular event-level streaming (like individual LLM tokens), use `streamEvents` instead.\n     *\n     * @param state - The initial state for the agent execution. Can be:\n     *   - An object containing `messages` array and any middleware-specific state properties\n     *   - A Command object for more advanced control flow\n     *\n     * @param config - Optional runtime configuration including:\n     * @param config.context - The context for the agent execution.\n     * @param config.configurable - LangGraph configuration options like `thread_id`, `run_id`, etc.\n     * @param config.store - The store for the agent execution for persisting state, see more in {@link https://docs.langchain.com/oss/javascript/langgraph/memory#memory-storage | Memory storage}.\n     * @param config.signal - An optional {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | `AbortSignal`} for the agent execution.\n     * @param config.streamMode - The streaming mode for the agent execution, see more in {@link https://docs.langchain.com/oss/javascript/langgraph/streaming#supported-stream-modes | Supported stream modes}.\n     * @param config.recursionLimit - The recursion limit for the agent execution.\n     *\n     * @returns A Promise that resolves to an IterableReadableStream of state updates.\n     *          Each update contains the current state after a node completes.\n     *\n     * @example\n     * ```typescript\n     * const agent = new ReactAgent({\n     *   llm: myModel,\n     *   tools: [calculator, webSearch]\n     * });\n     *\n     * const stream = await agent.stream({\n     *   messages: [{ role: \"human\", content: \"What's 2+2 and the weather in NYC?\" }]\n     * });\n     *\n     * for await (const chunk of stream) {\n     *   console.log(chunk); // State update from each node\n     * }\n     * ```\n     */\n    stream(state: InvokeStateParameter<TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>>): Promise<IterableReadableStream<any>>;\n    /**\n     * Executes the agent with low-level event streaming, returning detailed events as they occur.\n     *\n     * This method provides fine-grained control over streaming, emitting events for every\n     * operation during execution. This is useful when you need to:\n     * - Stream individual LLM tokens as they're generated\n     * - Monitor detailed execution flow with timing information\n     * - Handle specific event types (model start/end, tool calls, etc.)\n     * - Debug or trace agent behavior at a granular level\n     *\n     * For simpler state-based streaming, use `stream` instead.\n     *\n     * @param state - The initial state for the agent execution. Can be:\n     *   - An object containing `messages` array and any middleware-specific state properties\n     *   - A Command object for more advanced control flow\n     *\n     * @param config - Optional runtime configuration including:\n     * @param config.context - The context for the agent execution.\n     * @param config.configurable - LangGraph configuration options like `thread_id`, `run_id`, etc.\n     * @param config.store - The store for the agent execution for persisting state, see more in {@link https://docs.langchain.com/oss/javascript/langgraph/memory#memory-storage | Memory storage}.\n     * @param config.signal - An optional {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | `AbortSignal`} for the agent execution.\n     * @param config.recursionLimit - The recursion limit for the agent execution.\n     * @param config.streamMode - The streaming mode for the agent execution, see more in {@link https://docs.langchain.com/oss/javascript/langgraph/streaming#supported-stream-modes | Supported stream modes}.\n     *\n     * @param streamOptions - Additional streaming options (passed to LangGraph's streamEvents).\n     *\n     * @returns An IterableReadableStream of detailed events including:\n     *          - `on_chat_model_start`: When the LLM begins processing\n     *          - `on_chat_model_stream`: Streaming tokens from the LLM\n     *          - `on_chat_model_end`: When the LLM completes\n     *          - `on_tool_start`: When a tool execution begins\n     *          - `on_tool_end`: When a tool execution completes\n     *          - `on_chain_start`: When middleware chains begin\n     *          - `on_chain_end`: When middleware chains complete\n     *          - And other LangGraph v2 stream events\n     *\n     * @example\n     * ```typescript\n     * const agent = new ReactAgent({\n     *   llm: myModel,\n     *   tools: [calculator, webSearch]\n     * });\n     *\n     * const stream = await agent.streamEvents({\n     *   messages: [{ role: \"human\", content: \"What's 2+2 and the weather in NYC?\" }]\n     * }, {\n     *   version: \"v2\"\n     * });\n     *\n     * for await (const event of stream) {\n     *   if (event.event === \"on_chat_model_stream\") {\n     *     process.stdout.write(event.data.chunk.content); // Stream tokens\n     *   }\n     * }\n     * ```\n     */\n    streamEvents(state: InvokeStateParameter<TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>> & {\n        version?: \"v1\" | \"v2\";\n    }, streamOptions?: any): Promise<IterableReadableStream<any>>;\n    /**\n     * Visualize the graph as a PNG image.\n     * @param params - Parameters for the drawMermaidPng method.\n     * @param params.withStyles - Whether to include styles in the graph.\n     * @param params.curveStyle - The style of the graph's curves.\n     * @param params.nodeColors - The colors of the graph's nodes.\n     * @param params.wrapLabelNWords - The maximum number of words to wrap in a node's label.\n     * @param params.backgroundColor - The background color of the graph.\n     * @returns PNG image as a buffer\n     */\n    drawMermaidPng(params?: {\n        withStyles?: boolean;\n        curveStyle?: string;\n        nodeColors?: Record<string, string>;\n        wrapLabelNWords?: number;\n        backgroundColor?: string;\n    }): Promise<Uint8Array<ArrayBuffer>>;\n    /**\n     * Draw the graph as a Mermaid string.\n     * @param params - Parameters for the drawMermaid method.\n     * @param params.withStyles - Whether to include styles in the graph.\n     * @param params.curveStyle - The style of the graph's curves.\n     * @param params.nodeColors - The colors of the graph's nodes.\n     * @param params.wrapLabelNWords - The maximum number of words to wrap in a node's label.\n     * @param params.backgroundColor - The background color of the graph.\n     * @returns Mermaid string\n     */\n    drawMermaid(params?: {\n        withStyles?: boolean;\n        curveStyle?: string;\n        nodeColors?: Record<string, string>;\n        wrapLabelNWords?: number;\n        backgroundColor?: string;\n    }): Promise<string>;\n    /**\n     * The following are internal methods to enable support for LangGraph Platform.\n     * They are not part of the createAgent public API.\n     *\n     * Note: we intentionally return as `never` to avoid type errors due to type inference.\n     */\n    /**\n     * @internal\n     */\n    getGraphAsync(config?: RunnableConfig): never;\n    /**\n     * @internal\n     */\n    getState(config: RunnableConfig, options?: GetStateOptions): never;\n    /**\n     * @internal\n     */\n    getStateHistory(config: RunnableConfig, options?: CheckpointListOptions): never;\n    /**\n     * @internal\n     */\n    getSubgraphs(namespace?: string, recurse?: boolean): never;\n    /**\n     * @internal\n     */\n    getSubgraphAsync(namespace?: string, recurse?: boolean): never;\n}\nexport {};\n"],"mappings":"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"}