npm - langchain - Versions diffs - 1.0.0-alpha.9 → 1.0.2 - Mend

langchain 1.0.0-alpha.9 → 1.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (445) hide show

package/dist/agents/index.d.cts CHANGED Viewed

@@ -2,7 +2,7 @@ import { MultipleStructuredOutputsError, MultipleToolsBoundError, StructuredOutp
 import { JsonSchemaFormat, ProviderStrategy, ResponseFormat, ResponseFormatUndefined, ToolStrategy, TypedToolStrategy, providerStrategy, toolStrategy } from "./responses.cjs";
 import { JumpToTarget } from "./constants.cjs";
 import { Runtime } from "./runtime.cjs";
-import { AgentMiddleware, AnyAnnotationRoot, ToolCallHandler, ToolCallRequest, ToolCallWrapper } from "./middleware/types.cjs";
+import { AgentMiddleware, AnyAnnotationRoot, ToolCallHandler, ToolCallRequest, WrapToolCallHook } from "./middleware/types.cjs";
 import { BuiltInState, CreateAgentParams, ExecutedToolCall, ExtractZodArrayTypes, Interrupt, JumpTo, N, ToolCall, ToolResult, UserInput, WithStateGraphNodes } from "./types.cjs";
 import { ReactAgent } from "./ReactAgent.cjs";
 import { createMiddleware } from "./middleware.cjs";
@@ -131,59 +131,59 @@ import { InteropZodObject, InteropZodType } from "@langchain/core/utils/types";
  * ```
  */
 // 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>> & {
+declare function createAgent<T extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, ContextSchema, InteropZodType<T>> & {
   responseFormat: InteropZodType<T>;
   middleware?: TMiddleware;
-}): ReactAgent<T, ContextSchema, TMiddleware>;
+}): ReactAgent<T, StateSchema, 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> & {
+declare function createAgent<T extends readonly InteropZodType<any>[], StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, StateSchema, ContextSchema, T> & {
   responseFormat: T;
   middleware?: TMiddleware;
-}): ReactAgent<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, ContextSchema, TMiddleware>;
+}): ReactAgent<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, StateSchema, 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> & {
+declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, ContextSchema, JsonSchemaFormat> & {
   responseFormat: JsonSchemaFormat;
   middleware?: TMiddleware;
-}): ReactAgent<Record<string, unknown>, ContextSchema, TMiddleware>;
+}): ReactAgent<Record<string, unknown>, StateSchema, 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[]> & {
+declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, ContextSchema, JsonSchemaFormat[]> & {
   responseFormat: JsonSchemaFormat[];
   middleware?: TMiddleware;
-}): ReactAgent<Record<string, unknown>, ContextSchema, TMiddleware>;
+}): ReactAgent<Record<string, unknown>, StateSchema, 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[]> & {
+declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, ContextSchema, JsonSchemaFormat | JsonSchemaFormat[]> & {
   responseFormat: JsonSchemaFormat | JsonSchemaFormat[];
   middleware?: TMiddleware;
-}): ReactAgent<Record<string, unknown>, ContextSchema, TMiddleware>;
+}): ReactAgent<Record<string, unknown>, StateSchema, 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>> & {
+declare function createAgent<T extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, ContextSchema, TypedToolStrategy<T>> & {
   responseFormat: TypedToolStrategy<T>;
   middleware?: TMiddleware;
-}): ReactAgent<T, ContextSchema, TMiddleware>;
+}): ReactAgent<T, StateSchema, 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>> & {
+declare function createAgent<T extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, ContextSchema, ToolStrategy<T>> & {
   responseFormat: ToolStrategy<T>;
   middleware?: TMiddleware;
-}): ReactAgent<T, ContextSchema, TMiddleware>;
+}): ReactAgent<T, StateSchema, 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>> & {
+declare function createAgent<T extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, ContextSchema, ProviderStrategy<T>> & {
   responseFormat: ProviderStrategy<T>;
   middleware?: TMiddleware;
-}): ReactAgent<T, ContextSchema, TMiddleware>;
+}): ReactAgent<T, StateSchema, 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"> & {
+declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, StateSchema, ContextSchema, never>, "responseFormat"> & {
   middleware?: TMiddleware;
-}): ReactAgent<ResponseFormatUndefined, ContextSchema, TMiddleware>;
+}): ReactAgent<ResponseFormatUndefined, StateSchema, 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"> & {
+declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, StateSchema, ContextSchema, never>, "responseFormat"> & {
   responseFormat?: undefined;
   middleware?: TMiddleware;
-}): ReactAgent<ResponseFormatUndefined, ContextSchema, TMiddleware>;
+}): ReactAgent<ResponseFormatUndefined, StateSchema, 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> & {
+declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<StructuredResponseFormat, StateSchema, ContextSchema, ResponseFormat> & {
   responseFormat: ResponseFormat;
   middleware?: TMiddleware;
-}): ReactAgent<StructuredResponseFormat, ContextSchema, TMiddleware>;
+}): ReactAgent<StructuredResponseFormat, StateSchema, ContextSchema, TMiddleware>;
 // Re-export types and utilities
 //#endregion

package/dist/agents/index.d.cts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.cts","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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"}
1	+ {"version":3,"file":"index.d.cts","names":["InteropZodObject","InteropZodType","ResponseFormatUndefined","CreateAgentParams","AgentMiddleware","AnyAnnotationRoot","ExtractZodArrayTypes","ToolStrategy","TypedToolStrategy","ProviderStrategy","ResponseFormat","JsonSchemaFormat","ReactAgent","createAgent","Record","T","StateSchema","ContextSchema","TMiddleware","Omit","StructuredResponseFormat","JumpToTarget","Runtime","toolStrategy","providerStrategy","createMiddleware","ToolCallRequest","ToolCallHandler","WrapToolCallHook","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>, StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, ContextSchema, InteropZodType<T>> & {\n responseFormat: InteropZodType<T>;\n middleware?: TMiddleware;\n}): ReactAgent<T, StateSchema, ContextSchema, TMiddleware>;\n// Overload 2: With responseFormat as array of InteropZodTypes (infers union type)\nexport declare function createAgent<T extends readonly InteropZodType<any>[], StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, StateSchema, ContextSchema, T> & {\n responseFormat: T;\n middleware?: TMiddleware;\n}): ReactAgent<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, StateSchema, ContextSchema, TMiddleware>;\n// Overload 3: With responseFormat as JsonSchemaFormat (JSON schema object)\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, ContextSchema, JsonSchemaFormat> & {\n responseFormat: JsonSchemaFormat;\n middleware?: TMiddleware;\n}): ReactAgent<Record<string, unknown>, StateSchema, ContextSchema, TMiddleware>;\n// Overload 4: With responseFormat as array of JsonSchemaFormat (JSON schema objects)\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, ContextSchema, JsonSchemaFormat[]> & {\n responseFormat: JsonSchemaFormat[];\n middleware?: TMiddleware;\n}): ReactAgent<Record<string, unknown>, StateSchema, ContextSchema, TMiddleware>;\n// Overload 4.5: With responseFormat as union of JsonSchemaFormat \| JsonSchemaFormat[]\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, ContextSchema, JsonSchemaFormat \| JsonSchemaFormat[]> & {\n responseFormat: JsonSchemaFormat \| JsonSchemaFormat[];\n middleware?: TMiddleware;\n}): ReactAgent<Record<string, unknown>, StateSchema, 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>, StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, ContextSchema, TypedToolStrategy<T>> & {\n responseFormat: TypedToolStrategy<T>;\n middleware?: TMiddleware;\n}): ReactAgent<T, StateSchema, ContextSchema, TMiddleware>;\n// Overload 6: With responseFormat as single ToolStrategy instance\nexport declare function createAgent<T extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, ContextSchema, ToolStrategy<T>> & {\n responseFormat: ToolStrategy<T>;\n middleware?: TMiddleware;\n}): ReactAgent<T, StateSchema, ContextSchema, TMiddleware>;\n// Overload 7: With responseFormat as ProviderStrategy\nexport declare function createAgent<T extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, ContextSchema, ProviderStrategy<T>> & {\n responseFormat: ProviderStrategy<T>;\n middleware?: TMiddleware;\n}): ReactAgent<T, StateSchema, ContextSchema, TMiddleware>;\n// Overload 8: Without responseFormat property at all - with proper middleware state typing\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, StateSchema, ContextSchema, never>, \"responseFormat\"> & {\n middleware?: TMiddleware;\n}): ReactAgent<ResponseFormatUndefined, StateSchema, ContextSchema, TMiddleware>;\n// Overload 9: With responseFormat explicitly undefined\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, StateSchema, ContextSchema, never>, \"responseFormat\"> & {\n responseFormat?: undefined;\n middleware?: TMiddleware;\n}): ReactAgent<ResponseFormatUndefined, StateSchema, ContextSchema, TMiddleware>;\n// Overload 10: For other ResponseFormat values (failsafe)\nexport declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<StructuredResponseFormat, StateSchema, ContextSchema, ResponseFormat> & {\n responseFormat: ResponseFormat;\n middleware?: TMiddleware;\n}): ReactAgent<StructuredResponseFormat, StateSchema, 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, WrapToolCallHook, } from \"./middleware/types.js\";\nexport { FakeToolCallingModel } from \"./tests/utils.js\";\nexport type { ReactAgent } from \"./ReactAgent.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;AAgIA;;;;;;;;;;;;;;;;;;;;;;;;;AAGc;AAEd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGc;AAEd;;;;;;;;;;;;;;;;;;;;;AAGc;AAEd;;;;;;;;;;;;;;;;;;;;;AAGc;AAEd;;;;;;;;;;;;;AAA2XW,iBApBnWE,WAoBmWF,CAAAA,UApB7UG,MAoB6UH,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GApBvTG,MAoBuTH,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAAAA,oBApB9QN,iBAoB8QM,GApB1PX,gBAoB0PW,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBApB1LN,iBAoB0LM,GApBtKX,gBAoBsKW,GApBnJN,iBAoBmJM,EAAAA,0BAAAA,SApB7FP,eAoB6FO,EAAAA,GAAAA,SApBhEP,eAoBgEO,EAAAA,CAAAA,CAAAA,MAAAA,EApBrCR,iBAoBqCQ,CApBnBI,CAoBmBJ,EApBhBK,WAoBgBL,EApBHM,aAoBGN,EApBYV,cAoBZU,CApB2BI,CAoB3BJ,CAAAA,CAAAA,GAAAA;EAAgB,cAA1GR,EAnB7QF,cAmB6QE,CAnB9PY,CAmB8PZ,CAAAA;EAAiB,UAC9RQ,CAAAA,EAnBHO,WAmBGP;CAAgB,CAAA,EAlBhCC,UAkBmCD,CAlBxBI,CAkBwBJ,EAlBrBK,WAkBqBL,EAlBRM,aAkBQN,EAlBOO,WAkBPP,CAAAA;;AAExBG,iBAlBSD,WAkBTC,CAAAA,UAAAA,SAlBwCb,cAkBxCa,CAAAA,GAAAA,CAAAA,EAAAA,EAAAA,oBAlBmFT,iBAkBnFS,GAlBuGd,gBAkBvGc,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBAlBuKT,iBAkBvKS,GAlB2Ld,gBAkB3Lc,GAlB8MT,iBAkB9MS,EAAAA,0BAAAA,SAlBoQV,eAkBpQU,EAAAA,GAAAA,SAlBiSV,eAkBjSU,EAAAA,CAAAA,CAAAA,MAAAA,EAlB4TX,iBAkB5TW,CAlB8UR,oBAkB9UQ,CAlBmWC,CAkBnWD,CAAAA,SAlB8WA,MAkB9WA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAlBoYR,oBAkBpYQ,CAlByZC,CAkBzZD,CAAAA,GAlB8ZA,MAkB9ZA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAlBmbE,WAkBnbF,EAlBgcG,aAkBhcH,EAlB+cC,CAkB/cD,CAAAA,GAAAA;EAAM,cAAmBE,EAjBpBD,CAiBoBC;EAAW,UAAEC,CAAAA,EAhBpCC,WAgBoCD;CAAa,CAAA,EAf9DL,UAegEM,CAfrDZ,oBAeqDY,CAfhCH,CAegCG,CAAAA,SAfrBJ,MAeqBI,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAfCZ,oBAeDY,CAfsBH,CAetBG,CAAAA,GAf2BJ,MAe3BI,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAfgDF,WAehDE,EAf6DD,aAe7DC,EAf4EA,WAe5EA,CAAAA;;AAAtD,iBAbUL,WAaV,CAAA,oBAb0CR,iBAa1C,GAb8DL,gBAa9D,GAAA,SAAA,GAAA,SAAA,EAAA,sBAb8HK,iBAa9H,GAbkJL,gBAalJ,GAbqKK,iBAarK,EAAA,0BAAA,SAb2ND,eAa3N,EAAA,GAAA,SAbwPA,eAaxP,EAAA,CAAA,CAAA,MAAA,EAbmRD,iBAanR,CAbqSW,MAarS,CAAA,MAAA,EAAA,OAAA,CAAA,EAb8TE,WAa9T,EAb2UC,aAa3U,EAb0VN,gBAa1V,CAAA,GAAA;EAEUE,cAAW,EAdfF,gBAce;EAAA,UAAA,CAAA,EAblBO,WAakB;CAAA,CAAA,EAZ/BN,UAY0CE,CAZ/BA,MAY+BA,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAZNE,WAYMF,EAZOG,aAYPH,EAZsBI,WAYtBJ,CAAAA;;AAA+DT,iBAVrFQ,WAUqFR,CAAAA,oBAVrDA,iBAUqDA,GAVjCL,gBAUiCK,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBAV+BA,iBAU/BA,GAVmDL,gBAUnDK,GAVsEA,iBAUtEA,EAAAA,0BAAAA,SAV4HD,eAU5HC,EAAAA,GAAAA,SAVyJD,eAUzJC,EAAAA,CAAAA,CAAAA,MAAAA,EAVoLF,iBAUpLE,CAVsMS,MAUtMT,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAV+NW,WAU/NX,EAV4OY,aAU5OZ,EAV2PM,gBAU3PN,EAAAA,CAAAA,GAAAA;EAAiB,cAAGL,EAT7GW,gBAS6GX,EAAAA;EAAgB,UAAgDK,CAAAA,EARhLa,WAQgLb;CAAiB,CAAA,EAP9MO,UAOiNZ,CAPtMc,MAOsMd,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAP7KgB,WAO6KhB,EAPhKiB,aAOgKjB,EAPjJkB,WAOiJlB,CAAAA;;AAAyEI,iBALtQS,WAKsQT,CAAAA,oBALtOC,iBAKsOD,GALlNJ,gBAKkNI,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBALlJC,iBAKkJD,GAL9HJ,gBAK8HI,GAL3GC,iBAK2GD,EAAAA,0BAAAA,SALrDA,eAKqDA,EAAAA,GAAAA,SALxBA,eAKwBA,EAAAA,CAAAA,CAAAA,MAAAA,EALGD,iBAKHC,CALqBU,MAKrBV,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAL8CY,WAK9CZ,EAL2Da,aAK3Db,EAL0EO,gBAK1EP,GAL6FO,gBAK7FP,EAAAA,CAAAA,GAAAA;EAAe,cAAcA,EAJvSO,gBAIuSP,GAJpRO,gBAIoRP,EAAAA;EAAe,UAA8BW,CAAAA,EAHvVG,WAGuVH;CAAC,CAAA,EAFrWH,UAEuWI,CAF5VF,MAE4VE,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAFnUA,WAEmUA,EAFtTC,aAEsTD,EAFvSE,WAEuSF,CAAAA;;AAA8CD,iBAAjYF,WAAiYE,CAAAA,UAA3WD,MAA2WC,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAArVD,MAAqVC,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAAAA,oBAA5SV,iBAA4SU,GAAxRf,gBAAwRe,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBAAxNV,iBAAwNU,GAApMf,gBAAoMe,GAAjLV,iBAAiLU,EAAAA,0BAAAA,SAA3HX,eAA2HW,EAAAA,GAAAA,SAA9FX,eAA8FW,EAAAA,CAAAA,CAAAA,MAAAA,EAAnEZ,iBAAmEY,CAAjDA,CAAiDA,EAA9CC,WAA8CD,EAAjCE,aAAiCF,EAAlBP,iBAAkBO,CAAAA,CAAAA,CAAAA,CAAAA,GAAAA;EAAC,cAAnBP,EACnXA,iBADmXA,CACjWO,CADiWP,CAAAA;EAAiB,UAAlEL,CAAAA,EAErUe,WAFqUf;CAAiB,CAAA,EAGnWS,UAFkCG,CAEvBA,CAFuBA,EAEpBC,WAFoBD,EAEPE,aAFOF,EAEQG,WAFRH,CAAAA;;AACrBG,iBAGOL,WAHPK,CAAAA,UAG6BJ,MAH7BI,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAGmDJ,MAHnDI,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAAAA,oBAG4Fb,iBAH5Fa,GAGgHlB,gBAHhHkB,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBAGgLb,iBAHhLa,GAGoMlB,gBAHpMkB,GAGuNb,iBAHvNa,EAAAA,0BAAAA,SAG6Qd,eAH7Qc,EAAAA,GAAAA,SAG0Sd,eAH1Sc,EAAAA,CAAAA,CAAAA,MAAAA,EAGqUf,iBAHrUe,CAGuVH,CAHvVG,EAG0VF,WAH1VE,EAGuWD,aAHvWC,EAGsXX,YAHtXW,CAGmYH,CAHnYG,CAAAA,CAAAA,GAAAA;EAAW,cACbH,EAGKR,YAHLQ,CAGkBA,CAHlBA,CAAAA;EAAC,UAAEC,CAAAA,EAIDE,WAJCF;CAAW,CAAA,EAKzBJ,UAL2BK,CAKhBF,CALgBE,EAKbD,WALaC,EAKAA,aALAA,EAKeC,WALfD,CAAAA;;AAA3BL,iBAOoBC,WAPpBD,CAAAA,UAO0CE,MAP1CF,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAOgEE,MAPhEF,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAAAA,oBAOyGP,iBAPzGO,GAO6HZ,gBAP7HY,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBAO6LP,iBAP7LO,GAOiNZ,gBAPjNY,GAOoOP,iBAPpOO,EAAAA,0BAAAA,SAO0RR,eAP1RQ,EAAAA,GAAAA,SAOuTR,eAPvTQ,EAAAA,CAAAA,CAAAA,MAAAA,EAOkVT,iBAPlVS,CAOoWG,CAPpWH,EAOuWI,WAPvWJ,EAOoXK,aAPpXL,EAOmYH,gBAPnYG,CAOoZG,CAPpZH,CAAAA,CAAAA,GAAAA;EAAU,cAAA,EAQMH,gBARN,CAQuBM,CARvB,CAAA;EAEUF,UAAAA,CAAAA,EAOPK,WAPkB;CAAA,CAAA,EAQ/BN,UAR+B,CAQpBG,CARoB,EAQjBC,WARiB,EAQJC,aARI,EAQWC,WARX,CAAA;;AAAiCJ,iBAU5CD,WAV4CC,CAAAA,oBAUZT,iBAVYS,GAUQd,gBAVRc,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBAUwET,iBAVxES,GAU4Fd,gBAV5Fc,GAU+GT,iBAV/GS,EAAAA,0BAAAA,SAUqKV,eAVrKU,EAAAA,GAAAA,SAUkMV,eAVlMU,EAAAA,CAAAA,CAAAA,MAAAA,EAU6NK,IAV7NL,CAUkOX,iBAVlOW,CAUoPZ,uBAVpPY,EAU6QE,WAV7QF,EAU0RG,aAV1RH,EAAAA,KAAAA,CAAAA,EAAAA,gBAAAA,CAAAA,GAAAA;EAAM,UAAmCT,CAAAA,EAW5Fa,WAX4Fb;CAAiB,CAAA,EAY1HO,UAZ6HZ,CAYlHE,uBAZkHF,EAYzFgB,WAZyFhB,EAY5EiB,aAZ4EjB,EAY7DkB,WAZ6DlB,CAAAA;;AAAoFA,iBAc7La,WAd6Lb,CAAAA,oBAc7JK,iBAd6JL,GAczIA,gBAdyIA,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBAczEK,iBAdyEL,GAcrDA,gBAdqDA,GAclCK,iBAdkCL,EAAAA,0BAAAA,SAcoBI,eAdpBJ,EAAAA,GAAAA,SAciDI,eAdjDJ,EAAAA,CAAAA,CAAAA,MAAAA,EAc4EmB,IAd5EnB,CAciFG,iBAdjFH,CAcmGE,uBAdnGF,EAc4HgB,WAd5HhB,EAcyIiB,aAdzIjB,EAAAA,KAAAA,CAAAA,EAAAA,gBAAAA,CAAAA,GAAAA;EAAgB,cAAGK,CAAAA,EAAAA,SAAAA;EAAiB,UAAqCD,CAAAA,EAgB7Qc,WAhB6Qd;CAAe,CAAA,EAiBzSQ,UAjBuTR,CAiB5SF,uBAjB4SE,EAiBnRY,WAjBmRZ,EAiBtQa,aAjBsQb,EAiBvPc,WAjBuPd,CAAAA;;AAAgDY,iBAmBnVH,WAnBmVG,CAAAA,iCAmBtSF,MAnBsSE,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAmBhRF,MAnBgRE,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAAAA,oBAmBvOX,iBAnBuOW,GAmBnNhB,gBAnBmNgB,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBAmBnJX,iBAnBmJW,GAmB/HhB,gBAnB+HgB,GAmB5GX,iBAnB4GW,EAAAA,0BAAAA,SAmBtDZ,eAnBsDY,EAAAA,GAAAA,SAmBzBZ,eAnByBY,EAAAA,CAAAA,CAAAA,MAAAA,EAmBEb,iBAnBFa,CAmBoBI,wBAnBpBJ,EAmB8CA,WAnB9CA,EAmB2DC,aAnB3DD,EAmB0EN,cAnB1EM,CAAAA,GAAAA;EAAW,cAAEC,EAoBpWP,cApBoWO;EAAa,UAAeF,CAAAA,EAqBnYG,WArBmYH;CAAC,CAAA,EAsBjZH,UAtBmYL,CAsBxXa,wBAtBwXb,EAsB9VS,WAtB8VT,EAsBjVU,aAtBiVV,EAsBlUW,WAtBkUX,CAAAA"}

package/dist/agents/index.d.ts CHANGED Viewed

@@ -2,7 +2,7 @@ import { MultipleStructuredOutputsError, MultipleToolsBoundError, StructuredOutp
 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 { AgentMiddleware, AnyAnnotationRoot, ToolCallHandler, ToolCallRequest, WrapToolCallHook } 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 { createMiddleware } from "./middleware.js";
@@ -131,59 +131,59 @@ import { InteropZodObject, InteropZodType } from "@langchain/core/utils/types";
  * ```
  */
 // 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>> & {
+declare function createAgent<T extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, ContextSchema, InteropZodType<T>> & {
   responseFormat: InteropZodType<T>;
   middleware?: TMiddleware;
-}): ReactAgent<T, ContextSchema, TMiddleware>;
+}): ReactAgent<T, StateSchema, 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> & {
+declare function createAgent<T extends readonly InteropZodType<any>[], StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, StateSchema, ContextSchema, T> & {
   responseFormat: T;
   middleware?: TMiddleware;
-}): ReactAgent<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, ContextSchema, TMiddleware>;
+}): ReactAgent<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, StateSchema, 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> & {
+declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, ContextSchema, JsonSchemaFormat> & {
   responseFormat: JsonSchemaFormat;
   middleware?: TMiddleware;
-}): ReactAgent<Record<string, unknown>, ContextSchema, TMiddleware>;
+}): ReactAgent<Record<string, unknown>, StateSchema, 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[]> & {
+declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, ContextSchema, JsonSchemaFormat[]> & {
   responseFormat: JsonSchemaFormat[];
   middleware?: TMiddleware;
-}): ReactAgent<Record<string, unknown>, ContextSchema, TMiddleware>;
+}): ReactAgent<Record<string, unknown>, StateSchema, 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[]> & {
+declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, ContextSchema, JsonSchemaFormat | JsonSchemaFormat[]> & {
   responseFormat: JsonSchemaFormat | JsonSchemaFormat[];
   middleware?: TMiddleware;
-}): ReactAgent<Record<string, unknown>, ContextSchema, TMiddleware>;
+}): ReactAgent<Record<string, unknown>, StateSchema, 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>> & {
+declare function createAgent<T extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, ContextSchema, TypedToolStrategy<T>> & {
   responseFormat: TypedToolStrategy<T>;
   middleware?: TMiddleware;
-}): ReactAgent<T, ContextSchema, TMiddleware>;
+}): ReactAgent<T, StateSchema, 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>> & {
+declare function createAgent<T extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, ContextSchema, ToolStrategy<T>> & {
   responseFormat: ToolStrategy<T>;
   middleware?: TMiddleware;
-}): ReactAgent<T, ContextSchema, TMiddleware>;
+}): ReactAgent<T, StateSchema, 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>> & {
+declare function createAgent<T extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, ContextSchema, ProviderStrategy<T>> & {
   responseFormat: ProviderStrategy<T>;
   middleware?: TMiddleware;
-}): ReactAgent<T, ContextSchema, TMiddleware>;
+}): ReactAgent<T, StateSchema, 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"> & {
+declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, StateSchema, ContextSchema, never>, "responseFormat"> & {
   middleware?: TMiddleware;
-}): ReactAgent<ResponseFormatUndefined, ContextSchema, TMiddleware>;
+}): ReactAgent<ResponseFormatUndefined, StateSchema, 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"> & {
+declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, StateSchema, ContextSchema, never>, "responseFormat"> & {
   responseFormat?: undefined;
   middleware?: TMiddleware;
-}): ReactAgent<ResponseFormatUndefined, ContextSchema, TMiddleware>;
+}): ReactAgent<ResponseFormatUndefined, StateSchema, 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> & {
+declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<StructuredResponseFormat, StateSchema, ContextSchema, ResponseFormat> & {
   responseFormat: ResponseFormat;
   middleware?: TMiddleware;
-}): ReactAgent<StructuredResponseFormat, ContextSchema, TMiddleware>;
+}): ReactAgent<StructuredResponseFormat, StateSchema, ContextSchema, TMiddleware>;
 // Re-export types and utilities
 //#endregion

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

	@@ -1 +1 @@
1	- {"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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"}
1	+ {"version":3,"file":"index.d.ts","names":["InteropZodObject","InteropZodType","ResponseFormatUndefined","CreateAgentParams","AgentMiddleware","AnyAnnotationRoot","ExtractZodArrayTypes","ToolStrategy","TypedToolStrategy","ProviderStrategy","ResponseFormat","JsonSchemaFormat","ReactAgent","createAgent","Record","T","StateSchema","ContextSchema","TMiddleware","Omit","StructuredResponseFormat","JumpToTarget","Runtime","toolStrategy","providerStrategy","createMiddleware","ToolCallRequest","ToolCallHandler","WrapToolCallHook","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>, StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, ContextSchema, InteropZodType<T>> & {\n responseFormat: InteropZodType<T>;\n middleware?: TMiddleware;\n}): ReactAgent<T, StateSchema, ContextSchema, TMiddleware>;\n// Overload 2: With responseFormat as array of InteropZodTypes (infers union type)\nexport declare function createAgent<T extends readonly InteropZodType<any>[], StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, StateSchema, ContextSchema, T> & {\n responseFormat: T;\n middleware?: TMiddleware;\n}): ReactAgent<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, StateSchema, ContextSchema, TMiddleware>;\n// Overload 3: With responseFormat as JsonSchemaFormat (JSON schema object)\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, ContextSchema, JsonSchemaFormat> & {\n responseFormat: JsonSchemaFormat;\n middleware?: TMiddleware;\n}): ReactAgent<Record<string, unknown>, StateSchema, ContextSchema, TMiddleware>;\n// Overload 4: With responseFormat as array of JsonSchemaFormat (JSON schema objects)\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, ContextSchema, JsonSchemaFormat[]> & {\n responseFormat: JsonSchemaFormat[];\n middleware?: TMiddleware;\n}): ReactAgent<Record<string, unknown>, StateSchema, ContextSchema, TMiddleware>;\n// Overload 4.5: With responseFormat as union of JsonSchemaFormat \| JsonSchemaFormat[]\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, ContextSchema, JsonSchemaFormat \| JsonSchemaFormat[]> & {\n responseFormat: JsonSchemaFormat \| JsonSchemaFormat[];\n middleware?: TMiddleware;\n}): ReactAgent<Record<string, unknown>, StateSchema, 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>, StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, ContextSchema, TypedToolStrategy<T>> & {\n responseFormat: TypedToolStrategy<T>;\n middleware?: TMiddleware;\n}): ReactAgent<T, StateSchema, ContextSchema, TMiddleware>;\n// Overload 6: With responseFormat as single ToolStrategy instance\nexport declare function createAgent<T extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, ContextSchema, ToolStrategy<T>> & {\n responseFormat: ToolStrategy<T>;\n middleware?: TMiddleware;\n}): ReactAgent<T, StateSchema, ContextSchema, TMiddleware>;\n// Overload 7: With responseFormat as ProviderStrategy\nexport declare function createAgent<T extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, ContextSchema, ProviderStrategy<T>> & {\n responseFormat: ProviderStrategy<T>;\n middleware?: TMiddleware;\n}): ReactAgent<T, StateSchema, ContextSchema, TMiddleware>;\n// Overload 8: Without responseFormat property at all - with proper middleware state typing\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, StateSchema, ContextSchema, never>, \"responseFormat\"> & {\n middleware?: TMiddleware;\n}): ReactAgent<ResponseFormatUndefined, StateSchema, ContextSchema, TMiddleware>;\n// Overload 9: With responseFormat explicitly undefined\nexport declare function createAgent<StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, StateSchema, ContextSchema, never>, \"responseFormat\"> & {\n responseFormat?: undefined;\n middleware?: TMiddleware;\n}): ReactAgent<ResponseFormatUndefined, StateSchema, ContextSchema, TMiddleware>;\n// Overload 10: For other ResponseFormat values (failsafe)\nexport declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot \| InteropZodObject \| undefined = undefined, ContextSchema extends AnyAnnotationRoot \| InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<StructuredResponseFormat, StateSchema, ContextSchema, ResponseFormat> & {\n responseFormat: ResponseFormat;\n middleware?: TMiddleware;\n}): ReactAgent<StructuredResponseFormat, StateSchema, 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, WrapToolCallHook, } 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.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"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"}
1	+ {"version":3,"file":"index.js","names":["params: CreateAgentParams<\n StructuredResponseFormat,\n StateSchema,\n ContextSchema,\n any\n >"],"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 StateSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject\n \| undefined = undefined,\n ContextSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject = AnyAnnotationRoot,\n const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n params: CreateAgentParams<\n T,\n StateSchema,\n ContextSchema,\n InteropZodType<T>\n > & {\n responseFormat: InteropZodType<T>;\n middleware?: TMiddleware;\n }\n): ReactAgent<T, StateSchema, 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 StateSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject\n \| undefined = undefined,\n ContextSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject = AnyAnnotationRoot,\n const 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 StateSchema,\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 StateSchema,\n ContextSchema,\n TMiddleware\n>;\n\n// Overload 3: With responseFormat as JsonSchemaFormat (JSON schema object)\nexport function createAgent<\n StateSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject\n \| undefined = undefined,\n ContextSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject = AnyAnnotationRoot,\n const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n params: CreateAgentParams<\n Record<string, unknown>,\n StateSchema,\n ContextSchema,\n JsonSchemaFormat\n > & {\n responseFormat: JsonSchemaFormat;\n middleware?: TMiddleware;\n }\n): ReactAgent<Record<string, unknown>, StateSchema, ContextSchema, TMiddleware>;\n\n// Overload 4: With responseFormat as array of JsonSchemaFormat (JSON schema objects)\nexport function createAgent<\n StateSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject\n \| undefined = undefined,\n ContextSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject = AnyAnnotationRoot,\n const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n params: CreateAgentParams<\n Record<string, unknown>,\n StateSchema,\n ContextSchema,\n JsonSchemaFormat[]\n > & {\n responseFormat: JsonSchemaFormat[];\n middleware?: TMiddleware;\n }\n): ReactAgent<Record<string, unknown>, StateSchema, ContextSchema, TMiddleware>;\n\n// Overload 4.5: With responseFormat as union of JsonSchemaFormat \| JsonSchemaFormat[]\nexport function createAgent<\n StateSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject\n \| undefined = undefined,\n ContextSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject = AnyAnnotationRoot,\n const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n params: CreateAgentParams<\n Record<string, unknown>,\n StateSchema,\n ContextSchema,\n JsonSchemaFormat \| JsonSchemaFormat[]\n > & {\n responseFormat: JsonSchemaFormat \| JsonSchemaFormat[];\n middleware?: TMiddleware;\n }\n): ReactAgent<Record<string, unknown>, StateSchema, 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 StateSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject\n \| undefined = undefined,\n ContextSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject = AnyAnnotationRoot,\n const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n params: CreateAgentParams<\n T,\n StateSchema,\n ContextSchema,\n TypedToolStrategy<T>\n > & {\n responseFormat: TypedToolStrategy<T>;\n middleware?: TMiddleware;\n }\n): ReactAgent<T, StateSchema, 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 StateSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject\n \| undefined = undefined,\n ContextSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject = AnyAnnotationRoot,\n const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n params: CreateAgentParams<T, StateSchema, ContextSchema, ToolStrategy<T>> & {\n responseFormat: ToolStrategy<T>;\n middleware?: TMiddleware;\n }\n): ReactAgent<T, StateSchema, ContextSchema, TMiddleware>;\n\n// Overload 7: With responseFormat as ProviderStrategy\nexport function createAgent<\n T extends Record<string, any> = Record<string, any>,\n StateSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject\n \| undefined = undefined,\n ContextSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject = AnyAnnotationRoot,\n const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n params: CreateAgentParams<\n T,\n StateSchema,\n ContextSchema,\n ProviderStrategy<T>\n > & {\n responseFormat: ProviderStrategy<T>;\n middleware?: TMiddleware;\n }\n): ReactAgent<T, StateSchema, ContextSchema, TMiddleware>;\n\n// Overload 8: Without responseFormat property at all - with proper middleware state typing\nexport function createAgent<\n StateSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject\n \| undefined = undefined,\n ContextSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject = AnyAnnotationRoot,\n const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n params: Omit<\n CreateAgentParams<\n ResponseFormatUndefined,\n StateSchema,\n ContextSchema,\n never\n >,\n \"responseFormat\"\n > & { middleware?: TMiddleware }\n): ReactAgent<ResponseFormatUndefined, StateSchema, ContextSchema, TMiddleware>;\n\n// Overload 9: With responseFormat explicitly undefined\nexport function createAgent<\n StateSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject\n \| undefined = undefined,\n ContextSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject = AnyAnnotationRoot,\n const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n params: Omit<\n CreateAgentParams<\n ResponseFormatUndefined,\n StateSchema,\n ContextSchema,\n never\n >,\n \"responseFormat\"\n > & {\n responseFormat?: undefined;\n middleware?: TMiddleware;\n }\n): ReactAgent<ResponseFormatUndefined, StateSchema, ContextSchema, TMiddleware>;\n\n// Overload 10: For other ResponseFormat values (failsafe)\nexport function createAgent<\n StructuredResponseFormat extends Record<string, any> = Record<string, any>,\n StateSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject\n \| undefined = undefined,\n ContextSchema extends\n \| AnyAnnotationRoot\n \| InteropZodObject = AnyAnnotationRoot,\n const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]\n>(\n params: CreateAgentParams<\n StructuredResponseFormat,\n StateSchema,\n ContextSchema,\n ResponseFormat\n > & {\n responseFormat: ResponseFormat;\n middleware?: TMiddleware;\n }\n): ReactAgent<\n StructuredResponseFormat,\n StateSchema,\n ContextSchema,\n TMiddleware\n>;\n\n// Implementation\nexport function createAgent<\n StructuredResponseFormat extends Record<string, any>,\n StateSchema extends AnyAnnotationRoot \| InteropZodObject,\n ContextSchema extends AnyAnnotationRoot \| InteropZodObject,\n TMiddleware extends readonly AgentMiddleware[] = []\n>(\n params: CreateAgentParams<\n StructuredResponseFormat,\n StateSchema,\n ContextSchema,\n any\n >\n): ReactAgent<\n StructuredResponseFormat,\n StateSchema,\n ContextSchema,\n TMiddleware\n> {\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 WrapToolCallHook,\n} from \"./middleware/types.js\";\nexport { FakeToolCallingModel } from \"./tests/utils.js\";\nexport type { ReactAgent } from \"./ReactAgent.js\";\n"],"mappings":";;;;;;;AA+YA,SAAgB,YAMdA,QAWA;AACA,QAAO,IAAI,WAAW;AACvB"}

package/dist/agents/middleware/callLimit.cjs CHANGED Viewed

@@ -91,34 +91,36 @@ function modelCallLimitMiddleware(middlewareOptions) {
 	return require_middleware.createMiddleware({
 		name: "ModelCallLimitMiddleware",
 		contextSchema,
-		beforeModelJumpTo: ["end"],
-		beforeModel: (state, runtime) => {
-			const exitBehavior = runtime.context.exitBehavior ?? middlewareOptions?.exitBehavior ?? DEFAULT_EXIT_BEHAVIOR;
-			const threadLimit = runtime.context.threadLimit ?? middlewareOptions?.threadLimit;
-			const runLimit = runtime.context.runLimit ?? middlewareOptions?.runLimit;
-			if (typeof threadLimit === "number" && threadLimit <= runtime.threadLevelCallCount) {
-				const error = new ModelCallLimitMiddlewareError({
-					threadLimit,
-					threadCount: runtime.threadLevelCallCount
-				});
-				if (exitBehavior === "end") return {
-					jumpTo: "end",
-					messages: [new __langchain_core_messages.AIMessage(error.message)]
-				};
-				throw error;
+		beforeModel: {
+			canJumpTo: ["end"],
+			hook: (state, runtime) => {
+				const exitBehavior = runtime.context.exitBehavior ?? middlewareOptions?.exitBehavior ?? DEFAULT_EXIT_BEHAVIOR;
+				const threadLimit = runtime.context.threadLimit ?? middlewareOptions?.threadLimit;
+				const runLimit = runtime.context.runLimit ?? middlewareOptions?.runLimit;
+				if (typeof threadLimit === "number" && threadLimit <= runtime.threadLevelCallCount) {
+					const error = new ModelCallLimitMiddlewareError({
+						threadLimit,
+						threadCount: runtime.threadLevelCallCount
+					});
+					if (exitBehavior === "end") return {
+						jumpTo: "end",
+						messages: [new __langchain_core_messages.AIMessage(error.message)]
+					};
+					throw error;
+				}
+				if (typeof runLimit === "number" && runLimit <= runtime.runModelCallCount) {
+					const error = new ModelCallLimitMiddlewareError({
+						runLimit,
+						runCount: runtime.runModelCallCount
+					});
+					if (exitBehavior === "end") return {
+						jumpTo: "end",
+						messages: [new __langchain_core_messages.AIMessage(error.message)]
+					};
+					throw error;
+				}
+				return state;
 			}
-			if (typeof runLimit === "number" && runLimit <= runtime.runModelCallCount) {
-				const error = new ModelCallLimitMiddlewareError({
-					runLimit,
-					runCount: runtime.runModelCallCount
-				});
-				if (exitBehavior === "end") return {
-					jumpTo: "end",
-					messages: [new __langchain_core_messages.AIMessage(error.message)]
-				};
-				throw error;
-			}
-			return state;
 		}
 	});
 }

package/dist/agents/middleware/callLimit.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"callLimit.cjs","names":["z","exceededHint: string[]","middlewareOptions?: ModelCallLimitMiddlewareConfig","createMiddleware","AIMessage"],"sources":["../../../src/agents/middleware/callLimit.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { AIMessage } from \"@langchain/core/messages\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\n\nimport { createMiddleware } from \"../middleware.js\";\n\nconst DEFAULT_EXIT_BEHAVIOR = \"end\";\n\nconst contextSchema = z.object({\n /*\n The maximum number of model calls allowed per thread.\n /\n threadLimit: z.number().optional(),\n /\n The maximum number of model calls allowed per run.\n /\n runLimit: z.number().optional(),\n /\n The behavior to take when the limit is exceeded.\n * - \"throw\" will throw an error and stop the agent.\n * - \"end\" will end the agent.\n * @default \"end\"\n /\n exitBehavior: z.enum([\"throw\", \"end\"]).optional(),\n});\nexport type ModelCallLimitMiddlewareConfig = Partial<\n InferInteropZodInput<typeof contextSchema>\n>;\n\n/\n Error thrown when the model call limit is exceeded.\n \n @param threadLimit - The maximum number of model calls allowed per thread.\n * @param runLimit - The maximum number of model calls allowed per run.\n * @param threadCount - The number of model calls made at the thread level.\n * @param runCount - The number of model calls made at the run level.\n /\nclass ModelCallLimitMiddlewareError extends Error {\n constructor({\n threadLimit,\n runLimit,\n threadCount,\n runCount,\n }: {\n threadLimit?: number;\n runLimit?: number;\n threadCount?: number;\n runCount?: number;\n }) {\n const exceededHint: string[] = [];\n if (typeof threadLimit === \"number\" && typeof threadCount === \"number\") {\n exceededHint.push(\n `thread level call limit reached with ${threadCount} model calls`\n );\n }\n if (typeof runLimit === \"number\" && typeof runCount === \"number\") {\n exceededHint.push(\n `run level call limit reached with ${runCount} model calls`\n );\n }\n super(\n `Model call limits exceeded${\n exceededHint.length > 0 ? `: ${exceededHint.join(\", \")}` : \"\"\n }`\n );\n this.name = \"ModelCallLimitMiddlewareError\";\n }\n}\n\n/\n Creates a middleware to limit the number of model calls at both thread and run levels.\n \n This middleware helps prevent excessive model API calls by enforcing limits on how many\n * times the model can be invoked. It supports two types of limits:\n \n - Thread-level limit: Restricts the total number of model calls across an entire conversation thread\n * - Run-level limit: Restricts the number of model calls within a single agent run/invocation\n \n ## How It Works\n \n The middleware intercepts model requests before they are sent and checks the current call counts\n * against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`\n * to stop execution and prevent further API calls.\n \n ## Use Cases\n \n - Cost Control: Prevent runaway costs from excessive model calls in production\n * - Testing: Ensure agents don't make too many calls during development/testing\n * - Safety: Limit potential infinite loops or recursive agent behaviors\n * - Rate Limiting: Enforce organizational policies on model usage per conversation\n \n @param middlewareOptions - Configuration options for the call limits\n * @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)\n * @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)\n \n @returns A middleware instance that can be passed to `createAgent`\n \n @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded\n \n @example\n * ```typescript\n * import { createAgent, modelCallLimitMiddleware } from \"langchain\";\n \n // Limit to 10 calls per thread and 3 calls per run\n * const agent = createAgent({\n * model: \"openai:gpt-4o-mini\",\n * tools: [myTool],\n * middleware: [\n * modelCallLimitMiddleware({\n * threadLimit: 10,\n * runLimit: 3\n * })\n * ]\n * });\n * ```\n \n @example\n * ```typescript\n * // Limits can also be configured at runtime via context\n * const result = await agent.invoke(\n * { messages: [\"Hello\"] },\n * {\n * configurable: {\n * threadLimit: 5 // Override the default limit for this run\n * }\n * }\n * );\n * ```\n */\nexport function modelCallLimitMiddleware(\n middlewareOptions?: ModelCallLimitMiddlewareConfig\n) {\n return createMiddleware({\n name: \"ModelCallLimitMiddleware\",\n contextSchema,\n ~~beforeModelJumpTo~~: [\"end\"],\n ~~beforeModel~~: (state, runtime) => {\n const exitBehavior =\n runtime.context.exitBehavior ??\n middlewareOptions?.exitBehavior ??\n DEFAULT_EXIT_BEHAVIOR;\n const threadLimit =\n runtime.context.threadLimit ?? middlewareOptions?.threadLimit;\n const runLimit = runtime.context.runLimit ?? middlewareOptions?.runLimit;\n\n if (\n typeof threadLimit === \"number\" &&\n threadLimit <= runtime.threadLevelCallCount\n ) {\n const error = new ModelCallLimitMiddlewareError({\n threadLimit,\n threadCount: runtime.threadLevelCallCount,\n });\n if (exitBehavior === \"end\") {\n return {\n jumpTo: \"end\",\n messages: [new AIMessage(error.message)],\n };\n }\n\n throw error;\n }\n if (\n typeof runLimit === \"number\" &&\n runLimit <= runtime.runModelCallCount\n ) {\n const error = new ModelCallLimitMiddlewareError({\n runLimit,\n runCount: runtime.runModelCallCount,\n });\n if (exitBehavior === \"end\") {\n return {\n jumpTo: \"end\",\n messages: [new AIMessage(error.message)],\n };\n }\n\n throw error;\n }\n\n return state;\n },\n });\n}\n"],"mappings":";;;;;;AAMA,MAAM,wBAAwB;AAE9B,MAAM,gBAAgBA,SAAE,OAAO;CAI7B,aAAaA,SAAE,QAAQ,CAAC,UAAU;CAIlC,UAAUA,SAAE,QAAQ,CAAC,UAAU;CAO/B,cAAcA,SAAE,KAAK,CAAC,SAAS,KAAM,EAAC,CAAC,UAAU;AAClD,EAAC;;;;;;;;;AAaF,IAAM,gCAAN,cAA4C,MAAM;CAChD,YAAY,EACV,aACA,UACA,aACA,UAMD,EAAE;EACD,MAAMC,eAAyB,CAAE;AACjC,MAAI,OAAO,gBAAgB,YAAY,OAAO,gBAAgB,UAC5D,aAAa,KACX,CAAC,qCAAqC,EAAE,YAAY,YAAY,CAAC,CAClE;AAEH,MAAI,OAAO,aAAa,YAAY,OAAO,aAAa,UACtD,aAAa,KACX,CAAC,kCAAkC,EAAE,SAAS,YAAY,CAAC,CAC5D;EAEH,MACE,CAAC,0BAA0B,EACzB,aAAa,SAAS,IAAI,CAAC,EAAE,EAAE,aAAa,KAAK,KAAK,EAAE,GAAG,IAC3D,CACH;EACD,KAAK,OAAO;CACb;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DD,SAAgB,yBACdC,mBACA;AACA,QAAOC,oCAAiB;EACtB,MAAM;EACN;EACA,~~mBAAmB~~,CAAC,KAAM;~~EAC1B~~,~~aAAa~~,CAAC,OAAO,YAAY;~~GAC/B~~,MAAM,eACJ,QAAQ,QAAQ,gBAChB,mBAAmB,gBACnB;~~GACF~~,MAAM,cACJ,QAAQ,QAAQ,eAAe,mBAAmB;~~GACpD~~,MAAM,~~WAAW~~,QAAQ,QAAQ,YAAY,mBAAmB;~~AAEhE~~,~~OACE~~,OAAO,gBAAgB,YACvB,eAAe,QAAQ,sBACvB;~~IACA~~,MAAM,QAAQ,IAAI,8BAA8B;~~KAC9C~~;~~KACA~~,aAAa,QAAQ;~~IACtB~~;AACD,~~QAAI~~,iBAAiB,MACnB,QAAO;~~KACL~~,QAAQ;~~KACR~~,UAAU,CAAC,IAAIC,oCAAU,MAAM,QAAS;~~IACzC~~;AAGH,~~UAAM~~;~~GACP~~;AACD,~~OACE~~,OAAO,aAAa,YACpB,YAAY,QAAQ,mBACpB;~~IACA~~,MAAM,QAAQ,IAAI,8BAA8B;~~KAC9C~~;~~KACA~~,UAAU,QAAQ;~~IACnB~~;AACD,~~QAAI~~,iBAAiB,MACnB,QAAO;~~KACL~~,QAAQ;~~KACR~~,UAAU,CAAC,IAAIA,oCAAU,MAAM,QAAS;~~IACzC~~;AAGH,~~UAAM~~;~~GACP~~;AAED,~~UAAO~~;~~EACR~~;CACF,EAAC;AACH"}
1	+ {"version":3,"file":"callLimit.cjs","names":["z","exceededHint: string[]","middlewareOptions?: ModelCallLimitMiddlewareConfig","createMiddleware","AIMessage"],"sources":["../../../src/agents/middleware/callLimit.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { AIMessage } from \"@langchain/core/messages\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\n\nimport { createMiddleware } from \"../middleware.js\";\n\nconst DEFAULT_EXIT_BEHAVIOR = \"end\";\n\nconst contextSchema = z.object({\n /*\n The maximum number of model calls allowed per thread.\n /\n threadLimit: z.number().optional(),\n /\n The maximum number of model calls allowed per run.\n /\n runLimit: z.number().optional(),\n /\n The behavior to take when the limit is exceeded.\n * - \"throw\" will throw an error and stop the agent.\n * - \"end\" will end the agent.\n * @default \"end\"\n /\n exitBehavior: z.enum([\"throw\", \"end\"]).optional(),\n});\nexport type ModelCallLimitMiddlewareConfig = Partial<\n InferInteropZodInput<typeof contextSchema>\n>;\n\n/\n Error thrown when the model call limit is exceeded.\n \n @param threadLimit - The maximum number of model calls allowed per thread.\n * @param runLimit - The maximum number of model calls allowed per run.\n * @param threadCount - The number of model calls made at the thread level.\n * @param runCount - The number of model calls made at the run level.\n /\nclass ModelCallLimitMiddlewareError extends Error {\n constructor({\n threadLimit,\n runLimit,\n threadCount,\n runCount,\n }: {\n threadLimit?: number;\n runLimit?: number;\n threadCount?: number;\n runCount?: number;\n }) {\n const exceededHint: string[] = [];\n if (typeof threadLimit === \"number\" && typeof threadCount === \"number\") {\n exceededHint.push(\n `thread level call limit reached with ${threadCount} model calls`\n );\n }\n if (typeof runLimit === \"number\" && typeof runCount === \"number\") {\n exceededHint.push(\n `run level call limit reached with ${runCount} model calls`\n );\n }\n super(\n `Model call limits exceeded${\n exceededHint.length > 0 ? `: ${exceededHint.join(\", \")}` : \"\"\n }`\n );\n this.name = \"ModelCallLimitMiddlewareError\";\n }\n}\n\n/\n Creates a middleware to limit the number of model calls at both thread and run levels.\n \n This middleware helps prevent excessive model API calls by enforcing limits on how many\n * times the model can be invoked. It supports two types of limits:\n \n - Thread-level limit: Restricts the total number of model calls across an entire conversation thread\n * - Run-level limit: Restricts the number of model calls within a single agent run/invocation\n \n ## How It Works\n \n The middleware intercepts model requests before they are sent and checks the current call counts\n * against the configured limits. If either limit is exceeded, it throws a `ModelCallLimitMiddlewareError`\n * to stop execution and prevent further API calls.\n \n ## Use Cases\n \n - Cost Control: Prevent runaway costs from excessive model calls in production\n * - Testing: Ensure agents don't make too many calls during development/testing\n * - Safety: Limit potential infinite loops or recursive agent behaviors\n * - Rate Limiting: Enforce organizational policies on model usage per conversation\n \n @param middlewareOptions - Configuration options for the call limits\n * @param middlewareOptions.threadLimit - Maximum number of model calls allowed per thread (optional)\n * @param middlewareOptions.runLimit - Maximum number of model calls allowed per run (optional)\n \n @returns A middleware instance that can be passed to `createAgent`\n \n @throws {ModelCallLimitMiddlewareError} When either the thread or run limit is exceeded\n \n @example\n * ```typescript\n * import { createAgent, modelCallLimitMiddleware } from \"langchain\";\n \n // Limit to 10 calls per thread and 3 calls per run\n * const agent = createAgent({\n * model: \"openai:gpt-4o-mini\",\n * tools: [myTool],\n * middleware: [\n * modelCallLimitMiddleware({\n * threadLimit: 10,\n * runLimit: 3\n * })\n * ]\n * });\n * ```\n \n @example\n * ```typescript\n * // Limits can also be configured at runtime via context\n * const result = await agent.invoke(\n * { messages: [\"Hello\"] },\n * {\n * configurable: {\n * threadLimit: 5 // Override the default limit for this run\n * }\n * }\n * );\n * ```\n */\nexport function modelCallLimitMiddleware(\n middlewareOptions?: ModelCallLimitMiddlewareConfig\n) {\n return createMiddleware({\n name: \"ModelCallLimitMiddleware\",\n contextSchema,\n beforeModel: {\n canJumpTo: [\"end\"],\n hook: (state, runtime) => {\n const exitBehavior =\n runtime.context.exitBehavior ??\n middlewareOptions?.exitBehavior ??\n DEFAULT_EXIT_BEHAVIOR;\n const threadLimit =\n runtime.context.threadLimit ?? middlewareOptions?.threadLimit;\n const runLimit =\n runtime.context.runLimit ?? middlewareOptions?.runLimit;\n\n if (\n typeof threadLimit === \"number\" &&\n threadLimit <= runtime.threadLevelCallCount\n ) {\n const error = new ModelCallLimitMiddlewareError({\n threadLimit,\n threadCount: runtime.threadLevelCallCount,\n });\n if (exitBehavior === \"end\") {\n return {\n jumpTo: \"end\",\n messages: [new AIMessage(error.message)],\n };\n }\n\n throw error;\n }\n if (\n typeof runLimit === \"number\" &&\n runLimit <= runtime.runModelCallCount\n ) {\n const error = new ModelCallLimitMiddlewareError({\n runLimit,\n runCount: runtime.runModelCallCount,\n });\n if (exitBehavior === \"end\") {\n return {\n jumpTo: \"end\",\n messages: [new AIMessage(error.message)],\n };\n }\n\n throw error;\n }\n\n return state;\n },\n },\n });\n}\n"],"mappings":";;;;;;AAMA,MAAM,wBAAwB;AAE9B,MAAM,gBAAgBA,SAAE,OAAO;CAI7B,aAAaA,SAAE,QAAQ,CAAC,UAAU;CAIlC,UAAUA,SAAE,QAAQ,CAAC,UAAU;CAO/B,cAAcA,SAAE,KAAK,CAAC,SAAS,KAAM,EAAC,CAAC,UAAU;AAClD,EAAC;;;;;;;;;AAaF,IAAM,gCAAN,cAA4C,MAAM;CAChD,YAAY,EACV,aACA,UACA,aACA,UAMD,EAAE;EACD,MAAMC,eAAyB,CAAE;AACjC,MAAI,OAAO,gBAAgB,YAAY,OAAO,gBAAgB,UAC5D,aAAa,KACX,CAAC,qCAAqC,EAAE,YAAY,YAAY,CAAC,CAClE;AAEH,MAAI,OAAO,aAAa,YAAY,OAAO,aAAa,UACtD,aAAa,KACX,CAAC,kCAAkC,EAAE,SAAS,YAAY,CAAC,CAC5D;EAEH,MACE,CAAC,0BAA0B,EACzB,aAAa,SAAS,IAAI,CAAC,EAAE,EAAE,aAAa,KAAK,KAAK,EAAE,GAAG,IAC3D,CACH;EACD,KAAK,OAAO;CACb;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DD,SAAgB,yBACdC,mBACA;AACA,QAAOC,oCAAiB;EACtB,MAAM;EACN;EACA,aAAa;GACX,WAAW,CAAC,KAAM;GAClB,MAAM,CAAC,OAAO,YAAY;IACxB,MAAM,eACJ,QAAQ,QAAQ,gBAChB,mBAAmB,gBACnB;IACF,MAAM,cACJ,QAAQ,QAAQ,eAAe,mBAAmB;IACpD,MAAM,WACJ,QAAQ,QAAQ,YAAY,mBAAmB;AAEjD,QACE,OAAO,gBAAgB,YACvB,eAAe,QAAQ,sBACvB;KACA,MAAM,QAAQ,IAAI,8BAA8B;MAC9C;MACA,aAAa,QAAQ;KACtB;AACD,SAAI,iBAAiB,MACnB,QAAO;MACL,QAAQ;MACR,UAAU,CAAC,IAAIC,oCAAU,MAAM,QAAS;KACzC;AAGH,WAAM;IACP;AACD,QACE,OAAO,aAAa,YACpB,YAAY,QAAQ,mBACpB;KACA,MAAM,QAAQ,IAAI,8BAA8B;MAC9C;MACA,UAAU,QAAQ;KACnB;AACD,SAAI,iBAAiB,MACnB,QAAO;MACL,QAAQ;MACR,UAAU,CAAC,IAAIA,oCAAU,MAAM,QAAS;KACzC;AAGH,WAAM;IACP;AAED,WAAO;GACR;EACF;CACF,EAAC;AACH"}