langchain 1.0.0-alpha.8 → 1.0.1

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

@@ -1 +0,0 @@
-{"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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"}

package/dist/agents/middlewareAgent/ReactAgent.js

@@ -1,578 +0,0 @@
-import { isClientTool } from "../utils.js";
-import { ToolNode } from "../nodes/ToolNode.js";
-import { createAgentAnnotationConditional } from "./annotation.js";
-import { AgentNode } from "./nodes/AgentNode.js";
-import { initializeMiddlewareStates, parseJumpToTarget } from "./nodes/utils.js";
-import { BeforeModelNode } from "./nodes/BeforeModalNode.js";
-import { AfterModelNode } from "./nodes/AfterModalNode.js";
-import { AIMessage, ToolMessage } from "@langchain/core/messages";
-import { Command, END, START, Send, StateGraph } from "@langchain/langgraph";
-
-//#region src/agents/middlewareAgent/ReactAgent.ts
-var ReactAgent = class {
-	#graph;
-	#toolBehaviorVersion = "v2";
-	#agentNode;
-	constructor(options) {
-		this.options = options;
-		this.#toolBehaviorVersion = options.version ?? this.#toolBehaviorVersion;
-		/**
-		* define complete list of tools based on options and middleware
-		*/
-		const middlewareTools = this.options.middleware?.filter((m) => m.tools).flatMap((m) => m.tools) ?? [];
-		const toolClasses = [...(Array.isArray(options.tools) ? options.tools : options.tools?.tools) ?? [], ...middlewareTools];
-		/**
-		* If any of the tools are configured to return_directly after running,
-		* our graph needs to check if these were called
-		*/
-		const shouldReturnDirect = new Set(toolClasses.filter(isClientTool).filter((tool) => "returnDirect" in tool && tool.returnDirect).map((tool) => tool.name));
-		const schema = createAgentAnnotationConditional(this.options.responseFormat !== void 0, this.options.middleware);
-		const workflow = new StateGraph(schema, this.options.contextSchema);
-		const allNodeWorkflows = workflow;
-		const beforeModelNodes = [];
-		const afterModelNodes = [];
-		const modifyModelRequestHookMiddleware = [];
-		const retryModelRequestHookMiddleware = [];
-		this.#agentNode = new AgentNode({
-			model: this.options.model,
-			systemPrompt: this.options.systemPrompt,
-			includeAgentName: this.options.includeAgentName,
-			name: this.options.name,
-			responseFormat: this.options.responseFormat,
-			middleware: this.options.middleware,
-			toolClasses,
-			shouldReturnDirect,
-			signal: this.options.signal,
-			modifyModelRequestHookMiddleware,
-			retryModelRequestHookMiddleware
-		});
-		const middlewareNames = /* @__PURE__ */ new Set();
-		const middleware = this.options.middleware ?? [];
-		for (let i = 0; i < middleware.length; i++) {
-			let beforeModelNode;
-			let afterModelNode;
-			const m = middleware[i];
-			if (middlewareNames.has(m.name)) throw new Error(`Middleware ${m.name} is defined multiple times`);
-			middlewareNames.add(m.name);
-			if (m.beforeModel) {
-				beforeModelNode = new BeforeModelNode(m, { getPrivateState: () => this.#agentNode.getState()._privateState });
-				const name = `${m.name}.before_model`;
-				beforeModelNodes.push({
-					index: i,
-					name,
-					allowed: m.beforeModelJumpTo
-				});
-				allNodeWorkflows.addNode(name, beforeModelNode, beforeModelNode.nodeOptions);
-			}
-			if (m.afterModel) {
-				afterModelNode = new AfterModelNode(m, { getPrivateState: () => this.#agentNode.getState()._privateState });
-				const name = `${m.name}.after_model`;
-				afterModelNodes.push({
-					index: i,
-					name,
-					allowed: m.afterModelJumpTo
-				});
-				allNodeWorkflows.addNode(name, afterModelNode, afterModelNode.nodeOptions);
-			}
-			if (m.modifyModelRequest) modifyModelRequestHookMiddleware.push([m, () => ({
-				...beforeModelNode?.getState(),
-				...afterModelNode?.getState()
-			})]);
-			if (m.retryModelRequest) retryModelRequestHookMiddleware.push([m, () => ({
-				...beforeModelNode?.getState(),
-				...afterModelNode?.getState()
-			})]);
-		}
-		/**
-		* Add Nodes
-		*/
-		allNodeWorkflows.addNode("model_request", this.#agentNode, AgentNode.nodeOptions);
-		/**
-		* add single tool node for all tools
-		*/
-		if (toolClasses.filter(isClientTool).length > 0) {
-			const toolNode = new ToolNode(toolClasses.filter(isClientTool), { signal: this.options.signal });
-			allNodeWorkflows.addNode("tools", toolNode);
-		}
-		/**
-		* Add Edges
-		*/
-		if (beforeModelNodes.length > 0) allNodeWorkflows.addEdge(START, beforeModelNodes[0].name);
-		else allNodeWorkflows.addEdge(START, "model_request");
-		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;
-			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 destinations = Array.from(new Set([nextDefault, ...allowedMapped]));
-				allNodeWorkflows.addConditionalEdges(current, this.#createBeforeModelRouter(toolClasses.filter(isClientTool), nextDefault), destinations);
-			} else allNodeWorkflows.addEdge(current, nextDefault);
-		}
-		const lastAfterModelNode = afterModelNodes.at(-1);
-		if (afterModelNodes.length > 0 && lastAfterModelNode) allNodeWorkflows.addEdge("model_request", lastAfterModelNode.name);
-		else {
-			const modelPaths = this.#getModelPaths(toolClasses.filter(isClientTool));
-			if (modelPaths.length === 1) allNodeWorkflows.addEdge("model_request", modelPaths[0]);
-			else allNodeWorkflows.addConditionalEdges("model_request", this.#createModelRouter(), modelPaths);
-		}
-		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 destinations = Array.from(new Set([nextDefault, ...allowedMapped]));
-				allNodeWorkflows.addConditionalEdges(current, this.#createAfterModelSequenceRouter(toolClasses.filter(isClientTool), 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 allowJump = Boolean(firstAfterModel.allowed && firstAfterModel.allowed.length > 0);
-			const destinations = modelPaths;
-			allNodeWorkflows.addConditionalEdges(firstAfterModelNode, this.#createAfterModelRouter(toolClasses.filter(isClientTool), allowJump), destinations);
-		}
-		/**
-		* add edges for tools node
-		*/
-		if (toolClasses.filter(isClientTool).length > 0) {
-			let toolReturnTarget;
-			if (beforeModelNodes.length > 0) toolReturnTarget = beforeModelNodes[0].name;
-			else toolReturnTarget = "model_request";
-			if (shouldReturnDirect.size > 0) allNodeWorkflows.addConditionalEdges("tools", this.#createToolsRouter(shouldReturnDirect), [toolReturnTarget, END]);
-			else allNodeWorkflows.addEdge("tools", toolReturnTarget);
-		}
-		/**
-		* compile the graph
-		*/
-		this.#graph = allNodeWorkflows.compile({
-			checkpointer: this.options.checkpointer ?? this.options.checkpointSaver,
-			store: this.options.store,
-			name: this.options.name,
-			description: this.options.description
-		});
-	}
-	/**
-	* Get the compiled {@link https://docs.langchain.com/oss/javascript/langgraph/use-graph-api | StateGraph}.
-	*/
-	get graph() {
-		return this.#graph;
-	}
-	/**
-	* Get possible edge destinations from model node.
-	* @param toolClasses names of tools to call
-	* @param includeModelRequest whether to include "model_request" as a valid path (for jumpTo routing)
-	* @returns list of possible edge destinations
-	*/
-	#getModelPaths(toolClasses, includeModelRequest = false) {
-		const paths = [];
-		if (toolClasses.length > 0) paths.push("tools");
-		if (includeModelRequest) paths.push("model_request");
-		paths.push(END);
-		return paths;
-	}
-	/**
-	* Create routing function for tools node conditional edges.
-	*/
-	#createToolsRouter(shouldReturnDirect) {
-		/**
-		* 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" : END;
-			return "model_request";
-		};
-	}
-	/**
-	* Create routing function for model node conditional edges.
-	*/
-	#createModelRouter() {
-		/**
-		* determine if the agent should continue or not
-		*/
-		return (state) => {
-			const messages = state.messages;
-			const lastMessage = messages.at(-1);
-			if (!AIMessage.isInstance(lastMessage) || !lastMessage.tool_calls || lastMessage.tool_calls.length === 0) return END;
-			const hasOnlyStructuredResponseCalls = lastMessage.tool_calls.every((toolCall) => toolCall.name.startsWith("extract-"));
-			if (hasOnlyStructuredResponseCalls) return END;
-			/**
-			* The tool node processes a single message.
-			*/
-			if (this.#toolBehaviorVersion === "v1") return "tools";
-			/**
-			* 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 END;
-			return regularToolCalls.map((toolCall) => new Send("tools", {
-				...state,
-				lg_tool_call: toolCall
-			}));
-		};
-	}
-	/**
-	* Create routing function for jumpTo functionality after afterModel hooks.
-	*
-	* This router checks if the `jumpTo` property is set in the state after afterModel middleware
-	* execution. If set, it routes to the specified target ("model_request" or "tools").
-	* If not set, it falls back to the normal model routing logic for afterModel context.
-	*
-	* The jumpTo property is automatically cleared after use to prevent infinite loops.
-	*
-	* @param toolClasses - Available tool classes for validation
-	* @returns Router function that handles jumpTo logic and normal routing
-	*/
-	#createAfterModelRouter(toolClasses, allowJump) {
-		const hasStructuredResponse = Boolean(this.options.responseFormat);
-		return (state) => {
-			const messages = state.messages;
-			const lastMessage = messages.at(-1);
-			if (AIMessage.isInstance(lastMessage) && (!lastMessage.tool_calls || lastMessage.tool_calls.length === 0)) return END;
-			if (allowJump && state.jumpTo) {
-				if (state.jumpTo === END) return END;
-				if (state.jumpTo === "tools") {
-					if (toolClasses.length === 0) return END;
-					return new Send("tools", {
-						...state,
-						jumpTo: void 0
-					});
-				}
-				return new Send("model_request", {
-					...state,
-					jumpTo: void 0
-				});
-			}
-			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", {
-				...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 (!AIMessage.isInstance(lastMessage) || !lastMessage.tool_calls || lastMessage.tool_calls.length === 0) return END;
-			const hasOnlyStructuredResponseCalls = lastMessage.tool_calls.every((toolCall) => toolCall.name.startsWith("extract-"));
-			const hasRegularToolCalls = lastMessage.tool_calls.some((toolCall) => !toolCall.name.startsWith("extract-"));
-			if (hasOnlyStructuredResponseCalls || !hasRegularToolCalls) return END;
-			/**
-			* For routing from afterModel nodes, always use simple string paths
-			* The Send API is handled at the model_request node level
-			*/
-			return "tools";
-		};
-	}
-	/**
-	* Router for afterModel sequence nodes (connecting later middlewares to earlier ones),
-	* honoring allowed jump targets and defaulting to the next node.
-	*/
-	#createAfterModelSequenceRouter(toolClasses, allowed, nextDefault) {
-		const allowedSet = new Set(allowed.map((t) => parseJumpToTarget(t)));
-		return (state) => {
-			if (state.jumpTo) {
-				const dest = parseJumpToTarget(state.jumpTo);
-				if (dest === END && allowedSet.has(END)) return END;
-				if (dest === "tools" && allowedSet.has("tools")) {
-					if (toolClasses.length === 0) return END;
-					return new Send("tools", {
-						...state,
-						jumpTo: void 0
-					});
-				}
-				if (dest === "model_request" && allowedSet.has("model_request")) return new Send("model_request", {
-					...state,
-					jumpTo: void 0
-				});
-			}
-			return nextDefault;
-		};
-	}
-	/**
-	* Create routing function for jumpTo functionality after beforeModel hooks.
-	* Falls back to the default next node if no jumpTo is present.
-	*/
-	#createBeforeModelRouter(toolClasses, nextDefault) {
-		return (state) => {
-			if (!state.jumpTo) return nextDefault;
-			const destination = parseJumpToTarget(state.jumpTo);
-			if (destination === END) return END;
-			if (destination === "tools") {
-				if (toolClasses.length === 0) return END;
-				return new Send("tools", {
-					...state,
-					jumpTo: void 0
-				});
-			}
-			return new Send("model_request", {
-				...state,
-				jumpTo: void 0
-			});
-		};
-	}
-	/**
-	* Initialize middleware states if not already present in the input state.
-	*/
-	async #initializeMiddlewareStates(state) {
-		if (!this.options.middleware || this.options.middleware.length === 0 || state instanceof Command || !state) return state;
-		const defaultStates = await initializeMiddlewareStates(this.options.middleware, state);
-		const updatedState = { ...state };
-		if (!updatedState) return updatedState;
-		for (const [key, value] of Object.entries(defaultStates)) if (!(key in updatedState)) updatedState[key] = value;
-		return updatedState;
-	}
-	/**
-	* Populate the private state of the agent node from the previous state.
-	*/
-	async #populatePrivateState(config) {
-		/**
-		* not needed if thread_id is not provided
-		*/
-		if (!config?.configurable?.thread_id) return;
-		const prevState = await this.#graph.getState(config);
-		/**
-		* not need if state is empty
-		*/
-		if (!prevState.values._privateState) return;
-		this.#agentNode.setState({
-			structuredResponse: void 0,
-			_privateState: prevState.values._privateState
-		});
-	}
-	/**
-	* 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."
-	* ```
-	*/
-	async invoke(state, config) {
-		const initializedState = await this.#initializeMiddlewareStates(state);
-		await this.#populatePrivateState(config);
-		return this.#graph.invoke(initializedState, config);
-	}
-	/**
-	* 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
-	* }
-	* ```
-	*/
-	async stream(state, config) {
-		const initializedState = await this.#initializeMiddlewareStates(state);
-		return this.#graph.stream(initializedState, config);
-	}
-	/**
-	* 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
-	*   }
-	* }
-	* ```
-	*/
-	async streamEvents(state, config, streamOptions) {
-		const initializedState = await this.#initializeMiddlewareStates(state);
-		await this.#populatePrivateState(config);
-		return this.#graph.streamEvents(initializedState, {
-			...config,
-			version: config?.version ?? "v2"
-		}, streamOptions);
-	}
-	/**
-	* Visualize the graph as a PNG image.
-	* @param params - Parameters for the drawMermaidPng method.
-	* @param params.withStyles - Whether to include styles in the graph.
-	* @param params.curveStyle - The style of the graph's curves.
-	* @param params.nodeColors - The colors of the graph's nodes.
-	* @param params.wrapLabelNWords - The maximum number of words to wrap in a node's label.
-	* @param params.backgroundColor - The background color of the graph.
-	* @returns PNG image as a buffer
-	*/
-	async drawMermaidPng(params) {
-		const representation = await this.#graph.getGraphAsync();
-		const image = await representation.drawMermaidPng(params);
-		const arrayBuffer = await image.arrayBuffer();
-		const buffer = new Uint8Array(arrayBuffer);
-		return buffer;
-	}
-	/**
-	* Draw the graph as a Mermaid string.
-	* @param params - Parameters for the drawMermaid method.
-	* @param params.withStyles - Whether to include styles in the graph.
-	* @param params.curveStyle - The style of the graph's curves.
-	* @param params.nodeColors - The colors of the graph's nodes.
-	* @param params.wrapLabelNWords - The maximum number of words to wrap in a node's label.
-	* @param params.backgroundColor - The background color of the graph.
-	* @returns Mermaid string
-	*/
-	async drawMermaid(params) {
-		const representation = await this.#graph.getGraphAsync();
-		return representation.drawMermaid(params);
-	}
-	/**
-	* 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) {
-		return this.#graph.getGraphAsync(config);
-	}
-	/**
-	* @internal
-	*/
-	getState(config, options) {
-		return this.#graph.getState(config, options);
-	}
-	/**
-	* @internal
-	*/
-	getStateHistory(config, options) {
-		return this.#graph.getStateHistory(config, options);
-	}
-	/**
-	* @internal
-	*/
-	getSubgraphs(namespace, recurse) {
-		return this.#graph.getSubgraphs(namespace, recurse);
-	}
-	/**
-	* @internal
-	*/
-	getSubgraphAsync(namespace, recurse) {
-		return this.#graph.getSubgraphsAsync(namespace, recurse);
-	}
-};
-
-//#endregion
-export { ReactAgent };
-//# sourceMappingURL=ReactAgent.js.map