langchain 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/agents/index.d.ts

@@ -1,161 +1,191 @@
-import { AnyAnnotationRoot, ResponseFormatUndefined } from "./annotation.js";
-import { MultipleStructuredOutputsError, StructuredOutputParsingError } from "./errors.js";
-import { JsonSchemaFormat, ProviderStrategy, ResponseFormat, ToolStrategy, TypedToolStrategy, providerStrategy, toolStrategy } from "./responses.js";
-import { ActionRequest, HumanInterrupt, HumanInterruptConfig, HumanResponse, Interrupt } from "./interrupt.js";
-import { ToolNode } from "./nodes/ToolNode.js";
-import { AgentRuntime, AgentState, ClientTool, CreateAgentParams, ExtractZodArrayTypes, N, Prompt, ServerTool } from "./types.js";
-import { AgentMiddleware, CreateAgentParams as CreateAgentParams$1 } from "./middlewareAgent/types.js";
+import { MultipleStructuredOutputsError, MultipleToolsBoundError, StructuredOutputParsingError, ToolInvocationError } from "./errors.js";
+import { JsonSchemaFormat, ProviderStrategy, ResponseFormat, ResponseFormatUndefined, ToolStrategy, TypedToolStrategy, providerStrategy, toolStrategy } from "./responses.js";
+import { JumpToTarget } from "./constants.js";
+import { Runtime } from "./runtime.js";
+import { AgentMiddleware, AnyAnnotationRoot, ToolCallHandler, ToolCallRequest, ToolCallWrapper } from "./middleware/types.js";
+import { BuiltInState, CreateAgentParams, ExecutedToolCall, ExtractZodArrayTypes, Interrupt, JumpTo, N, ToolCall, ToolResult, UserInput, WithStateGraphNodes } from "./types.js";
 import { ReactAgent } from "./ReactAgent.js";
-import { ReactAgent as ReactAgent$1 } from "./middlewareAgent/ReactAgent.js";
-import { createMiddleware } from "./middlewareAgent/middleware.js";
-import { MessagesAnnotation } from "@langchain/langgraph";
+import { createMiddleware } from "./middleware.js";
+import { FakeToolCallingModel } from "./tests/utils.js";
 import { InteropZodObject, InteropZodType } from "@langchain/core/utils/types";
 
 //#region src/agents/index.d.ts
 
 /**
- * Agents combine language models with tools to create systems that can reason
- * about tasks, decide which tools to use, and iteratively work towards solutions.
- * {@link createAgent} provides a production-ready ReAct (Reasoning + Acting)
- * agent implementation based on the paper {@link https://arxiv.org/abs/2210.03629|ReAct: Synergizing Reasoning and Acting in Language Models.}
+ * Creates a production-ready ReAct (Reasoning + Acting) agent that combines language models with tools
+ * and middleware to create systems that can reason about tasks, decide which tools to use, and iteratively
+ * work towards solutions.
  *
- * @example
+ * The agent follows the ReAct pattern, interleaving reasoning steps with tool calls to iteratively
+ * work towards solutions. It can handle multiple tool calls in sequence or parallel, maintain state
+ * across interactions, and provide auditable decision processes.
+ *
+ * ## Core Components
+ *
+ * ### Model
+ * The reasoning engine can be specified as:
+ * - **String identifier**: `"openai:gpt-4o"` for simple setup
+ * - **Model instance**: Configured model object for full control
+ * - **Dynamic function**: Select models at runtime based on state
+ *
+ * ### Tools
+ * Tools give agents the ability to take actions:
+ * - Pass an array of tools created with the `tool` function
+ * - Or provide a configured `ToolNode` for custom error handling
+ *
+ * ### Prompt
+ * Shape how your agent approaches tasks:
+ * - String for simple instructions
+ * - SystemMessage for structured prompts
+ * - Function for dynamic prompts based on state
+ *
+ * ### Middleware
+ * Middleware allows you to extend the agent's behavior:
+ * - Add pre/post-model processing for context injection or validation
+ * - Add dynamic control flows, e.g. terminate invocation or retries
+ * - Add human-in-the-loop capabilities
+ * - Add tool calls to the agent
+ * - Add tool results to the agent
+ *
+ * ## Advanced Features
+ *
+ * - **Structured Output**: Use `responseFormat` with a Zod schema to get typed responses
+ * - **Memory**: Extend the state schema to remember information across interactions
+ * - **Streaming**: Get real-time updates as the agent processes
+ *
+ * @param options - Configuration options for the agent
+ * @param options.llm - The language model as an instance of a chat model
+ * @param options.model - The language model as a string identifier, see more in {@link https://docs.langchain.com/oss/javascript/langchain/models#basic-usage | Models}.
+ * @param options.tools - Array of tools or configured ToolNode
+ * @param options.prompt - System instructions (string, SystemMessage, or function)
+ * @param options.responseFormat - Zod schema for structured output
+ * @param options.stateSchema - Custom state schema for memory
+ * @param options.middleware - Array of middleware for extending agent behavior, see more in {@link https://docs.langchain.com/oss/javascript/langchain/middleware | Middleware}.
+ *
+ * @returns A ReactAgent instance with `invoke` and `stream` methods
+ *
+ * @example Basic agent with tools
  * ```ts
  * import { createAgent, tool } from "langchain";
- * import { z } from "zod/v3";
+ * import { z } from "zod";
  *
- * const getWeather = tool((input) => {
- *   if (["sf", "san francisco"].includes(input.location.toLowerCase())) {
- *     return "It's 60 degrees and foggy.";
- *   } else {
- *     return "It's 90 degrees and sunny.";
+ * const search = tool(
+ *   ({ query }) => `Results for: ${query}`,
+ *   {
+ *     name: "search",
+ *     description: "Search for information",
+ *     schema: z.object({
+ *       query: z.string().describe("The search query"),
+ *     })
  *   }
- * }, {
- *   name: "get_weather",
- *   description: "Call to get the current weather.",
- *   schema: z.object({
- *     location: z.string().describe("Location to get the weather for."),
- *   })
- * })
+ * );
+ *
+ * const agent = createAgent({
+ *   llm: "openai:gpt-4o",
+ *   tools: [search],
+ * });
+ *
+ * const result = await agent.invoke({
+ *   messages: [{ role: "user", content: "Search for ReAct agents" }],
+ * });
+ * ```
+ *
+ * @example Structured output
+ * ```ts
+ * import { createAgent } from "langchain";
+ * import { z } from "zod";
+ *
+ * const ContactInfo = z.object({
+ *   name: z.string(),
+ *   email: z.string(),
+ *   phone: z.string(),
+ * });
  *
  * const agent = createAgent({
- *   // use chat model from "@langchain/openai"
- *   model: "openai:gpt-4o-mini",
- *   tools: [getWeather]
+ *   llm: "openai:gpt-4o",
+ *   tools: [],
+ *   responseFormat: ContactInfo,
  * });
  *
- * const inputs = {
- *   messages: [{ role: "user", content: "what is the weather in SF?" }],
- * };
+ * const result = await agent.invoke({
+ *   messages: [{
+ *     role: "user",
+ *     content: "Extract: John Doe, john@example.com, (555) 123-4567"
+ *   }],
+ * });
  *
- * const stream = await agent.stream(inputs, { streamMode: "values" });
+ * console.log(result.structuredResponse);
+ * // { name: 'John Doe', email: 'john@example.com', phone: '(555) 123-4567' }
+ * ```
  *
- * for await (const { messages } of stream) {
- *   console.log(messages);
+ * @example Streaming responses
+ * ```ts
+ * const stream = await agent.stream(
+ *   { messages: [{ role: "user", content: "What's the weather?" }] },
+ *   { streamMode: "values" }
+ * );
+ *
+ * for await (const chunk of stream) {
+ *   // ...
  * }
- * // Returns the messages in the state at each step of execution
  * ```
  */
-// ===== V1 OVERLOADS (WITHOUT MIDDLEWARE) =====
-// These overloads come first to ensure proper type inference when middleware is NOT provided
-// Overload 1: V1 - With responseFormat as single InteropZodType
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, T, ContextSchema, InteropZodType<T>> & {
+// Overload 1: With responseFormat as single InteropZodType
+declare function createAgent<T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, ContextSchema, InteropZodType<T>> & {
   responseFormat: InteropZodType<T>;
-}): ReactAgent<StateSchema, T, ContextSchema>;
-// Overload 2: V1 - With responseFormat as array of InteropZodTypes
-declare function createAgent<T extends readonly InteropZodType<any>[], StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, ContextSchema, T> & {
+  middleware?: TMiddleware;
+}): ReactAgent<T, ContextSchema, TMiddleware>;
+// Overload 2: With responseFormat as array of InteropZodTypes (infers union type)
+declare function createAgent<T extends readonly InteropZodType<any>[], ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, ContextSchema, T> & {
   responseFormat: T;
-}): ReactAgent<StateSchema, ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, ContextSchema>;
-// Overload 3: V1 - With responseFormat as JsonSchemaFormat
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, Record<string, unknown>, ContextSchema, JsonSchemaFormat> & {
+  middleware?: TMiddleware;
+}): ReactAgent<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, ContextSchema, TMiddleware>;
+// Overload 3: With responseFormat as JsonSchemaFormat (JSON schema object)
+declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, ContextSchema, JsonSchemaFormat> & {
   responseFormat: JsonSchemaFormat;
-}): ReactAgent<StateSchema, Record<string, unknown>, ContextSchema>;
-// Overload 4: V1 - With responseFormat as array of JsonSchemaFormat
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, Record<string, unknown>, ContextSchema, JsonSchemaFormat[]> & {
+  middleware?: TMiddleware;
+}): ReactAgent<Record<string, unknown>, ContextSchema, TMiddleware>;
+// Overload 4: With responseFormat as array of JsonSchemaFormat (JSON schema objects)
+declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, ContextSchema, JsonSchemaFormat[]> & {
   responseFormat: JsonSchemaFormat[];
-}): ReactAgent<StateSchema, Record<string, unknown>, ContextSchema>;
-// Overload 5: V1 - With responseFormat as union of JsonSchemaFormat | JsonSchemaFormat[]
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, Record<string, unknown>, ContextSchema, JsonSchemaFormat | JsonSchemaFormat[]> & {
+  middleware?: TMiddleware;
+}): ReactAgent<Record<string, unknown>, ContextSchema, TMiddleware>;
+// Overload 4.5: With responseFormat as union of JsonSchemaFormat | JsonSchemaFormat[]
+declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, ContextSchema, JsonSchemaFormat | JsonSchemaFormat[]> & {
   responseFormat: JsonSchemaFormat | JsonSchemaFormat[];
-}): ReactAgent<StateSchema, Record<string, unknown>, ContextSchema>;
-// Overload 6: V1 - With responseFormat as TypedToolStrategy
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, T, ContextSchema, TypedToolStrategy<T>> & {
+  middleware?: TMiddleware;
+}): ReactAgent<Record<string, unknown>, ContextSchema, TMiddleware>;
+// Overload 5: With responseFormat as TypedToolStrategy (for union types from toolStrategy)
+declare function createAgent<T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, ContextSchema, TypedToolStrategy<T>> & {
   responseFormat: TypedToolStrategy<T>;
-}): ReactAgent<StateSchema, T, ContextSchema>;
-// Overload 7: V1 - With responseFormat as single ToolStrategy
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, T, ContextSchema, ToolStrategy<T>> & {
+  middleware?: TMiddleware;
+}): ReactAgent<T, ContextSchema, TMiddleware>;
+// Overload 6: With responseFormat as single ToolStrategy instance
+declare function createAgent<T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, ContextSchema, ToolStrategy<T>> & {
   responseFormat: ToolStrategy<T>;
-}): ReactAgent<StateSchema, T, ContextSchema>;
-// Overload 8: V1 - With responseFormat as ProviderStrategy
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, T, ContextSchema, ProviderStrategy<T>> & {
+  middleware?: TMiddleware;
+}): ReactAgent<T, ContextSchema, TMiddleware>;
+// Overload 7: With responseFormat as ProviderStrategy
+declare function createAgent<T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, ContextSchema, ProviderStrategy<T>> & {
   responseFormat: ProviderStrategy<T>;
-}): ReactAgent<StateSchema, T, ContextSchema>;
-// Overload 9: V1 - Without responseFormat property at all
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: Omit<CreateAgentParams<StateSchema, ResponseFormatUndefined, ContextSchema, never>, "responseFormat">): ReactAgent<StateSchema, ResponseFormatUndefined, ContextSchema>;
-// Overload 10: V1 - With responseFormat explicitly undefined
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: Omit<CreateAgentParams<StateSchema, ResponseFormatUndefined, ContextSchema, never>, "responseFormat"> & {
+  middleware?: TMiddleware;
+}): ReactAgent<T, ContextSchema, TMiddleware>;
+// Overload 8: Without responseFormat property at all - with proper middleware state typing
+declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, ContextSchema, never>, "responseFormat"> & {
+  middleware?: TMiddleware;
+}): ReactAgent<ResponseFormatUndefined, ContextSchema, TMiddleware>;
+// Overload 9: With responseFormat explicitly undefined
+declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, ContextSchema, never>, "responseFormat"> & {
   responseFormat?: undefined;
-}): ReactAgent<StateSchema, ResponseFormatUndefined, ContextSchema>;
-// Overload 11: V1 - For other ResponseFormat values (failsafe)
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, StructuredResponseFormat extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, StructuredResponseFormat, ContextSchema, any> & {
-  responseFormat: any;
-}): ReactAgent<StateSchema, StructuredResponseFormat, ContextSchema>;
-// ===== V2 OVERLOADS (WITH MIDDLEWARE) =====
-// These overloads explicitly require the middleware property
-// Overload 12: With responseFormat as single InteropZodType and middleware
-declare function createAgent<T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParams$1<T, ContextSchema, InteropZodType<T>> & {
-  responseFormat: InteropZodType<T>;
-  middleware: TMiddleware;
-}): ReactAgent$1<T, ContextSchema, TMiddleware>;
-// Overload 13: With responseFormat as array of InteropZodTypes and middleware
-declare function createAgent<T extends readonly InteropZodType<any>[], ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParams$1<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, ContextSchema, T> & {
-  responseFormat: T;
-  middleware: TMiddleware;
-}): ReactAgent$1<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, ContextSchema, TMiddleware>;
-// Overload 14: With responseFormat as JsonSchemaFormat and middleware
-declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParams$1<Record<string, unknown>, ContextSchema, JsonSchemaFormat> & {
-  responseFormat: JsonSchemaFormat;
-  middleware: TMiddleware;
-}): ReactAgent$1<Record<string, unknown>, ContextSchema, TMiddleware>;
-// Overload 15: With responseFormat as array of JsonSchemaFormat and middleware
-declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParams$1<Record<string, unknown>, ContextSchema, JsonSchemaFormat[]> & {
-  responseFormat: JsonSchemaFormat[];
-  middleware: TMiddleware;
-}): ReactAgent$1<Record<string, unknown>, ContextSchema, TMiddleware>;
-// Overload 16: With responseFormat as union of JsonSchemaFormat | JsonSchemaFormat[] and middleware
-declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParams$1<Record<string, unknown>, ContextSchema, JsonSchemaFormat | JsonSchemaFormat[]> & {
-  responseFormat: JsonSchemaFormat | JsonSchemaFormat[];
-  middleware: TMiddleware;
-}): ReactAgent$1<Record<string, unknown>, ContextSchema, TMiddleware>;
-// Overload 17: With responseFormat as TypedToolStrategy and middleware
-declare function createAgent<T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParams$1<T, ContextSchema, TypedToolStrategy<T>> & {
-  responseFormat: TypedToolStrategy<T>;
-  middleware: TMiddleware;
-}): ReactAgent$1<T, ContextSchema, TMiddleware>;
-// Overload 18: With responseFormat as single ToolStrategy and middleware
-declare function createAgent<T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParams$1<T, ContextSchema, ToolStrategy<T>> & {
-  responseFormat: ToolStrategy<T>;
-  middleware: TMiddleware;
-}): ReactAgent$1<T, ContextSchema, TMiddleware>;
-// Overload 19: With responseFormat as ProviderStrategy and middleware
-declare function createAgent<T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParams$1<T, ContextSchema, ProviderStrategy<T>> & {
-  responseFormat: ProviderStrategy<T>;
-  middleware: TMiddleware;
-}): ReactAgent$1<T, ContextSchema, TMiddleware>;
-// Overload 20: Without responseFormat but with middleware
-declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: Omit<CreateAgentParams$1<ResponseFormatUndefined, ContextSchema, never>, "responseFormat"> & {
-  middleware: TMiddleware;
-}): ReactAgent$1<ResponseFormatUndefined, ContextSchema, TMiddleware>;
-// Overload 21: With responseFormat explicitly undefined and middleware
-declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: Omit<CreateAgentParams$1<ResponseFormatUndefined, ContextSchema, never>, "responseFormat"> & {
-  responseFormat?: undefined;
-  middleware: TMiddleware;
-}): ReactAgent$1<ResponseFormatUndefined, ContextSchema, TMiddleware>;
-// Overload 22: For other ResponseFormat values with middleware (failsafe)
-declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParams$1<StructuredResponseFormat, ContextSchema, any> & {
-  responseFormat: any;
-  middleware: TMiddleware;
-}): ReactAgent$1<StructuredResponseFormat, ContextSchema, TMiddleware>;
+  middleware?: TMiddleware;
+}): ReactAgent<ResponseFormatUndefined, ContextSchema, TMiddleware>;
+// Overload 10: For other ResponseFormat values (failsafe)
+declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<StructuredResponseFormat, ContextSchema, ResponseFormat> & {
+  responseFormat: ResponseFormat;
+  middleware?: TMiddleware;
+}): ReactAgent<StructuredResponseFormat, ContextSchema, TMiddleware>;
+// Re-export types and utilities
+
 //#endregion
 export { createAgent };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["InteropZodObject","InteropZodType","MessagesAnnotation","ReactAgent","ReactAgentV1","ReactAgentV2","AnyAnnotationRoot","ResponseFormatUndefined","CreateAgentParams","ExtractZodArrayTypes","CreateAgentParamsV2","AgentMiddleware","ToolStrategy","TypedToolStrategy","ProviderStrategy","JsonSchemaFormat","ToolNode","toolStrategy","providerStrategy","ResponseFormat","createMiddleware","createAgent","Record","StateSchema","T","ContextSchema","Omit","StructuredResponseFormat","TMiddleware"],"sources":["../../src/agents/index.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport { MessagesAnnotation } from \"@langchain/langgraph\";\nimport { ReactAgent as ReactAgentV1 } from \"./ReactAgent.js\";\nimport { ReactAgent as ReactAgentV2 } from \"./middlewareAgent/ReactAgent.js\";\nimport type { AnyAnnotationRoot, ResponseFormatUndefined } from \"./annotation.js\";\nimport type { CreateAgentParams, ExtractZodArrayTypes } from \"./types.js\";\nimport type { CreateAgentParams as CreateAgentParamsV2, AgentMiddleware } from \"./middlewareAgent/types.js\";\nimport type { ToolStrategy, TypedToolStrategy, ProviderStrategy, JsonSchemaFormat } from \"./responses.js\";\n// Re-export types and utilities\nexport * from \"./types.js\";\nexport * from \"./errors.js\";\nexport * from \"./interrupt.js\";\nexport { ToolNode } from \"./nodes/ToolNode.js\";\nexport { toolStrategy, providerStrategy, ToolStrategy, ProviderStrategy, type ResponseFormat, } from \"./responses.js\";\nexport { createMiddleware } from \"./middlewareAgent/index.js\";\nexport type { AgentMiddleware } from \"./middlewareAgent/types.js\";\nexport type { ReactAgent } from \"./middlewareAgent/ReactAgent.js\";\n/**\n * Agents combine language models with tools to create systems that can reason\n * about tasks, decide which tools to use, and iteratively work towards solutions.\n * {@link createAgent} provides a production-ready ReAct (Reasoning + Acting)\n * agent implementation based on the paper {@link https://arxiv.org/abs/2210.03629|ReAct: Synergizing Reasoning and Acting in Language Models.}\n *\n * @example\n * ```ts\n * import { createAgent, tool } from \"langchain\";\n * import { z } from \"zod/v3\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   })\n * })\n *\n * const agent = createAgent({\n *   // use chat model from \"@langchain/openai\"\n *   model: \"openai:gpt-4o-mini\",\n *   tools: [getWeather]\n * });\n *\n * const inputs = {\n *   messages: [{ role: \"user\", content: \"what is the weather in SF?\" }],\n * };\n *\n * const stream = await agent.stream(inputs, { streamMode: \"values\" });\n *\n * for await (const { messages } of stream) {\n *   console.log(messages);\n * }\n * // Returns the messages in the state at each step of execution\n * ```\n */\n// ===== V1 OVERLOADS (WITHOUT MIDDLEWARE) =====\n// These overloads come first to ensure proper type inference when middleware is NOT provided\n// Overload 1: V1 - With responseFormat as single InteropZodType\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, T, ContextSchema, InteropZodType<T>> & {\n    responseFormat: InteropZodType<T>;\n}): ReactAgentV1<StateSchema, T, ContextSchema>;\n// Overload 2: V1 - With responseFormat as array of InteropZodTypes\nexport declare function createAgent<T extends readonly InteropZodType<any>[], StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, ContextSchema, T> & {\n    responseFormat: T;\n}): ReactAgentV1<StateSchema, ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, ContextSchema>;\n// Overload 3: V1 - With responseFormat as JsonSchemaFormat\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, Record<string, unknown>, ContextSchema, JsonSchemaFormat> & {\n    responseFormat: JsonSchemaFormat;\n}): ReactAgentV1<StateSchema, Record<string, unknown>, ContextSchema>;\n// Overload 4: V1 - With responseFormat as array of JsonSchemaFormat\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, Record<string, unknown>, ContextSchema, JsonSchemaFormat[]> & {\n    responseFormat: JsonSchemaFormat[];\n}): ReactAgentV1<StateSchema, Record<string, unknown>, ContextSchema>;\n// Overload 5: V1 - With responseFormat as union of JsonSchemaFormat | JsonSchemaFormat[]\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, Record<string, unknown>, ContextSchema, JsonSchemaFormat | JsonSchemaFormat[]> & {\n    responseFormat: JsonSchemaFormat | JsonSchemaFormat[];\n}): ReactAgentV1<StateSchema, Record<string, unknown>, ContextSchema>;\n// Overload 6: V1 - With responseFormat as TypedToolStrategy\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, T, ContextSchema, TypedToolStrategy<T>> & {\n    responseFormat: TypedToolStrategy<T>;\n}): ReactAgentV1<StateSchema, T, ContextSchema>;\n// Overload 7: V1 - With responseFormat as single ToolStrategy\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, T, ContextSchema, ToolStrategy<T>> & {\n    responseFormat: ToolStrategy<T>;\n}): ReactAgentV1<StateSchema, T, ContextSchema>;\n// Overload 8: V1 - With responseFormat as ProviderStrategy\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, T, ContextSchema, ProviderStrategy<T>> & {\n    responseFormat: ProviderStrategy<T>;\n}): ReactAgentV1<StateSchema, T, ContextSchema>;\n// Overload 9: V1 - Without responseFormat property at all\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: Omit<CreateAgentParams<StateSchema, ResponseFormatUndefined, ContextSchema, never>, \"responseFormat\">): ReactAgentV1<StateSchema, ResponseFormatUndefined, ContextSchema>;\n// Overload 10: V1 - With responseFormat explicitly undefined\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: Omit<CreateAgentParams<StateSchema, ResponseFormatUndefined, ContextSchema, never>, \"responseFormat\"> & {\n    responseFormat?: undefined;\n}): ReactAgentV1<StateSchema, ResponseFormatUndefined, ContextSchema>;\n// Overload 11: V1 - For other ResponseFormat values (failsafe)\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, StructuredResponseFormat extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateAgentParams<StateSchema, StructuredResponseFormat, ContextSchema, any> & {\n    responseFormat: any;\n}): ReactAgentV1<StateSchema, StructuredResponseFormat, ContextSchema>;\n// ===== V2 OVERLOADS (WITH MIDDLEWARE) =====\n// These overloads explicitly require the middleware property\n// Overload 12: With responseFormat as single InteropZodType and middleware\nexport declare function createAgent<T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParamsV2<T, ContextSchema, InteropZodType<T>> & {\n    responseFormat: InteropZodType<T>;\n    middleware: TMiddleware;\n}): ReactAgentV2<T, ContextSchema, TMiddleware>;\n// Overload 13: With responseFormat as array of InteropZodTypes and middleware\nexport declare function createAgent<T extends readonly InteropZodType<any>[], ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParamsV2<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, ContextSchema, T> & {\n    responseFormat: T;\n    middleware: TMiddleware;\n}): ReactAgentV2<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, ContextSchema, TMiddleware>;\n// Overload 14: With responseFormat as JsonSchemaFormat and middleware\nexport declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParamsV2<Record<string, unknown>, ContextSchema, JsonSchemaFormat> & {\n    responseFormat: JsonSchemaFormat;\n    middleware: TMiddleware;\n}): ReactAgentV2<Record<string, unknown>, ContextSchema, TMiddleware>;\n// Overload 15: With responseFormat as array of JsonSchemaFormat and middleware\nexport declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParamsV2<Record<string, unknown>, ContextSchema, JsonSchemaFormat[]> & {\n    responseFormat: JsonSchemaFormat[];\n    middleware: TMiddleware;\n}): ReactAgentV2<Record<string, unknown>, ContextSchema, TMiddleware>;\n// Overload 16: With responseFormat as union of JsonSchemaFormat | JsonSchemaFormat[] and middleware\nexport declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParamsV2<Record<string, unknown>, ContextSchema, JsonSchemaFormat | JsonSchemaFormat[]> & {\n    responseFormat: JsonSchemaFormat | JsonSchemaFormat[];\n    middleware: TMiddleware;\n}): ReactAgentV2<Record<string, unknown>, ContextSchema, TMiddleware>;\n// Overload 17: With responseFormat as TypedToolStrategy and middleware\nexport declare function createAgent<T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParamsV2<T, ContextSchema, TypedToolStrategy<T>> & {\n    responseFormat: TypedToolStrategy<T>;\n    middleware: TMiddleware;\n}): ReactAgentV2<T, ContextSchema, TMiddleware>;\n// Overload 18: With responseFormat as single ToolStrategy and middleware\nexport declare function createAgent<T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParamsV2<T, ContextSchema, ToolStrategy<T>> & {\n    responseFormat: ToolStrategy<T>;\n    middleware: TMiddleware;\n}): ReactAgentV2<T, ContextSchema, TMiddleware>;\n// Overload 19: With responseFormat as ProviderStrategy and middleware\nexport declare function createAgent<T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParamsV2<T, ContextSchema, ProviderStrategy<T>> & {\n    responseFormat: ProviderStrategy<T>;\n    middleware: TMiddleware;\n}): ReactAgentV2<T, ContextSchema, TMiddleware>;\n// Overload 20: Without responseFormat but with middleware\nexport declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: Omit<CreateAgentParamsV2<ResponseFormatUndefined, ContextSchema, never>, \"responseFormat\"> & {\n    middleware: TMiddleware;\n}): ReactAgentV2<ResponseFormatUndefined, ContextSchema, TMiddleware>;\n// Overload 21: With responseFormat explicitly undefined and middleware\nexport declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: Omit<CreateAgentParamsV2<ResponseFormatUndefined, ContextSchema, never>, \"responseFormat\"> & {\n    responseFormat?: undefined;\n    middleware: TMiddleware;\n}): ReactAgentV2<ResponseFormatUndefined, ContextSchema, TMiddleware>;\n// Overload 22: For other ResponseFormat values with middleware (failsafe)\nexport declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware<any, any, any>[] = readonly AgentMiddleware<any, any, any>[]>(params: CreateAgentParamsV2<StructuredResponseFormat, ContextSchema, any> & {\n    responseFormat: any;\n    middleware: TMiddleware;\n}): ReactAgentV2<StructuredResponseFormat, ContextSchema, TMiddleware>;\n"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":["InteropZodObject","InteropZodType","ResponseFormatUndefined","CreateAgentParams","AgentMiddleware","AnyAnnotationRoot","ExtractZodArrayTypes","ToolStrategy","TypedToolStrategy","ProviderStrategy","ResponseFormat","JsonSchemaFormat","ReactAgent","createAgent","Record","T","ContextSchema","TMiddleware","Omit","StructuredResponseFormat","JumpToTarget","Runtime","toolStrategy","providerStrategy","createMiddleware","ToolCallRequest","ToolCallHandler","ToolCallWrapper","FakeToolCallingModel"],"sources":["../../src/agents/index.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport type { ResponseFormatUndefined } from \"./responses.js\";\nimport type { CreateAgentParams } from \"./types.js\";\nimport type { AgentMiddleware, AnyAnnotationRoot } from \"./middleware/types.js\";\nimport type { ExtractZodArrayTypes } from \"./types.js\";\nimport type { ToolStrategy, TypedToolStrategy, ProviderStrategy, ResponseFormat, JsonSchemaFormat } from \"./responses.js\";\nimport { ReactAgent } from \"./ReactAgent.js\";\n/**\n * Creates a production-ready ReAct (Reasoning + Acting) agent that combines language models with tools\n * and middleware to create systems that can reason about tasks, decide which tools to use, and iteratively\n * work towards solutions.\n *\n * The agent follows the ReAct pattern, interleaving reasoning steps with tool calls to iteratively\n * work towards solutions. It can handle multiple tool calls in sequence or parallel, maintain state\n * across interactions, and provide auditable decision processes.\n *\n * ## Core Components\n *\n * ### Model\n * The reasoning engine can be specified as:\n * - **String identifier**: `\"openai:gpt-4o\"` for simple setup\n * - **Model instance**: Configured model object for full control\n * - **Dynamic function**: Select models at runtime based on state\n *\n * ### Tools\n * Tools give agents the ability to take actions:\n * - Pass an array of tools created with the `tool` function\n * - Or provide a configured `ToolNode` for custom error handling\n *\n * ### Prompt\n * Shape how your agent approaches tasks:\n * - String for simple instructions\n * - SystemMessage for structured prompts\n * - Function for dynamic prompts based on state\n *\n * ### Middleware\n * Middleware allows you to extend the agent's behavior:\n * - Add pre/post-model processing for context injection or validation\n * - Add dynamic control flows, e.g. terminate invocation or retries\n * - Add human-in-the-loop capabilities\n * - Add tool calls to the agent\n * - Add tool results to the agent\n *\n * ## Advanced Features\n *\n * - **Structured Output**: Use `responseFormat` with a Zod schema to get typed responses\n * - **Memory**: Extend the state schema to remember information across interactions\n * - **Streaming**: Get real-time updates as the agent processes\n *\n * @param options - Configuration options for the agent\n * @param options.llm - The language model as an instance of a chat model\n * @param options.model - The language model as a string identifier, see more in {@link https://docs.langchain.com/oss/javascript/langchain/models#basic-usage | Models}.\n * @param options.tools - Array of tools or configured ToolNode\n * @param options.prompt - System instructions (string, SystemMessage, or function)\n * @param options.responseFormat - Zod schema for structured output\n * @param options.stateSchema - Custom state schema for memory\n * @param options.middleware - Array of middleware for extending agent behavior, see more in {@link https://docs.langchain.com/oss/javascript/langchain/middleware | Middleware}.\n *\n * @returns A ReactAgent instance with `invoke` and `stream` methods\n *\n * @example Basic agent with tools\n * ```ts\n * import { createAgent, tool } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const search = tool(\n *   ({ query }) => `Results for: ${query}`,\n *   {\n *     name: \"search\",\n *     description: \"Search for information\",\n *     schema: z.object({\n *       query: z.string().describe(\"The search query\"),\n *     })\n *   }\n * );\n *\n * const agent = createAgent({\n *   llm: \"openai:gpt-4o\",\n *   tools: [search],\n * });\n *\n * const result = await agent.invoke({\n *   messages: [{ role: \"user\", content: \"Search for ReAct agents\" }],\n * });\n * ```\n *\n * @example Structured output\n * ```ts\n * import { createAgent } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const ContactInfo = z.object({\n *   name: z.string(),\n *   email: z.string(),\n *   phone: z.string(),\n * });\n *\n * const agent = createAgent({\n *   llm: \"openai:gpt-4o\",\n *   tools: [],\n *   responseFormat: ContactInfo,\n * });\n *\n * const result = await agent.invoke({\n *   messages: [{\n *     role: \"user\",\n *     content: \"Extract: John Doe, john@example.com, (555) 123-4567\"\n *   }],\n * });\n *\n * console.log(result.structuredResponse);\n * // { name: 'John Doe', email: 'john@example.com', phone: '(555) 123-4567' }\n * ```\n *\n * @example Streaming responses\n * ```ts\n * const stream = await agent.stream(\n *   { messages: [{ role: \"user\", content: \"What's the weather?\" }] },\n *   { streamMode: \"values\" }\n * );\n *\n * for await (const chunk of stream) {\n *   // ...\n * }\n * ```\n */\n// Overload 1: With responseFormat as single InteropZodType\nexport declare function createAgent<T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, ContextSchema, InteropZodType<T>> & {\n    responseFormat: InteropZodType<T>;\n    middleware?: TMiddleware;\n}): ReactAgent<T, ContextSchema, TMiddleware>;\n// Overload 2: With responseFormat as array of InteropZodTypes (infers union type)\nexport declare function createAgent<T extends readonly InteropZodType<any>[], ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, ContextSchema, T> & {\n    responseFormat: T;\n    middleware?: TMiddleware;\n}): ReactAgent<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, ContextSchema, TMiddleware>;\n// Overload 3: With responseFormat as JsonSchemaFormat (JSON schema object)\nexport declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, ContextSchema, JsonSchemaFormat> & {\n    responseFormat: JsonSchemaFormat;\n    middleware?: TMiddleware;\n}): ReactAgent<Record<string, unknown>, ContextSchema, TMiddleware>;\n// Overload 4: With responseFormat as array of JsonSchemaFormat (JSON schema objects)\nexport declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, ContextSchema, JsonSchemaFormat[]> & {\n    responseFormat: JsonSchemaFormat[];\n    middleware?: TMiddleware;\n}): ReactAgent<Record<string, unknown>, ContextSchema, TMiddleware>;\n// Overload 4.5: With responseFormat as union of JsonSchemaFormat | JsonSchemaFormat[]\nexport declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, ContextSchema, JsonSchemaFormat | JsonSchemaFormat[]> & {\n    responseFormat: JsonSchemaFormat | JsonSchemaFormat[];\n    middleware?: TMiddleware;\n}): ReactAgent<Record<string, unknown>, ContextSchema, TMiddleware>;\n// Overload 5: With responseFormat as TypedToolStrategy (for union types from toolStrategy)\nexport declare function createAgent<T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, ContextSchema, TypedToolStrategy<T>> & {\n    responseFormat: TypedToolStrategy<T>;\n    middleware?: TMiddleware;\n}): ReactAgent<T, ContextSchema, TMiddleware>;\n// Overload 6: With responseFormat as single ToolStrategy instance\nexport declare function createAgent<T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, ContextSchema, ToolStrategy<T>> & {\n    responseFormat: ToolStrategy<T>;\n    middleware?: TMiddleware;\n}): ReactAgent<T, ContextSchema, TMiddleware>;\n// Overload 7: With responseFormat as ProviderStrategy\nexport declare function createAgent<T extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, ContextSchema, ProviderStrategy<T>> & {\n    responseFormat: ProviderStrategy<T>;\n    middleware?: TMiddleware;\n}): ReactAgent<T, ContextSchema, TMiddleware>;\n// Overload 8: Without responseFormat property at all - with proper middleware state typing\nexport declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, ContextSchema, never>, \"responseFormat\"> & {\n    middleware?: TMiddleware;\n}): ReactAgent<ResponseFormatUndefined, ContextSchema, TMiddleware>;\n// Overload 9: With responseFormat explicitly undefined\nexport declare function createAgent<ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, ContextSchema, never>, \"responseFormat\"> & {\n    responseFormat?: undefined;\n    middleware?: TMiddleware;\n}): ReactAgent<ResponseFormatUndefined, ContextSchema, TMiddleware>;\n// Overload 10: For other ResponseFormat values (failsafe)\nexport declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<StructuredResponseFormat, ContextSchema, ResponseFormat> & {\n    responseFormat: ResponseFormat;\n    middleware?: TMiddleware;\n}): ReactAgent<StructuredResponseFormat, ContextSchema, TMiddleware>;\n// Re-export types and utilities\nexport * from \"./types.js\";\nexport * from \"./errors.js\";\nexport type { JumpToTarget } from \"./constants.js\";\nexport type { Runtime } from \"./runtime.js\";\nexport { toolStrategy, providerStrategy, ToolStrategy, ProviderStrategy, type ResponseFormat, type ResponseFormatUndefined, } from \"./responses.js\";\nexport { createMiddleware } from \"./middleware.js\";\nexport type { ToolCallRequest, ToolCallHandler, ToolCallWrapper, } from \"./middleware/types.js\";\nexport { FakeToolCallingModel } from \"./tests/utils.js\";\nexport type { ReactAgent } from \"./ReactAgent.js\";\n"],"mappings":"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"}

package/dist/agents/index.js

@@ -1,33 +1,14 @@
 import { MultipleStructuredOutputsError, MultipleToolsBoundError, StructuredOutputParsingError, ToolInvocationError } from "./errors.js";
 import { ProviderStrategy, ToolStrategy, providerStrategy, toolStrategy } from "./responses.js";
-import { ToolNode } from "./nodes/ToolNode.js";
-import { createAgent } from "./createAgent.js";
-import { createMiddleware } from "./middlewareAgent/middleware.js";
-import { createAgent as createAgent$1 } from "./middlewareAgent/index.js";
-import "./interrupt.js";
+import { ReactAgent } from "./ReactAgent.js";
+import { createMiddleware } from "./middleware.js";
+import { FakeToolCallingModel } from "./tests/utils.js";
 
 //#region src/agents/index.ts
-function createAgent$2(params) {
-	/**
-	* Check if middleware property is present
-	*/
-	if ("middleware" in params && params.middleware !== void 0) {
-		/**
-		* The user wants to use the middleware version of the agent.
-		* Let's verify that `preModelHook` and `postModelHook` are not provided
-		*/
-		if ("preModelHook" in params || "postModelHook" in params) throw new Error("The `preModelHook` and `postModelHook` parameters are not supported in the middleware version of the agent.");
-		/**
-		* Use v2 (middleware version)
-		*/
-		return createAgent$1(params);
-	} else
- /**
-	* Use v1 (original version)
-	*/
-	return createAgent(params);
+function createAgent(params) {
+	return new ReactAgent(params);
 }
 
 //#endregion
-export { createAgent$2 as createAgent };
+export { createAgent };
 //# sourceMappingURL=index.js.map

package/dist/agents/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["createAgent","params: any","createAgentV2","createAgentV1"],"sources":["../../src/agents/index.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type {\n  InteropZodObject,\n  InteropZodType,\n} from \"@langchain/core/utils/types\";\nimport { MessagesAnnotation } from \"@langchain/langgraph\";\n\n// Import v1 (without middleware)\nimport { createAgent as createAgentV1 } from \"./createAgent.js\";\nimport { ReactAgent as ReactAgentV1 } from \"./ReactAgent.js\";\n\n// Import v2 (with middleware)\nimport { createAgent as createAgentV2 } from \"./middlewareAgent/index.js\";\nimport { ReactAgent as ReactAgentV2 } from \"./middlewareAgent/ReactAgent.js\";\n\nimport type {\n  AnyAnnotationRoot,\n  ResponseFormatUndefined,\n} from \"./annotation.js\";\nimport type { CreateAgentParams, ExtractZodArrayTypes } from \"./types.js\";\nimport type {\n  CreateAgentParams as CreateAgentParamsV2,\n  AgentMiddleware,\n} from \"./middlewareAgent/types.js\";\nimport type {\n  ToolStrategy,\n  TypedToolStrategy,\n  ProviderStrategy,\n  JsonSchemaFormat,\n} from \"./responses.js\";\n\n// Re-export types and utilities\nexport * from \"./types.js\";\nexport * from \"./errors.js\";\nexport * from \"./interrupt.js\";\nexport { ToolNode } from \"./nodes/ToolNode.js\";\nexport {\n  toolStrategy,\n  providerStrategy,\n  ToolStrategy,\n  ProviderStrategy,\n  type ResponseFormat,\n} from \"./responses.js\";\nexport { createMiddleware } from \"./middlewareAgent/index.js\";\nexport type { AgentMiddleware } from \"./middlewareAgent/types.js\";\nexport type { ReactAgent } from \"./middlewareAgent/ReactAgent.js\";\n/**\n * Agents combine language models with tools to create systems that can reason\n * about tasks, decide which tools to use, and iteratively work towards solutions.\n * {@link createAgent} provides a production-ready ReAct (Reasoning + Acting)\n * agent implementation based on the paper {@link https://arxiv.org/abs/2210.03629|ReAct: Synergizing Reasoning and Acting in Language Models.}\n *\n * @example\n * ```ts\n * import { createAgent, tool } from \"langchain\";\n * import { z } from \"zod/v3\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   })\n * })\n *\n * const agent = createAgent({\n *   // use chat model from \"@langchain/openai\"\n *   model: \"openai:gpt-4o-mini\",\n *   tools: [getWeather]\n * });\n *\n * const inputs = {\n *   messages: [{ role: \"user\", content: \"what is the weather in SF?\" }],\n * };\n *\n * const stream = await agent.stream(inputs, { streamMode: \"values\" });\n *\n * for await (const { messages } of stream) {\n *   console.log(messages);\n * }\n * // Returns the messages in the state at each step of execution\n * ```\n */\n\n// ===== V1 OVERLOADS (WITHOUT MIDDLEWARE) =====\n// These overloads come first to ensure proper type inference when middleware is NOT provided\n\n// Overload 1: V1 - With responseFormat as single InteropZodType\nexport function createAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  T extends Record<string, any> = Record<string, any>,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateAgentParams<\n    StateSchema,\n    T,\n    ContextSchema,\n    InteropZodType<T>\n  > & {\n    responseFormat: InteropZodType<T>;\n  }\n): ReactAgentV1<StateSchema, T, ContextSchema>;\n\n// Overload 2: V1 - With responseFormat as array of InteropZodTypes\nexport function createAgent<\n  T extends readonly InteropZodType<any>[],\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateAgentParams<\n    StateSchema,\n    ExtractZodArrayTypes<T> extends Record<string, any>\n      ? ExtractZodArrayTypes<T>\n      : Record<string, any>,\n    ContextSchema,\n    T\n  > & {\n    responseFormat: T;\n  }\n): ReactAgentV1<\n  StateSchema,\n  ExtractZodArrayTypes<T> extends Record<string, any>\n    ? ExtractZodArrayTypes<T>\n    : Record<string, any>,\n  ContextSchema\n>;\n\n// Overload 3: V1 - With responseFormat as JsonSchemaFormat\nexport function createAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateAgentParams<\n    StateSchema,\n    Record<string, unknown>,\n    ContextSchema,\n    JsonSchemaFormat\n  > & {\n    responseFormat: JsonSchemaFormat;\n  }\n): ReactAgentV1<StateSchema, Record<string, unknown>, ContextSchema>;\n\n// Overload 4: V1 - With responseFormat as array of JsonSchemaFormat\nexport function createAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateAgentParams<\n    StateSchema,\n    Record<string, unknown>,\n    ContextSchema,\n    JsonSchemaFormat[]\n  > & {\n    responseFormat: JsonSchemaFormat[];\n  }\n): ReactAgentV1<StateSchema, Record<string, unknown>, ContextSchema>;\n\n// Overload 5: V1 - With responseFormat as union of JsonSchemaFormat | JsonSchemaFormat[]\nexport function createAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateAgentParams<\n    StateSchema,\n    Record<string, unknown>,\n    ContextSchema,\n    JsonSchemaFormat | JsonSchemaFormat[]\n  > & {\n    responseFormat: JsonSchemaFormat | JsonSchemaFormat[];\n  }\n): ReactAgentV1<StateSchema, Record<string, unknown>, ContextSchema>;\n\n// Overload 6: V1 - With responseFormat as TypedToolStrategy\nexport function createAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  T extends Record<string, any> = Record<string, any>,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateAgentParams<\n    StateSchema,\n    T,\n    ContextSchema,\n    TypedToolStrategy<T>\n  > & {\n    responseFormat: TypedToolStrategy<T>;\n  }\n): ReactAgentV1<StateSchema, T, ContextSchema>;\n\n// Overload 7: V1 - With responseFormat as single ToolStrategy\nexport function createAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  T extends Record<string, any> = Record<string, any>,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateAgentParams<StateSchema, T, ContextSchema, ToolStrategy<T>> & {\n    responseFormat: ToolStrategy<T>;\n  }\n): ReactAgentV1<StateSchema, T, ContextSchema>;\n\n// Overload 8: V1 - With responseFormat as ProviderStrategy\nexport function createAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  T extends Record<string, any> = Record<string, any>,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateAgentParams<\n    StateSchema,\n    T,\n    ContextSchema,\n    ProviderStrategy<T>\n  > & {\n    responseFormat: ProviderStrategy<T>;\n  }\n): ReactAgentV1<StateSchema, T, ContextSchema>;\n\n// Overload 9: V1 - Without responseFormat property at all\nexport function createAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: Omit<\n    CreateAgentParams<\n      StateSchema,\n      ResponseFormatUndefined,\n      ContextSchema,\n      never\n    >,\n    \"responseFormat\"\n  >\n): ReactAgentV1<StateSchema, ResponseFormatUndefined, ContextSchema>;\n\n// Overload 10: V1 - With responseFormat explicitly undefined\nexport function createAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: Omit<\n    CreateAgentParams<\n      StateSchema,\n      ResponseFormatUndefined,\n      ContextSchema,\n      never\n    >,\n    \"responseFormat\"\n  > & {\n    responseFormat?: undefined;\n  }\n): ReactAgentV1<StateSchema, ResponseFormatUndefined, ContextSchema>;\n\n// Overload 11: V1 - For other ResponseFormat values (failsafe)\nexport function createAgent<\n  StateSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = typeof MessagesAnnotation,\n  StructuredResponseFormat extends Record<string, any> = Record<string, any>,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot\n>(\n  params: CreateAgentParams<\n    StateSchema,\n    StructuredResponseFormat,\n    ContextSchema,\n    any\n  > & {\n    responseFormat: any;\n  }\n): ReactAgentV1<StateSchema, StructuredResponseFormat, ContextSchema>;\n\n// ===== V2 OVERLOADS (WITH MIDDLEWARE) =====\n// These overloads explicitly require the middleware property\n\n// Overload 12: With responseFormat as single InteropZodType and middleware\nexport function createAgent<\n  T extends Record<string, any> = Record<string, any>,\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware<\n    any,\n    any,\n    any\n  >[] = readonly AgentMiddleware<any, any, any>[]\n>(\n  params: CreateAgentParamsV2<T, ContextSchema, InteropZodType<T>> & {\n    responseFormat: InteropZodType<T>;\n    middleware: TMiddleware;\n  }\n): ReactAgentV2<T, ContextSchema, TMiddleware>;\n\n// Overload 13: With responseFormat as array of InteropZodTypes and middleware\nexport function createAgent<\n  T extends readonly InteropZodType<any>[],\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware<\n    any,\n    any,\n    any\n  >[] = readonly AgentMiddleware<any, any, any>[]\n>(\n  params: CreateAgentParamsV2<\n    ExtractZodArrayTypes<T> extends Record<string, any>\n      ? ExtractZodArrayTypes<T>\n      : Record<string, any>,\n    ContextSchema,\n    T\n  > & {\n    responseFormat: T;\n    middleware: TMiddleware;\n  }\n): ReactAgentV2<\n  ExtractZodArrayTypes<T> extends Record<string, any>\n    ? ExtractZodArrayTypes<T>\n    : Record<string, any>,\n  ContextSchema,\n  TMiddleware\n>;\n\n// Overload 14: With responseFormat as JsonSchemaFormat and middleware\nexport function createAgent<\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware<\n    any,\n    any,\n    any\n  >[] = readonly AgentMiddleware<any, any, any>[]\n>(\n  params: CreateAgentParamsV2<\n    Record<string, unknown>,\n    ContextSchema,\n    JsonSchemaFormat\n  > & {\n    responseFormat: JsonSchemaFormat;\n    middleware: TMiddleware;\n  }\n): ReactAgentV2<Record<string, unknown>, ContextSchema, TMiddleware>;\n\n// Overload 15: With responseFormat as array of JsonSchemaFormat and middleware\nexport function createAgent<\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware<\n    any,\n    any,\n    any\n  >[] = readonly AgentMiddleware<any, any, any>[]\n>(\n  params: CreateAgentParamsV2<\n    Record<string, unknown>,\n    ContextSchema,\n    JsonSchemaFormat[]\n  > & {\n    responseFormat: JsonSchemaFormat[];\n    middleware: TMiddleware;\n  }\n): ReactAgentV2<Record<string, unknown>, ContextSchema, TMiddleware>;\n\n// Overload 16: With responseFormat as union of JsonSchemaFormat | JsonSchemaFormat[] and middleware\nexport function createAgent<\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware<\n    any,\n    any,\n    any\n  >[] = readonly AgentMiddleware<any, any, any>[]\n>(\n  params: CreateAgentParamsV2<\n    Record<string, unknown>,\n    ContextSchema,\n    JsonSchemaFormat | JsonSchemaFormat[]\n  > & {\n    responseFormat: JsonSchemaFormat | JsonSchemaFormat[];\n    middleware: TMiddleware;\n  }\n): ReactAgentV2<Record<string, unknown>, ContextSchema, TMiddleware>;\n\n// Overload 17: With responseFormat as TypedToolStrategy and middleware\nexport function createAgent<\n  T extends Record<string, any> = Record<string, any>,\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware<\n    any,\n    any,\n    any\n  >[] = readonly AgentMiddleware<any, any, any>[]\n>(\n  params: CreateAgentParamsV2<T, ContextSchema, TypedToolStrategy<T>> & {\n    responseFormat: TypedToolStrategy<T>;\n    middleware: TMiddleware;\n  }\n): ReactAgentV2<T, ContextSchema, TMiddleware>;\n\n// Overload 18: With responseFormat as single ToolStrategy and middleware\nexport function createAgent<\n  T extends Record<string, any> = Record<string, any>,\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware<\n    any,\n    any,\n    any\n  >[] = readonly AgentMiddleware<any, any, any>[]\n>(\n  params: CreateAgentParamsV2<T, ContextSchema, ToolStrategy<T>> & {\n    responseFormat: ToolStrategy<T>;\n    middleware: TMiddleware;\n  }\n): ReactAgentV2<T, ContextSchema, TMiddleware>;\n\n// Overload 19: With responseFormat as ProviderStrategy and middleware\nexport function createAgent<\n  T extends Record<string, any> = Record<string, any>,\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware<\n    any,\n    any,\n    any\n  >[] = readonly AgentMiddleware<any, any, any>[]\n>(\n  params: CreateAgentParamsV2<T, ContextSchema, ProviderStrategy<T>> & {\n    responseFormat: ProviderStrategy<T>;\n    middleware: TMiddleware;\n  }\n): ReactAgentV2<T, ContextSchema, TMiddleware>;\n\n// Overload 20: Without responseFormat but with middleware\nexport function createAgent<\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware<\n    any,\n    any,\n    any\n  >[] = readonly AgentMiddleware<any, any, any>[]\n>(\n  params: Omit<\n    CreateAgentParamsV2<ResponseFormatUndefined, ContextSchema, never>,\n    \"responseFormat\"\n  > & { middleware: TMiddleware }\n): ReactAgentV2<ResponseFormatUndefined, ContextSchema, TMiddleware>;\n\n// Overload 21: With responseFormat explicitly undefined and middleware\nexport function createAgent<\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware<\n    any,\n    any,\n    any\n  >[] = readonly AgentMiddleware<any, any, any>[]\n>(\n  params: Omit<\n    CreateAgentParamsV2<ResponseFormatUndefined, ContextSchema, never>,\n    \"responseFormat\"\n  > & {\n    responseFormat?: undefined;\n    middleware: TMiddleware;\n  }\n): ReactAgentV2<ResponseFormatUndefined, ContextSchema, TMiddleware>;\n\n// Overload 22: For other ResponseFormat values with middleware (failsafe)\nexport function createAgent<\n  StructuredResponseFormat extends Record<string, any> = Record<string, any>,\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware<\n    any,\n    any,\n    any\n  >[] = readonly AgentMiddleware<any, any, any>[]\n>(\n  params: CreateAgentParamsV2<StructuredResponseFormat, ContextSchema, any> & {\n    responseFormat: any;\n    middleware: TMiddleware;\n  }\n): ReactAgentV2<StructuredResponseFormat, ContextSchema, TMiddleware>;\n\nexport function createAgent(params: any): any {\n  /**\n   * Check if middleware property is present\n   */\n  if (\"middleware\" in params && params.middleware !== undefined) {\n    /**\n     * The user wants to use the middleware version of the agent.\n     * Let's verify that `preModelHook` and `postModelHook` are not provided\n     */\n    if (\"preModelHook\" in params || \"postModelHook\" in params) {\n      throw new Error(\n        \"The `preModelHook` and `postModelHook` parameters are not supported in the middleware version of the agent.\"\n      );\n    }\n\n    /**\n     * Use v2 (middleware version)\n     */\n    return createAgentV2(params);\n  } else {\n    /**\n     * Use v1 (original version)\n     */\n    return createAgentV1(params);\n  }\n}\n"],"mappings":";;;;;;;;;AAogBA,SAAgBA,cAAYC,QAAkB;;;;AAI5C,KAAI,gBAAgB,UAAU,OAAO,eAAe,QAAW;;;;;AAK7D,MAAI,kBAAkB,UAAU,mBAAmB,OACjD,OAAM,IAAI,MACR;;;;AAOJ,SAAOC,cAAc,OAAO;CAC7B;;;;AAIC,QAAOC,YAAc,OAAO;AAE/B"}
+{"version":3,"file":"index.js","names":["params: CreateAgentParams<StructuredResponseFormat, ContextSchema, any>"],"sources":["../../src/agents/index.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type {\n  InteropZodObject,\n  InteropZodType,\n} from \"@langchain/core/utils/types\";\n\nimport type { ResponseFormatUndefined } from \"./responses.js\";\nimport type { CreateAgentParams } from \"./types.js\";\nimport type { AgentMiddleware, AnyAnnotationRoot } from \"./middleware/types.js\";\nimport type { ExtractZodArrayTypes } from \"./types.js\";\nimport type {\n  ToolStrategy,\n  TypedToolStrategy,\n  ProviderStrategy,\n  ResponseFormat,\n  JsonSchemaFormat,\n} from \"./responses.js\";\nimport { ReactAgent } from \"./ReactAgent.js\";\n\n/**\n * Creates a production-ready ReAct (Reasoning + Acting) agent that combines language models with tools\n * and middleware to create systems that can reason about tasks, decide which tools to use, and iteratively\n * work towards solutions.\n *\n * The agent follows the ReAct pattern, interleaving reasoning steps with tool calls to iteratively\n * work towards solutions. It can handle multiple tool calls in sequence or parallel, maintain state\n * across interactions, and provide auditable decision processes.\n *\n * ## Core Components\n *\n * ### Model\n * The reasoning engine can be specified as:\n * - **String identifier**: `\"openai:gpt-4o\"` for simple setup\n * - **Model instance**: Configured model object for full control\n * - **Dynamic function**: Select models at runtime based on state\n *\n * ### Tools\n * Tools give agents the ability to take actions:\n * - Pass an array of tools created with the `tool` function\n * - Or provide a configured `ToolNode` for custom error handling\n *\n * ### Prompt\n * Shape how your agent approaches tasks:\n * - String for simple instructions\n * - SystemMessage for structured prompts\n * - Function for dynamic prompts based on state\n *\n * ### Middleware\n * Middleware allows you to extend the agent's behavior:\n * - Add pre/post-model processing for context injection or validation\n * - Add dynamic control flows, e.g. terminate invocation or retries\n * - Add human-in-the-loop capabilities\n * - Add tool calls to the agent\n * - Add tool results to the agent\n *\n * ## Advanced Features\n *\n * - **Structured Output**: Use `responseFormat` with a Zod schema to get typed responses\n * - **Memory**: Extend the state schema to remember information across interactions\n * - **Streaming**: Get real-time updates as the agent processes\n *\n * @param options - Configuration options for the agent\n * @param options.llm - The language model as an instance of a chat model\n * @param options.model - The language model as a string identifier, see more in {@link https://docs.langchain.com/oss/javascript/langchain/models#basic-usage | Models}.\n * @param options.tools - Array of tools or configured ToolNode\n * @param options.prompt - System instructions (string, SystemMessage, or function)\n * @param options.responseFormat - Zod schema for structured output\n * @param options.stateSchema - Custom state schema for memory\n * @param options.middleware - Array of middleware for extending agent behavior, see more in {@link https://docs.langchain.com/oss/javascript/langchain/middleware | Middleware}.\n *\n * @returns A ReactAgent instance with `invoke` and `stream` methods\n *\n * @example Basic agent with tools\n * ```ts\n * import { createAgent, tool } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const search = tool(\n *   ({ query }) => `Results for: ${query}`,\n *   {\n *     name: \"search\",\n *     description: \"Search for information\",\n *     schema: z.object({\n *       query: z.string().describe(\"The search query\"),\n *     })\n *   }\n * );\n *\n * const agent = createAgent({\n *   llm: \"openai:gpt-4o\",\n *   tools: [search],\n * });\n *\n * const result = await agent.invoke({\n *   messages: [{ role: \"user\", content: \"Search for ReAct agents\" }],\n * });\n * ```\n *\n * @example Structured output\n * ```ts\n * import { createAgent } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const ContactInfo = z.object({\n *   name: z.string(),\n *   email: z.string(),\n *   phone: z.string(),\n * });\n *\n * const agent = createAgent({\n *   llm: \"openai:gpt-4o\",\n *   tools: [],\n *   responseFormat: ContactInfo,\n * });\n *\n * const result = await agent.invoke({\n *   messages: [{\n *     role: \"user\",\n *     content: \"Extract: John Doe, john@example.com, (555) 123-4567\"\n *   }],\n * });\n *\n * console.log(result.structuredResponse);\n * // { name: 'John Doe', email: 'john@example.com', phone: '(555) 123-4567' }\n * ```\n *\n * @example Streaming responses\n * ```ts\n * const stream = await agent.stream(\n *   { messages: [{ role: \"user\", content: \"What's the weather?\" }] },\n *   { streamMode: \"values\" }\n * );\n *\n * for await (const chunk of stream) {\n *   // ...\n * }\n * ```\n */\n// Overload 1: With responseFormat as single InteropZodType\nexport function createAgent<\n  T extends Record<string, any> = Record<string, any>,\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n  params: CreateAgentParams<T, ContextSchema, InteropZodType<T>> & {\n    responseFormat: InteropZodType<T>;\n    middleware?: TMiddleware;\n  }\n): ReactAgent<T, ContextSchema, TMiddleware>;\n\n// Overload 2: With responseFormat as array of InteropZodTypes (infers union type)\nexport function createAgent<\n  T extends readonly InteropZodType<any>[],\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n  params: CreateAgentParams<\n    ExtractZodArrayTypes<T> extends Record<string, any>\n      ? ExtractZodArrayTypes<T>\n      : Record<string, any>,\n    ContextSchema,\n    T\n  > & {\n    responseFormat: T;\n    middleware?: TMiddleware;\n  }\n): ReactAgent<\n  ExtractZodArrayTypes<T> extends Record<string, any>\n    ? ExtractZodArrayTypes<T>\n    : Record<string, any>,\n  ContextSchema,\n  TMiddleware\n>;\n\n// Overload 3: With responseFormat as JsonSchemaFormat (JSON schema object)\nexport function createAgent<\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n  params: CreateAgentParams<\n    Record<string, unknown>,\n    ContextSchema,\n    JsonSchemaFormat\n  > & {\n    responseFormat: JsonSchemaFormat;\n    middleware?: TMiddleware;\n  }\n): ReactAgent<Record<string, unknown>, ContextSchema, TMiddleware>;\n\n// Overload 4: With responseFormat as array of JsonSchemaFormat (JSON schema objects)\nexport function createAgent<\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n  params: CreateAgentParams<\n    Record<string, unknown>,\n    ContextSchema,\n    JsonSchemaFormat[]\n  > & {\n    responseFormat: JsonSchemaFormat[];\n    middleware?: TMiddleware;\n  }\n): ReactAgent<Record<string, unknown>, ContextSchema, TMiddleware>;\n\n// Overload 4.5: With responseFormat as union of JsonSchemaFormat | JsonSchemaFormat[]\nexport function createAgent<\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n  params: CreateAgentParams<\n    Record<string, unknown>,\n    ContextSchema,\n    JsonSchemaFormat | JsonSchemaFormat[]\n  > & {\n    responseFormat: JsonSchemaFormat | JsonSchemaFormat[];\n    middleware?: TMiddleware;\n  }\n): ReactAgent<Record<string, unknown>, ContextSchema, TMiddleware>;\n\n// Overload 5: With responseFormat as TypedToolStrategy (for union types from toolStrategy)\nexport function createAgent<\n  T extends Record<string, any> = Record<string, any>,\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n  params: CreateAgentParams<T, ContextSchema, TypedToolStrategy<T>> & {\n    responseFormat: TypedToolStrategy<T>;\n    middleware?: TMiddleware;\n  }\n): ReactAgent<T, ContextSchema, TMiddleware>;\n\n// Overload 6: With responseFormat as single ToolStrategy instance\nexport function createAgent<\n  T extends Record<string, any> = Record<string, any>,\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n  params: CreateAgentParams<T, ContextSchema, ToolStrategy<T>> & {\n    responseFormat: ToolStrategy<T>;\n    middleware?: TMiddleware;\n  }\n): ReactAgent<T, ContextSchema, TMiddleware>;\n\n// Overload 7: With responseFormat as ProviderStrategy\nexport function createAgent<\n  T extends Record<string, any> = Record<string, any>,\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n  params: CreateAgentParams<T, ContextSchema, ProviderStrategy<T>> & {\n    responseFormat: ProviderStrategy<T>;\n    middleware?: TMiddleware;\n  }\n): ReactAgent<T, ContextSchema, TMiddleware>;\n\n// Overload 8: Without responseFormat property at all - with proper middleware state typing\nexport function createAgent<\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n  params: Omit<\n    CreateAgentParams<ResponseFormatUndefined, ContextSchema, never>,\n    \"responseFormat\"\n  > & { middleware?: TMiddleware }\n): ReactAgent<ResponseFormatUndefined, ContextSchema, TMiddleware>;\n\n// Overload 9: With responseFormat explicitly undefined\nexport function createAgent<\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n  params: Omit<\n    CreateAgentParams<ResponseFormatUndefined, ContextSchema, never>,\n    \"responseFormat\"\n  > & {\n    responseFormat?: undefined;\n    middleware?: TMiddleware;\n  }\n): ReactAgent<ResponseFormatUndefined, ContextSchema, TMiddleware>;\n\n// Overload 10: For other ResponseFormat values (failsafe)\nexport function createAgent<\n  StructuredResponseFormat extends Record<string, any> = Record<string, any>,\n  ContextSchema extends\n    | AnyAnnotationRoot\n    | InteropZodObject = AnyAnnotationRoot,\n  TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n  params: CreateAgentParams<\n    StructuredResponseFormat,\n    ContextSchema,\n    ResponseFormat\n  > & {\n    responseFormat: ResponseFormat;\n    middleware?: TMiddleware;\n  }\n): ReactAgent<StructuredResponseFormat, ContextSchema, TMiddleware>;\n\n// Implementation\nexport function createAgent<\n  StructuredResponseFormat extends Record<string, any>,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject,\n  TMiddleware extends readonly AgentMiddleware[] = []\n>(\n  params: CreateAgentParams<StructuredResponseFormat, ContextSchema, any>\n): ReactAgent<StructuredResponseFormat, ContextSchema, TMiddleware> {\n  return new ReactAgent(params);\n}\n\n// Re-export types and utilities\nexport * from \"./types.js\";\nexport * from \"./errors.js\";\nexport type { JumpToTarget } from \"./constants.js\";\nexport type { Runtime } from \"./runtime.js\";\nexport {\n  toolStrategy,\n  providerStrategy,\n  ToolStrategy,\n  ProviderStrategy,\n  type ResponseFormat,\n  type ResponseFormatUndefined,\n} from \"./responses.js\";\nexport { createMiddleware } from \"./middleware.js\";\nexport type {\n  ToolCallRequest,\n  ToolCallHandler,\n  ToolCallWrapper,\n} from \"./middleware/types.js\";\nexport { FakeToolCallingModel } from \"./tests/utils.js\";\nexport type { ReactAgent } from \"./ReactAgent.js\";\n"],"mappings":";;;;;;;AA+TA,SAAgB,YAKdA,QACkE;AAClE,QAAO,IAAI,WAAW;AACvB"}