langchain 1.0.4 → 1.0.6

package/dist/agents/ReactAgent.d.cts

@@ -6,7 +6,7 @@ import { Runnable, RunnableConfig } from "@langchain/core/runnables";
 import { IterableReadableStream } from "@langchain/core/utils/stream";
 import { StreamEvent } from "@langchain/core/tracers/log_stream";
 import { InteropZodObject } from "@langchain/core/utils/types";
-import { Command, CompiledStateGraph, GetStateOptions, LangGraphRunnableConfig } from "@langchain/langgraph";
+import { Command, CompiledStateGraph, GetStateOptions, LangGraphRunnableConfig, StreamMode, StreamOutputMap } from "@langchain/langgraph";
 import { CheckpointListOptions } from "@langchain/langgraph-checkpoint";
 
 //#region src/agents/ReactAgent.d.ts
@@ -111,7 +111,7 @@ declare class ReactAgent<StructuredResponseFormat extends Record<string, any> |
    * }
    * ```
    */
-  stream(state: InvokeStateParameter<StateSchema, TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>>): Promise<IterableReadableStream<any>>;
+  stream<TStreamMode extends StreamMode | StreamMode[] | undefined, TEncoding extends "text/event-stream" | undefined>(state: InvokeStateParameter<StateSchema, TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>, TStreamMode, TEncoding>): Promise<IterableReadableStream<StreamOutputMap<TStreamMode, false, MergedAgentState<StateSchema, StructuredResponseFormat, TMiddleware>, MergedAgentState<StateSchema, StructuredResponseFormat, TMiddleware>, string, unknown, unknown, TEncoding>>>;
   /**
    * Visualize the graph as a PNG image.
    * @param params - Parameters for the drawMermaidPng method.
@@ -155,7 +155,7 @@ declare class ReactAgent<StructuredResponseFormat extends Record<string, any> |
   /**
    * @internal
    */
-  streamEvents(state: InvokeStateParameter<StateSchema, TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>> & {
+  streamEvents(state: InvokeStateParameter<StateSchema, TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>, StreamMode | StreamMode[] | undefined, "text/event-stream" | undefined> & {
     version?: "v1" | "v2";
   }, streamOptions?: Parameters<Runnable["streamEvents"]>[2]): IterableReadableStream<StreamEvent>;
   /**

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

@@ -1 +1 @@
-{"version":3,"file":"ReactAgent.d.cts","names":["InteropZodObject","Command","CompiledStateGraph","GetStateOptions","LangGraphRunnableConfig","CheckpointListOptions","IterableReadableStream","Runnable","RunnableConfig","StreamEvent","CreateAgentParams","BuiltInState","UserInput","InvokeConfiguration","StreamConfiguration","AgentMiddleware","InferMiddlewareContextInputs","InferMiddlewareStates","InferMiddlewareInputStates","InferContextInput","AnyAnnotationRoot","InferSchemaInput","ToAnnotationRoot","ResponseFormatUndefined","MergedAgentState","Record","StateSchema","StructuredResponseFormat","Omit","TMiddleware","InvokeStateParameter","AgentGraph","ContextSchema","ReactAgent","Promise","ArrayBuffer","Uint8Array","Parameters"],"sources":["../../src/agents/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, type LangGraphRunnableConfig } from \"@langchain/langgraph\";\nimport type { CheckpointListOptions } from \"@langchain/langgraph-checkpoint\";\nimport { IterableReadableStream } from \"@langchain/core/utils/stream\";\nimport type { Runnable, RunnableConfig } from \"@langchain/core/runnables\";\nimport type { StreamEvent } from \"@langchain/core/tracers/log_stream\";\nimport type { CreateAgentParams, BuiltInState, UserInput } from \"./types.js\";\nimport type { InvokeConfiguration, StreamConfiguration } from \"./runtime.js\";\nimport type { AgentMiddleware, InferMiddlewareContextInputs, InferMiddlewareStates, InferMiddlewareInputStates, InferContextInput, AnyAnnotationRoot, InferSchemaInput, ToAnnotationRoot } from \"./middleware/types.js\";\nimport { type ResponseFormatUndefined } from \"./responses.js\";\n// Helper type to get the state definition with middleware states\ntype MergedAgentState<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined, StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined, TMiddleware extends readonly AgentMiddleware[]> = InferSchemaInput<StateSchema> & (StructuredResponseFormat extends ResponseFormatUndefined ? Omit<BuiltInState, \"jumpTo\"> : Omit<BuiltInState, \"jumpTo\"> & {\n    structuredResponse: StructuredResponseFormat;\n}) & InferMiddlewareStates<TMiddleware>;\ntype InvokeStateParameter<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined, TMiddleware extends readonly AgentMiddleware[]> = (UserInput<StateSchema> & InferMiddlewareInputStates<TMiddleware>) | Command<any, any, any> | null;\ntype AgentGraph<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = []> = CompiledStateGraph<any, any, any, any, MergedAgentState<StateSchema, StructuredResponseFormat, TMiddleware>, ToAnnotationRoot<ContextSchema>[\"spec\"], unknown>;\nexport declare class ReactAgent<StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]> {\n    #private;\n    options: CreateAgentParams<StructuredResponseFormat, StateSchema, ContextSchema>;\n    constructor(options: CreateAgentParams<StructuredResponseFormat, StateSchema, ContextSchema>);\n    /**\n     * Get the compiled {@link https://docs.langchain.com/oss/javascript/langgraph/use-graph-api | StateGraph}.\n     */\n    get graph(): AgentGraph<StateSchema, 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<StateSchema, TMiddleware>, config?: InvokeConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>>): Promise<MergedAgentState<StateSchema, 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<StateSchema, TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>>): 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    streamEvents(state: InvokeStateParameter<StateSchema, TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>> & {\n        version?: \"v1\" | \"v2\";\n    }, streamOptions?: Parameters<Runnable[\"streamEvents\"]>[2]): IterableReadableStream<StreamEvent>;\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    /**\n     * @internal\n     */\n    updateState(inputConfig: LangGraphRunnableConfig, values: Record<string, unknown> | unknown, asNode?: string): never;\n}\nexport {};\n"],"mappings":"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"}
+{"version":3,"file":"ReactAgent.d.cts","names":["InteropZodObject","Command","CompiledStateGraph","GetStateOptions","LangGraphRunnableConfig","StreamMode","StreamOutputMap","CheckpointListOptions","IterableReadableStream","Runnable","RunnableConfig","StreamEvent","CreateAgentParams","BuiltInState","UserInput","InvokeConfiguration","StreamConfiguration","AgentMiddleware","InferMiddlewareContextInputs","InferMiddlewareStates","InferMiddlewareInputStates","InferContextInput","AnyAnnotationRoot","InferSchemaInput","ToAnnotationRoot","ResponseFormatUndefined","MergedAgentState","Record","StateSchema","StructuredResponseFormat","Omit","TMiddleware","InvokeStateParameter","AgentGraph","ContextSchema","ReactAgent","Promise","TStreamMode","TEncoding","ArrayBuffer","Uint8Array","Parameters"],"sources":["../../src/agents/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, type LangGraphRunnableConfig, type StreamMode, type StreamOutputMap } from \"@langchain/langgraph\";\nimport type { CheckpointListOptions } from \"@langchain/langgraph-checkpoint\";\nimport { IterableReadableStream } from \"@langchain/core/utils/stream\";\nimport type { Runnable, RunnableConfig } from \"@langchain/core/runnables\";\nimport type { StreamEvent } from \"@langchain/core/tracers/log_stream\";\nimport type { CreateAgentParams, BuiltInState, UserInput } from \"./types.js\";\nimport type { InvokeConfiguration, StreamConfiguration } from \"./runtime.js\";\nimport type { AgentMiddleware, InferMiddlewareContextInputs, InferMiddlewareStates, InferMiddlewareInputStates, InferContextInput, AnyAnnotationRoot, InferSchemaInput, ToAnnotationRoot } from \"./middleware/types.js\";\nimport { type ResponseFormatUndefined } from \"./responses.js\";\n// Helper type to get the state definition with middleware states\ntype MergedAgentState<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined, StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined, TMiddleware extends readonly AgentMiddleware[]> = InferSchemaInput<StateSchema> & (StructuredResponseFormat extends ResponseFormatUndefined ? Omit<BuiltInState, \"jumpTo\"> : Omit<BuiltInState, \"jumpTo\"> & {\n    structuredResponse: StructuredResponseFormat;\n}) & InferMiddlewareStates<TMiddleware>;\ntype InvokeStateParameter<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined, TMiddleware extends readonly AgentMiddleware[]> = (UserInput<StateSchema> & InferMiddlewareInputStates<TMiddleware>) | Command<any, any, any> | null;\ntype AgentGraph<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = []> = CompiledStateGraph<any, any, any, any, MergedAgentState<StateSchema, StructuredResponseFormat, TMiddleware>, ToAnnotationRoot<ContextSchema>[\"spec\"], unknown>;\nexport declare class ReactAgent<StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]> {\n    #private;\n    options: CreateAgentParams<StructuredResponseFormat, StateSchema, ContextSchema>;\n    constructor(options: CreateAgentParams<StructuredResponseFormat, StateSchema, ContextSchema>);\n    /**\n     * Get the compiled {@link https://docs.langchain.com/oss/javascript/langgraph/use-graph-api | StateGraph}.\n     */\n    get graph(): AgentGraph<StateSchema, 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<StateSchema, TMiddleware>, config?: InvokeConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>>): Promise<MergedAgentState<StateSchema, 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<TStreamMode extends StreamMode | StreamMode[] | undefined, TEncoding extends \"text/event-stream\" | undefined>(state: InvokeStateParameter<StateSchema, TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>, TStreamMode, TEncoding>): Promise<IterableReadableStream<StreamOutputMap<TStreamMode, false, MergedAgentState<StateSchema, StructuredResponseFormat, TMiddleware>, MergedAgentState<StateSchema, StructuredResponseFormat, TMiddleware>, string, unknown, unknown, TEncoding>>>;\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    streamEvents(state: InvokeStateParameter<StateSchema, TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>, StreamMode | StreamMode[] | undefined, \"text/event-stream\" | undefined> & {\n        version?: \"v1\" | \"v2\";\n    }, streamOptions?: Parameters<Runnable[\"streamEvents\"]>[2]): IterableReadableStream<StreamEvent>;\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    /**\n     * @internal\n     */\n    updateState(inputConfig: LangGraphRunnableConfig, values: Record<string, unknown> | unknown, asNode?: string): never;\n}\nexport {};\n"],"mappings":"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"}

package/dist/agents/ReactAgent.d.ts

@@ -4,7 +4,7 @@ import { AgentMiddleware, AnyAnnotationRoot, InferContextInput, InferMiddlewareC
 import { BuiltInState, CreateAgentParams, UserInput } from "./types.js";
 import { Runnable, RunnableConfig } from "@langchain/core/runnables";
 import { IterableReadableStream } from "@langchain/core/utils/stream";
-import { Command, CompiledStateGraph, GetStateOptions, LangGraphRunnableConfig } from "@langchain/langgraph";
+import { Command, CompiledStateGraph, GetStateOptions, LangGraphRunnableConfig, StreamMode, StreamOutputMap } from "@langchain/langgraph";
 import { InteropZodObject } from "@langchain/core/utils/types";
 import { CheckpointListOptions } from "@langchain/langgraph-checkpoint";
 import { StreamEvent } from "@langchain/core/tracers/log_stream";
@@ -111,7 +111,7 @@ declare class ReactAgent<StructuredResponseFormat extends Record<string, any> |
    * }
    * ```
    */
-  stream(state: InvokeStateParameter<StateSchema, TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>>): Promise<IterableReadableStream<any>>;
+  stream<TStreamMode extends StreamMode | StreamMode[] | undefined, TEncoding extends "text/event-stream" | undefined>(state: InvokeStateParameter<StateSchema, TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>, TStreamMode, TEncoding>): Promise<IterableReadableStream<StreamOutputMap<TStreamMode, false, MergedAgentState<StateSchema, StructuredResponseFormat, TMiddleware>, MergedAgentState<StateSchema, StructuredResponseFormat, TMiddleware>, string, unknown, unknown, TEncoding>>>;
   /**
    * Visualize the graph as a PNG image.
    * @param params - Parameters for the drawMermaidPng method.
@@ -155,7 +155,7 @@ declare class ReactAgent<StructuredResponseFormat extends Record<string, any> |
   /**
    * @internal
    */
-  streamEvents(state: InvokeStateParameter<StateSchema, TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>> & {
+  streamEvents(state: InvokeStateParameter<StateSchema, TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>, StreamMode | StreamMode[] | undefined, "text/event-stream" | undefined> & {
     version?: "v1" | "v2";
   }, streamOptions?: Parameters<Runnable["streamEvents"]>[2]): IterableReadableStream<StreamEvent>;
   /**

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

@@ -1 +1 @@
-{"version":3,"file":"ReactAgent.d.ts","names":["InteropZodObject","Command","CompiledStateGraph","GetStateOptions","LangGraphRunnableConfig","CheckpointListOptions","IterableReadableStream","Runnable","RunnableConfig","StreamEvent","CreateAgentParams","BuiltInState","UserInput","InvokeConfiguration","StreamConfiguration","AgentMiddleware","InferMiddlewareContextInputs","InferMiddlewareStates","InferMiddlewareInputStates","InferContextInput","AnyAnnotationRoot","InferSchemaInput","ToAnnotationRoot","ResponseFormatUndefined","MergedAgentState","Record","StateSchema","StructuredResponseFormat","Omit","TMiddleware","InvokeStateParameter","AgentGraph","ContextSchema","ReactAgent","Promise","ArrayBuffer","Uint8Array","Parameters"],"sources":["../../src/agents/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, type LangGraphRunnableConfig } from \"@langchain/langgraph\";\nimport type { CheckpointListOptions } from \"@langchain/langgraph-checkpoint\";\nimport { IterableReadableStream } from \"@langchain/core/utils/stream\";\nimport type { Runnable, RunnableConfig } from \"@langchain/core/runnables\";\nimport type { StreamEvent } from \"@langchain/core/tracers/log_stream\";\nimport type { CreateAgentParams, BuiltInState, UserInput } from \"./types.js\";\nimport type { InvokeConfiguration, StreamConfiguration } from \"./runtime.js\";\nimport type { AgentMiddleware, InferMiddlewareContextInputs, InferMiddlewareStates, InferMiddlewareInputStates, InferContextInput, AnyAnnotationRoot, InferSchemaInput, ToAnnotationRoot } from \"./middleware/types.js\";\nimport { type ResponseFormatUndefined } from \"./responses.js\";\n// Helper type to get the state definition with middleware states\ntype MergedAgentState<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined, StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined, TMiddleware extends readonly AgentMiddleware[]> = InferSchemaInput<StateSchema> & (StructuredResponseFormat extends ResponseFormatUndefined ? Omit<BuiltInState, \"jumpTo\"> : Omit<BuiltInState, \"jumpTo\"> & {\n    structuredResponse: StructuredResponseFormat;\n}) & InferMiddlewareStates<TMiddleware>;\ntype InvokeStateParameter<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined, TMiddleware extends readonly AgentMiddleware[]> = (UserInput<StateSchema> & InferMiddlewareInputStates<TMiddleware>) | Command<any, any, any> | null;\ntype AgentGraph<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = []> = CompiledStateGraph<any, any, any, any, MergedAgentState<StateSchema, StructuredResponseFormat, TMiddleware>, ToAnnotationRoot<ContextSchema>[\"spec\"], unknown>;\nexport declare class ReactAgent<StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]> {\n    #private;\n    options: CreateAgentParams<StructuredResponseFormat, StateSchema, ContextSchema>;\n    constructor(options: CreateAgentParams<StructuredResponseFormat, StateSchema, ContextSchema>);\n    /**\n     * Get the compiled {@link https://docs.langchain.com/oss/javascript/langgraph/use-graph-api | StateGraph}.\n     */\n    get graph(): AgentGraph<StateSchema, 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<StateSchema, TMiddleware>, config?: InvokeConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>>): Promise<MergedAgentState<StateSchema, 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<StateSchema, TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>>): 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    streamEvents(state: InvokeStateParameter<StateSchema, TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>> & {\n        version?: \"v1\" | \"v2\";\n    }, streamOptions?: Parameters<Runnable[\"streamEvents\"]>[2]): IterableReadableStream<StreamEvent>;\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    /**\n     * @internal\n     */\n    updateState(inputConfig: LangGraphRunnableConfig, values: Record<string, unknown> | unknown, asNode?: string): never;\n}\nexport {};\n"],"mappings":"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"}
+{"version":3,"file":"ReactAgent.d.ts","names":["InteropZodObject","Command","CompiledStateGraph","GetStateOptions","LangGraphRunnableConfig","StreamMode","StreamOutputMap","CheckpointListOptions","IterableReadableStream","Runnable","RunnableConfig","StreamEvent","CreateAgentParams","BuiltInState","UserInput","InvokeConfiguration","StreamConfiguration","AgentMiddleware","InferMiddlewareContextInputs","InferMiddlewareStates","InferMiddlewareInputStates","InferContextInput","AnyAnnotationRoot","InferSchemaInput","ToAnnotationRoot","ResponseFormatUndefined","MergedAgentState","Record","StateSchema","StructuredResponseFormat","Omit","TMiddleware","InvokeStateParameter","AgentGraph","ContextSchema","ReactAgent","Promise","TStreamMode","TEncoding","ArrayBuffer","Uint8Array","Parameters"],"sources":["../../src/agents/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, type LangGraphRunnableConfig, type StreamMode, type StreamOutputMap } from \"@langchain/langgraph\";\nimport type { CheckpointListOptions } from \"@langchain/langgraph-checkpoint\";\nimport { IterableReadableStream } from \"@langchain/core/utils/stream\";\nimport type { Runnable, RunnableConfig } from \"@langchain/core/runnables\";\nimport type { StreamEvent } from \"@langchain/core/tracers/log_stream\";\nimport type { CreateAgentParams, BuiltInState, UserInput } from \"./types.js\";\nimport type { InvokeConfiguration, StreamConfiguration } from \"./runtime.js\";\nimport type { AgentMiddleware, InferMiddlewareContextInputs, InferMiddlewareStates, InferMiddlewareInputStates, InferContextInput, AnyAnnotationRoot, InferSchemaInput, ToAnnotationRoot } from \"./middleware/types.js\";\nimport { type ResponseFormatUndefined } from \"./responses.js\";\n// Helper type to get the state definition with middleware states\ntype MergedAgentState<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined, StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined, TMiddleware extends readonly AgentMiddleware[]> = InferSchemaInput<StateSchema> & (StructuredResponseFormat extends ResponseFormatUndefined ? Omit<BuiltInState, \"jumpTo\"> : Omit<BuiltInState, \"jumpTo\"> & {\n    structuredResponse: StructuredResponseFormat;\n}) & InferMiddlewareStates<TMiddleware>;\ntype InvokeStateParameter<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined, TMiddleware extends readonly AgentMiddleware[]> = (UserInput<StateSchema> & InferMiddlewareInputStates<TMiddleware>) | Command<any, any, any> | null;\ntype AgentGraph<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = []> = CompiledStateGraph<any, any, any, any, MergedAgentState<StateSchema, StructuredResponseFormat, TMiddleware>, ToAnnotationRoot<ContextSchema>[\"spec\"], unknown>;\nexport declare class ReactAgent<StructuredResponseFormat extends Record<string, any> | ResponseFormatUndefined = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]> {\n    #private;\n    options: CreateAgentParams<StructuredResponseFormat, StateSchema, ContextSchema>;\n    constructor(options: CreateAgentParams<StructuredResponseFormat, StateSchema, ContextSchema>);\n    /**\n     * Get the compiled {@link https://docs.langchain.com/oss/javascript/langgraph/use-graph-api | StateGraph}.\n     */\n    get graph(): AgentGraph<StateSchema, 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<StateSchema, TMiddleware>, config?: InvokeConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>>): Promise<MergedAgentState<StateSchema, 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<TStreamMode extends StreamMode | StreamMode[] | undefined, TEncoding extends \"text/event-stream\" | undefined>(state: InvokeStateParameter<StateSchema, TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>, TStreamMode, TEncoding>): Promise<IterableReadableStream<StreamOutputMap<TStreamMode, false, MergedAgentState<StateSchema, StructuredResponseFormat, TMiddleware>, MergedAgentState<StateSchema, StructuredResponseFormat, TMiddleware>, string, unknown, unknown, TEncoding>>>;\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    streamEvents(state: InvokeStateParameter<StateSchema, TMiddleware>, config?: StreamConfiguration<InferContextInput<ContextSchema> & InferMiddlewareContextInputs<TMiddleware>, StreamMode | StreamMode[] | undefined, \"text/event-stream\" | undefined> & {\n        version?: \"v1\" | \"v2\";\n    }, streamOptions?: Parameters<Runnable[\"streamEvents\"]>[2]): IterableReadableStream<StreamEvent>;\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    /**\n     * @internal\n     */\n    updateState(inputConfig: LangGraphRunnableConfig, values: Record<string, unknown> | unknown, asNode?: string): never;\n}\nexport {};\n"],"mappings":"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"}

package/dist/agents/ReactAgent.js

@@ -1,8 +1,8 @@
 import { createAgentAnnotationConditional } from "./annotation.js";
 import { isClientTool, validateLLMHasNoBoundTools, wrapToolCall } from "./utils.js";
 import { initializeMiddlewareStates, parseJumpToTarget } from "./nodes/utils.js";
-import { AgentNode } from "./nodes/AgentNode.js";
-import { ToolNode } from "./nodes/ToolNode.js";
+import { AGENT_NODE_NAME, AgentNode } from "./nodes/AgentNode.js";
+import { TOOLS_NODE_NAME, ToolNode } from "./nodes/ToolNode.js";
 import { getHookConstraint } from "./middleware/utils.js";
 import { BeforeAgentNode } from "./nodes/BeforeAgentNode.js";
 import { BeforeModelNode } from "./nodes/BeforeModelNode.js";
@@ -122,7 +122,7 @@ var ReactAgent = class {
 		/**
 		* Add Nodes
 		*/
-		allNodeWorkflows.addNode("model_request", this.#agentNode);
+		allNodeWorkflows.addNode(AGENT_NODE_NAME, this.#agentNode);
 		/**
 		* add single tool node for all tools
 		*/
@@ -131,7 +131,7 @@ var ReactAgent = class {
 				signal: this.options.signal,
 				wrapToolCall: wrapToolCall(middleware)
 			});
-			allNodeWorkflows.addNode("tools", toolNode);
+			allNodeWorkflows.addNode(TOOLS_NODE_NAME, toolNode);
 		}
 		/**
 		* Add Edges
@@ -139,93 +139,94 @@ var ReactAgent = class {
 		let entryNode;
 		if (beforeAgentNodes.length > 0) entryNode = beforeAgentNodes[0].name;
 		else if (beforeModelNodes.length > 0) entryNode = beforeModelNodes[0].name;
-		else entryNode = "model_request";
-		const loopEntryNode = beforeModelNodes.length > 0 ? beforeModelNodes[0].name : "model_request";
+		else entryNode = AGENT_NODE_NAME;
+		const loopEntryNode = beforeModelNodes.length > 0 ? beforeModelNodes[0].name : AGENT_NODE_NAME;
 		const exitNode = afterAgentNodes.length > 0 ? afterAgentNodes[afterAgentNodes.length - 1].name : END;
 		allNodeWorkflows.addEdge(START, entryNode);
+		const clientTools = toolClasses.filter(isClientTool);
 		for (let i = 0; i < beforeAgentNodes.length; i++) {
 			const node = beforeAgentNodes[i];
 			const current = node.name;
 			const isLast = i === beforeAgentNodes.length - 1;
 			const nextDefault = isLast ? loopEntryNode : beforeAgentNodes[i + 1].name;
 			if (node.allowed && node.allowed.length > 0) {
-				const hasTools = toolClasses.filter(isClientTool).length > 0;
-				const allowedMapped = node.allowed.map((t) => parseJumpToTarget(t)).filter((dest) => dest !== "tools" || hasTools);
+				const hasTools = clientTools.length > 0;
+				const allowedMapped = node.allowed.map((t) => parseJumpToTarget(t)).filter((dest) => dest !== TOOLS_NODE_NAME || hasTools);
 				const destinations = Array.from(new Set([nextDefault, ...allowedMapped.map((dest) => dest === END ? exitNode : dest)]));
-				allNodeWorkflows.addConditionalEdges(current, this.#createBeforeAgentRouter(toolClasses.filter(isClientTool), nextDefault, exitNode), destinations);
+				allNodeWorkflows.addConditionalEdges(current, this.#createBeforeAgentRouter(clientTools, nextDefault, exitNode), destinations);
 			} else allNodeWorkflows.addEdge(current, nextDefault);
 		}
 		for (let i = 0; i < beforeModelNodes.length; i++) {
 			const node = beforeModelNodes[i];
 			const current = node.name;
 			const isLast = i === beforeModelNodes.length - 1;
-			const nextDefault = isLast ? "model_request" : beforeModelNodes[i + 1].name;
+			const nextDefault = isLast ? AGENT_NODE_NAME : beforeModelNodes[i + 1].name;
 			if (node.allowed && node.allowed.length > 0) {
-				const hasTools = toolClasses.filter(isClientTool).length > 0;
-				const allowedMapped = node.allowed.map((t) => parseJumpToTarget(t)).filter((dest) => dest !== "tools" || hasTools);
+				const hasTools = clientTools.length > 0;
+				const allowedMapped = node.allowed.map((t) => parseJumpToTarget(t)).filter((dest) => dest !== TOOLS_NODE_NAME || hasTools);
 				const destinations = Array.from(new Set([nextDefault, ...allowedMapped]));
-				allNodeWorkflows.addConditionalEdges(current, this.#createBeforeModelRouter(toolClasses.filter(isClientTool), nextDefault), destinations);
+				allNodeWorkflows.addConditionalEdges(current, this.#createBeforeModelRouter(clientTools, nextDefault), destinations);
 			} else allNodeWorkflows.addEdge(current, nextDefault);
 		}
 		const lastAfterModelNode = afterModelNodes.at(-1);
-		if (afterModelNodes.length > 0 && lastAfterModelNode) allNodeWorkflows.addEdge("model_request", lastAfterModelNode.name);
+		if (afterModelNodes.length > 0 && lastAfterModelNode) allNodeWorkflows.addEdge(AGENT_NODE_NAME, lastAfterModelNode.name);
 		else {
-			const modelPaths = this.#getModelPaths(toolClasses.filter(isClientTool));
+			const modelPaths = this.#getModelPaths(clientTools);
 			const destinations = modelPaths.map((p) => p === END ? exitNode : p);
-			if (destinations.length === 1) allNodeWorkflows.addEdge("model_request", destinations[0]);
-			else allNodeWorkflows.addConditionalEdges("model_request", this.#createModelRouter(exitNode), destinations);
+			if (destinations.length === 1) allNodeWorkflows.addEdge(AGENT_NODE_NAME, destinations[0]);
+			else allNodeWorkflows.addConditionalEdges(AGENT_NODE_NAME, this.#createModelRouter(exitNode), destinations);
 		}
 		for (let i = afterModelNodes.length - 1; i > 0; i--) {
 			const node = afterModelNodes[i];
 			const current = node.name;
 			const nextDefault = afterModelNodes[i - 1].name;
 			if (node.allowed && node.allowed.length > 0) {
-				const hasTools = toolClasses.filter(isClientTool).length > 0;
-				const allowedMapped = node.allowed.map((t) => parseJumpToTarget(t)).filter((dest) => dest !== "tools" || hasTools);
+				const hasTools = clientTools.length > 0;
+				const allowedMapped = node.allowed.map((t) => parseJumpToTarget(t)).filter((dest) => dest !== TOOLS_NODE_NAME || hasTools);
 				const destinations = Array.from(new Set([nextDefault, ...allowedMapped]));
-				allNodeWorkflows.addConditionalEdges(current, this.#createAfterModelSequenceRouter(toolClasses.filter(isClientTool), node.allowed, nextDefault), destinations);
+				allNodeWorkflows.addConditionalEdges(current, this.#createAfterModelSequenceRouter(clientTools, node.allowed, nextDefault), destinations);
 			} else allNodeWorkflows.addEdge(current, nextDefault);
 		}
 		if (afterModelNodes.length > 0) {
 			const firstAfterModel = afterModelNodes[0];
 			const firstAfterModelNode = firstAfterModel.name;
-			const modelPaths = this.#getModelPaths(toolClasses.filter(isClientTool), true).filter((p) => p !== "tools" || toolClasses.filter(isClientTool).length > 0);
+			const modelPaths = this.#getModelPaths(clientTools, true).filter((p) => p !== TOOLS_NODE_NAME || toolClasses.filter(isClientTool).length > 0);
 			const allowJump = Boolean(firstAfterModel.allowed && firstAfterModel.allowed.length > 0);
 			const destinations = modelPaths.map((p) => p === END ? exitNode : p);
-			allNodeWorkflows.addConditionalEdges(firstAfterModelNode, this.#createAfterModelRouter(toolClasses.filter(isClientTool), allowJump, exitNode), destinations);
+			allNodeWorkflows.addConditionalEdges(firstAfterModelNode, this.#createAfterModelRouter(clientTools, allowJump, exitNode), destinations);
 		}
 		for (let i = afterAgentNodes.length - 1; i > 0; i--) {
 			const node = afterAgentNodes[i];
 			const current = node.name;
 			const nextDefault = afterAgentNodes[i - 1].name;
 			if (node.allowed && node.allowed.length > 0) {
-				const hasTools = toolClasses.filter(isClientTool).length > 0;
-				const allowedMapped = node.allowed.map((t) => parseJumpToTarget(t)).filter((dest) => dest !== "tools" || hasTools);
+				const hasTools = clientTools.length > 0;
+				const allowedMapped = node.allowed.map((t) => parseJumpToTarget(t)).filter((dest) => dest !== TOOLS_NODE_NAME || hasTools);
 				const destinations = Array.from(new Set([nextDefault, ...allowedMapped]));
-				allNodeWorkflows.addConditionalEdges(current, this.#createAfterModelSequenceRouter(toolClasses.filter(isClientTool), node.allowed, nextDefault), destinations);
+				allNodeWorkflows.addConditionalEdges(current, this.#createAfterModelSequenceRouter(clientTools, node.allowed, nextDefault), destinations);
 			} else allNodeWorkflows.addEdge(current, nextDefault);
 		}
 		if (afterAgentNodes.length > 0) {
 			const firstAfterAgent = afterAgentNodes[0];
 			const firstAfterAgentNode = firstAfterAgent.name;
 			if (firstAfterAgent.allowed && firstAfterAgent.allowed.length > 0) {
-				const hasTools = toolClasses.filter(isClientTool).length > 0;
-				const allowedMapped = firstAfterAgent.allowed.map((t) => parseJumpToTarget(t)).filter((dest) => dest !== "tools" || hasTools);
+				const hasTools = clientTools.length > 0;
+				const allowedMapped = firstAfterAgent.allowed.map((t) => parseJumpToTarget(t)).filter((dest) => dest !== TOOLS_NODE_NAME || hasTools);
 				/**
 				* For after_agent, only use explicitly allowed destinations (don't add loopEntryNode)
 				* The default destination (when no jump occurs) should be END
 				*/
 				const destinations = Array.from(new Set([END, ...allowedMapped]));
-				allNodeWorkflows.addConditionalEdges(firstAfterAgentNode, this.#createAfterModelSequenceRouter(toolClasses.filter(isClientTool), firstAfterAgent.allowed, END), destinations);
+				allNodeWorkflows.addConditionalEdges(firstAfterAgentNode, this.#createAfterModelSequenceRouter(clientTools, firstAfterAgent.allowed, END), destinations);
 			} else allNodeWorkflows.addEdge(firstAfterAgentNode, END);
 		}
 		/**
 		* add edges for tools node
 		*/
-		if (toolClasses.filter(isClientTool).length > 0) {
+		if (clientTools.length > 0) {
 			const toolReturnTarget = loopEntryNode;
-			if (shouldReturnDirect.size > 0) allNodeWorkflows.addConditionalEdges("tools", this.#createToolsRouter(shouldReturnDirect, exitNode), [toolReturnTarget, exitNode]);
-			else allNodeWorkflows.addEdge("tools", toolReturnTarget);
+			if (shouldReturnDirect.size > 0) allNodeWorkflows.addConditionalEdges(TOOLS_NODE_NAME, this.#createToolsRouter(shouldReturnDirect, exitNode), [toolReturnTarget, exitNode]);
+			else allNodeWorkflows.addEdge(TOOLS_NODE_NAME, toolReturnTarget);
 		}
 		/**
 		* compile the graph
@@ -251,8 +252,8 @@ var ReactAgent = class {
 	*/
 	#getModelPaths(toolClasses, includeModelRequest = false) {
 		const paths = [];
-		if (toolClasses.length > 0) paths.push("tools");
-		if (includeModelRequest) paths.push("model_request");
+		if (toolClasses.length > 0) paths.push(TOOLS_NODE_NAME);
+		if (includeModelRequest) paths.push(AGENT_NODE_NAME);
 		paths.push(END);
 		return paths;
 	}
@@ -260,14 +261,11 @@ var ReactAgent = class {
 	* Create routing function for tools node conditional edges.
 	*/
 	#createToolsRouter(shouldReturnDirect, exitNode) {
-		/**
-		* ToDo: fix type
-		*/
 		return (state) => {
 			const messages = state.messages;
 			const lastMessage = messages[messages.length - 1];
-			if (ToolMessage.isInstance(lastMessage) && lastMessage.name && shouldReturnDirect.has(lastMessage.name)) return this.options.responseFormat ? "model_request" : exitNode;
-			return "model_request";
+			if (ToolMessage.isInstance(lastMessage) && lastMessage.name && shouldReturnDirect.has(lastMessage.name)) return this.options.responseFormat ? AGENT_NODE_NAME : exitNode;
+			return AGENT_NODE_NAME;
 		};
 	}
 	/**
@@ -287,13 +285,13 @@ var ReactAgent = class {
 			/**
 			* The tool node processes a single message.
 			*/
-			if (this.#toolBehaviorVersion === "v1") return "tools";
+			if (this.#toolBehaviorVersion === "v1") return TOOLS_NODE_NAME;
 			/**
 			* Route to tools node (filter out any structured response tool calls)
 			*/
 			const regularToolCalls = lastMessage.tool_calls.filter((toolCall) => !toolCall.name.startsWith("extract-"));
 			if (regularToolCalls.length === 0) return exitNode;
-			return regularToolCalls.map((toolCall) => new Send("tools", {
+			return regularToolCalls.map((toolCall) => new Send(TOOLS_NODE_NAME, {
 				...state,
 				lg_tool_call: toolCall
 			}));
@@ -321,14 +319,14 @@ var ReactAgent = class {
 			if (AIMessage.isInstance(lastMessage) && (!lastMessage.tool_calls || lastMessage.tool_calls.length === 0)) return exitNode;
 			if (allowJump && state.jumpTo) {
 				if (state.jumpTo === END) return exitNode;
-				if (state.jumpTo === "tools") {
+				if (state.jumpTo === TOOLS_NODE_NAME) {
 					if (toolClasses.length === 0) return exitNode;
-					return new Send("tools", {
+					return new Send(TOOLS_NODE_NAME, {
 						...state,
 						jumpTo: void 0
 					});
 				}
-				return new Send("model_request", {
+				return new Send(AGENT_NODE_NAME, {
 					...state,
 					jumpTo: void 0
 				});
@@ -336,12 +334,12 @@ var ReactAgent = class {
 			const toolMessages = messages.filter(ToolMessage.isInstance);
 			const lastAiMessage = messages.filter(AIMessage.isInstance).at(-1);
 			const pendingToolCalls = lastAiMessage?.tool_calls?.filter((call) => !toolMessages.some((m) => m.tool_call_id === call.id));
-			if (pendingToolCalls && pendingToolCalls.length > 0) return pendingToolCalls.map((toolCall) => new Send("tools", {
+			if (pendingToolCalls && pendingToolCalls.length > 0) return pendingToolCalls.map((toolCall) => new Send(TOOLS_NODE_NAME, {
 				...state,
 				lg_tool_call: toolCall
 			}));
 			const hasStructuredResponseCalls = lastAiMessage?.tool_calls?.some((toolCall) => toolCall.name.startsWith("extract-"));
-			if (pendingToolCalls && pendingToolCalls.length === 0 && !hasStructuredResponseCalls && hasStructuredResponse) return "model_request";
+			if (pendingToolCalls && pendingToolCalls.length === 0 && !hasStructuredResponseCalls && hasStructuredResponse) return AGENT_NODE_NAME;
 			if (!AIMessage.isInstance(lastMessage) || !lastMessage.tool_calls || lastMessage.tool_calls.length === 0) return exitNode;
 			const hasOnlyStructuredResponseCalls = lastMessage.tool_calls.every((toolCall) => toolCall.name.startsWith("extract-"));
 			const hasRegularToolCalls = lastMessage.tool_calls.some((toolCall) => !toolCall.name.startsWith("extract-"));
@@ -350,7 +348,7 @@ var ReactAgent = class {
 			* For routing from afterModel nodes, always use simple string paths
 			* The Send API is handled at the model_request node level
 			*/
-			return "tools";
+			return TOOLS_NODE_NAME;
 		};
 	}
 	/**
@@ -363,14 +361,14 @@ var ReactAgent = class {
 			if (state.jumpTo) {
 				const dest = parseJumpToTarget(state.jumpTo);
 				if (dest === END && allowedSet.has(END)) return END;
-				if (dest === "tools" && allowedSet.has("tools")) {
+				if (dest === TOOLS_NODE_NAME && allowedSet.has(TOOLS_NODE_NAME)) {
 					if (toolClasses.length === 0) return END;
-					return new Send("tools", {
+					return new Send(TOOLS_NODE_NAME, {
 						...state,
 						jumpTo: void 0
 					});
 				}
-				if (dest === "model_request" && allowedSet.has("model_request")) return new Send("model_request", {
+				if (dest === AGENT_NODE_NAME && allowedSet.has(AGENT_NODE_NAME)) return new Send(AGENT_NODE_NAME, {
 					...state,
 					jumpTo: void 0
 				});
@@ -387,15 +385,19 @@ var ReactAgent = class {
 		return (state) => {
 			if (!state.jumpTo) return nextDefault;
 			const destination = parseJumpToTarget(state.jumpTo);
-			if (destination === END) return exitNode;
-			if (destination === "tools") {
+			if (destination === END)
+ /**
+			* When beforeAgent jumps to END, route to exitNode (first afterAgent node)
+			*/
+			return exitNode;
+			if (destination === TOOLS_NODE_NAME) {
 				if (toolClasses.length === 0) return exitNode;
-				return new Send("tools", {
+				return new Send(TOOLS_NODE_NAME, {
 					...state,
 					jumpTo: void 0
 				});
 			}
-			return new Send("model_request", {
+			return new Send(AGENT_NODE_NAME, {
 				...state,
 				jumpTo: void 0
 			});
@@ -410,14 +412,14 @@ var ReactAgent = class {
 			if (!state.jumpTo) return nextDefault;
 			const destination = parseJumpToTarget(state.jumpTo);
 			if (destination === END) return END;
-			if (destination === "tools") {
+			if (destination === TOOLS_NODE_NAME) {
 				if (toolClasses.length === 0) return END;
-				return new Send("tools", {
+				return new Send(TOOLS_NODE_NAME, {
 					...state,
 					jumpTo: void 0
 				});
 			}
-			return new Send("model_request", {
+			return new Send(AGENT_NODE_NAME, {
 				...state,
 				jumpTo: void 0
 			});