langchain 1.0.1 → 1.0.3

package/dist/agents/index.d.cts

@@ -131,56 +131,56 @@ 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>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, 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, StateSchema, ContextSchema, TMiddleware>;
 // Overload 2: With responseFormat as array of InteropZodTypes (infers union type)
-declare function createAgent<T extends readonly InteropZodType<any>[], StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, StateSchema, 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>, StateSchema, ContextSchema, TMiddleware>;
 // Overload 3: With responseFormat as JsonSchemaFormat (JSON schema object)
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, 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>, StateSchema, ContextSchema, TMiddleware>;
 // Overload 4: With responseFormat as array of JsonSchemaFormat (JSON schema objects)
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, 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>, StateSchema, ContextSchema, TMiddleware>;
 // Overload 4.5: With responseFormat as union of JsonSchemaFormat | JsonSchemaFormat[]
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, 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>, 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>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, 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, StateSchema, ContextSchema, TMiddleware>;
 // Overload 6: With responseFormat as single ToolStrategy instance
-declare function createAgent<T extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, 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, StateSchema, ContextSchema, TMiddleware>;
 // Overload 7: With responseFormat as ProviderStrategy
-declare function createAgent<T extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, 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, StateSchema, ContextSchema, TMiddleware>;
 // Overload 8: Without responseFormat property at all - with proper middleware state typing
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, StateSchema, 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, StateSchema, ContextSchema, TMiddleware>;
 // Overload 9: With responseFormat explicitly undefined
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, StateSchema, 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, StateSchema, ContextSchema, TMiddleware>;
 // Overload 10: For other ResponseFormat values (failsafe)
-declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<StructuredResponseFormat, StateSchema, 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, StateSchema, ContextSchema, TMiddleware>;

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

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

package/dist/agents/index.d.ts

@@ -131,56 +131,56 @@ 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>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, 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, StateSchema, ContextSchema, TMiddleware>;
 // Overload 2: With responseFormat as array of InteropZodTypes (infers union type)
-declare function createAgent<T extends readonly InteropZodType<any>[], StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<ExtractZodArrayTypes<T> extends Record<string, any> ? ExtractZodArrayTypes<T> : Record<string, any>, StateSchema, 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>, StateSchema, ContextSchema, TMiddleware>;
 // Overload 3: With responseFormat as JsonSchemaFormat (JSON schema object)
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, 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>, StateSchema, ContextSchema, TMiddleware>;
 // Overload 4: With responseFormat as array of JsonSchemaFormat (JSON schema objects)
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, 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>, StateSchema, ContextSchema, TMiddleware>;
 // Overload 4.5: With responseFormat as union of JsonSchemaFormat | JsonSchemaFormat[]
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<Record<string, unknown>, StateSchema, 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>, 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>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, 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, StateSchema, ContextSchema, TMiddleware>;
 // Overload 6: With responseFormat as single ToolStrategy instance
-declare function createAgent<T extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, 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, StateSchema, ContextSchema, TMiddleware>;
 // Overload 7: With responseFormat as ProviderStrategy
-declare function createAgent<T extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<T, StateSchema, 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, StateSchema, ContextSchema, TMiddleware>;
 // Overload 8: Without responseFormat property at all - with proper middleware state typing
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, StateSchema, 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, StateSchema, ContextSchema, TMiddleware>;
 // Overload 9: With responseFormat explicitly undefined
-declare function createAgent<StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, StateSchema, 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, StateSchema, ContextSchema, TMiddleware>;
 // Overload 10: For other ResponseFormat values (failsafe)
-declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, StateSchema extends AnyAnnotationRoot | InteropZodObject | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[]>(params: CreateAgentParams<StructuredResponseFormat, StateSchema, 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, StateSchema, ContextSchema, TMiddleware>;

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

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

@@ -1 +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  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  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  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  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  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  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  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  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  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  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  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"}
+{"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.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"callLimit.d.cts","names":["z","InferInteropZodInput","contextSchema","ZodNumber","ZodOptional","ZodEnum","ZodTypeAny","ZodObject","ModelCallLimitMiddlewareConfig","Partial","modelCallLimitMiddleware","__types_js8","AgentMiddleware"],"sources":["../../../src/agents/middleware/callLimit.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\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.ZodOptional<z.ZodEnum<[\"throw\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}>;\nexport type ModelCallLimitMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;\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 declare function modelCallLimitMiddleware(middlewareOptions?: ModelCallLimitMiddlewareConfig): import(\"./types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\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.ZodOptional<z.ZodEnum<[\"throw\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}>, any>;\nexport {};\n"],"mappings":";;;;;cAEcE,eAAeF,CAAAA,CAAEO;;;AADoC;EAyBjE,WAAA,EApBeP,CAAAA,CAAEI,WAoBjB,CApB6BJ,CAAAA,CAAEG,SAoB/B,CAAA;EAAA;;;EAhBqC,QAAvBC,EAAFJ,CAAAA,CAAEI,WAAAA,CAAYJ,CAAAA,CAAEG,SAAdC,CAAAA;EAAW;;;;AARa;AAyBxC;EAA0C,YAAA,EAVxBJ,CAAAA,CAAEI,WAUsB,CAVVJ,CAAAA,CAAEK,OAUQ,CAAA,CAAA,OAAA,EAAA,KAAA,CAAA,CAAA,CAAA;CAAA,EAAA,OAAuCH,EATrEF,CAAAA,CAAEM,UASmEJ,EAAAA;EAAa,WAAzCD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAoB,QAA5BQ,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAO,YAAA,CAAA,EAAA,KAAA,GAAA,OAAA,GAAA,SAAA;AA6DpD,CAAA,EAAA;EAAgD,WAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EAAA,QAAqBD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAA8B,YAIlEL,CAAAA,EAAAA,KAAAA,GAAAA,OAAAA,GAAAA,SAAAA;CAAS,CAAA;AAIdH,KArEhBQ,8BAAAA,GAAiCC,OAqEfN,CArEuBF,oBAqEvBE,CAAAA,OArEmDD,aAqEnDC,CAAAA,CAAAA;;;;;;;AAR4G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAlHO,wBAAAA,qBAA6CF,iCAA4F,2BAAXR,CAAAA,CAAEO;;;;eAIvIP,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;YAInBH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;;;;gBAOZH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEK;YACtBL,CAAAA,CAAEM"}
+{"version":3,"file":"callLimit.d.cts","names":["z","InferInteropZodInput","contextSchema","ZodNumber","ZodOptional","ZodEnum","ZodTypeAny","ZodObject","ModelCallLimitMiddlewareConfig","Partial","modelCallLimitMiddleware","__types_js10","AgentMiddleware"],"sources":["../../../src/agents/middleware/callLimit.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\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.ZodOptional<z.ZodEnum<[\"throw\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}>;\nexport type ModelCallLimitMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;\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 declare function modelCallLimitMiddleware(middlewareOptions?: ModelCallLimitMiddlewareConfig): import(\"./types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\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.ZodOptional<z.ZodEnum<[\"throw\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}>, any>;\nexport {};\n"],"mappings":";;;;;cAEcE,eAAeF,CAAAA,CAAEO;;;AADoC;EAyBjE,WAAA,EApBeP,CAAAA,CAAEI,WAoBjB,CApB6BJ,CAAAA,CAAEG,SAoB/B,CAAA;EAAA;;;EAhBqC,QAAvBC,EAAFJ,CAAAA,CAAEI,WAAAA,CAAYJ,CAAAA,CAAEG,SAAdC,CAAAA;EAAW;;;;AARa;AAyBxC;EAA0C,YAAA,EAVxBJ,CAAAA,CAAEI,WAUsB,CAVVJ,CAAAA,CAAEK,OAUQ,CAAA,CAAA,OAAA,EAAA,KAAA,CAAA,CAAA,CAAA;CAAA,EAAA,OAAuCH,EATrEF,CAAAA,CAAEM,UASmEJ,EAAAA;EAAa,WAAzCD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAoB,QAA5BQ,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAO,YAAA,CAAA,EAAA,KAAA,GAAA,OAAA,GAAA,SAAA;AA6DpD,CAAA,EAAA;EAAgD,WAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EAAA,QAAqBD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAA8B,YAIlEL,CAAAA,EAAAA,KAAAA,GAAAA,OAAAA,GAAAA,SAAAA;CAAS,CAAA;AAIdH,KArEhBQ,8BAAAA,GAAiCC,OAqEfN,CArEuBF,oBAqEvBE,CAAAA,OArEmDD,aAqEnDC,CAAAA,CAAAA;;;;;;;AAR4G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAlHO,wBAAAA,qBAA6CF,iCAA4F,2BAAXR,CAAAA,CAAEO;;;;eAIvIP,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;YAInBH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;;;;gBAOZH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEK;YACtBL,CAAAA,CAAEM"}

package/dist/agents/middleware/callLimit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"callLimit.d.ts","names":["z","InferInteropZodInput","contextSchema","ZodNumber","ZodOptional","ZodEnum","ZodTypeAny","ZodObject","ModelCallLimitMiddlewareConfig","Partial","modelCallLimitMiddleware","__types_js4","AgentMiddleware"],"sources":["../../../src/agents/middleware/callLimit.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\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.ZodOptional<z.ZodEnum<[\"throw\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}>;\nexport type ModelCallLimitMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;\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 declare function modelCallLimitMiddleware(middlewareOptions?: ModelCallLimitMiddlewareConfig): import(\"./types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\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.ZodOptional<z.ZodEnum<[\"throw\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}>, any>;\nexport {};\n"],"mappings":";;;;;cAEcE,eAAeF,CAAAA,CAAEO;;;AADoC;EAyBjE,WAAA,EApBeP,CAAAA,CAAEI,WAoBjB,CApB6BJ,CAAAA,CAAEG,SAoB/B,CAAA;EAAA;;;EAhBqC,QAAvBC,EAAFJ,CAAAA,CAAEI,WAAAA,CAAYJ,CAAAA,CAAEG,SAAdC,CAAAA;EAAW;;;;AARa;AAyBxC;EAA0C,YAAA,EAVxBJ,CAAAA,CAAEI,WAUsB,CAVVJ,CAAAA,CAAEK,OAUQ,CAAA,CAAA,OAAA,EAAA,KAAA,CAAA,CAAA,CAAA;CAAA,EAAA,OAAuCH,EATrEF,CAAAA,CAAEM,UASmEJ,EAAAA;EAAa,WAAzCD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAoB,QAA5BQ,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAO,YAAA,CAAA,EAAA,KAAA,GAAA,OAAA,GAAA,SAAA;AA6DpD,CAAA,EAAA;EAAgD,WAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EAAA,QAAqBD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAA8B,YAIlEL,CAAAA,EAAAA,KAAAA,GAAAA,OAAAA,GAAAA,SAAAA;CAAS,CAAA;AAIdH,KArEhBQ,8BAAAA,GAAiCC,OAqEfN,CArEuBF,oBAqEvBE,CAAAA,OArEmDD,aAqEnDC,CAAAA,CAAAA;;;;;;;AAR4G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAlHO,wBAAAA,qBAA6CF,iCAA4F,2BAAXR,CAAAA,CAAEO;;;;eAIvIP,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;YAInBH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;;;;gBAOZH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEK;YACtBL,CAAAA,CAAEM"}
+{"version":3,"file":"callLimit.d.ts","names":["z","InferInteropZodInput","contextSchema","ZodNumber","ZodOptional","ZodEnum","ZodTypeAny","ZodObject","ModelCallLimitMiddlewareConfig","Partial","modelCallLimitMiddleware","__types_js10","AgentMiddleware"],"sources":["../../../src/agents/middleware/callLimit.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\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.ZodOptional<z.ZodEnum<[\"throw\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}>;\nexport type ModelCallLimitMiddlewareConfig = Partial<InferInteropZodInput<typeof contextSchema>>;\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 declare function modelCallLimitMiddleware(middlewareOptions?: ModelCallLimitMiddlewareConfig): import(\"./types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    /**\n     * The maximum number of model calls allowed per thread.\n     */\n    threadLimit: z.ZodOptional<z.ZodNumber>;\n    /**\n     * The maximum number of model calls allowed per run.\n     */\n    runLimit: z.ZodOptional<z.ZodNumber>;\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.ZodOptional<z.ZodEnum<[\"throw\", \"end\"]>>;\n}, \"strip\", z.ZodTypeAny, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}, {\n    threadLimit?: number | undefined;\n    runLimit?: number | undefined;\n    exitBehavior?: \"end\" | \"throw\" | undefined;\n}>, any>;\nexport {};\n"],"mappings":";;;;;cAEcE,eAAeF,CAAAA,CAAEO;;;AADoC;EAyBjE,WAAA,EApBeP,CAAAA,CAAEI,WAoBjB,CApB6BJ,CAAAA,CAAEG,SAoB/B,CAAA;EAAA;;;EAhBqC,QAAvBC,EAAFJ,CAAAA,CAAEI,WAAAA,CAAYJ,CAAAA,CAAEG,SAAdC,CAAAA;EAAW;;;;AARa;AAyBxC;EAA0C,YAAA,EAVxBJ,CAAAA,CAAEI,WAUsB,CAVVJ,CAAAA,CAAEK,OAUQ,CAAA,CAAA,OAAA,EAAA,KAAA,CAAA,CAAA,CAAA;CAAA,EAAA,OAAuCH,EATrEF,CAAAA,CAAEM,UASmEJ,EAAAA;EAAa,WAAzCD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAoB,QAA5BQ,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAO,YAAA,CAAA,EAAA,KAAA,GAAA,OAAA,GAAA,SAAA;AA6DpD,CAAA,EAAA;EAAgD,WAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EAAA,QAAqBD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAA8B,YAIlEL,CAAAA,EAAAA,KAAAA,GAAAA,OAAAA,GAAAA,SAAAA;CAAS,CAAA;AAIdH,KArEhBQ,8BAAAA,GAAiCC,OAqEfN,CArEuBF,oBAqEvBE,CAAAA,OArEmDD,aAqEnDC,CAAAA,CAAAA;;;;;;;AAR4G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAlHO,wBAAAA,qBAA6CF,iCAA4F,2BAAXR,CAAAA,CAAEO;;;;eAIvIP,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;YAInBH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;;;;;;;gBAOZH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEK;YACtBL,CAAAA,CAAEM"}

package/dist/agents/middleware/contextEditing.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"contextEditing.d.cts","names":["BaseMessage","TokenCounter","Promise","ContextEdit","ClearToolUsesEditConfig","ClearToolUsesEdit","Set","ContextEditingMiddlewareConfig","contextEditingMiddleware","__types_js10","AgentMiddleware"],"sources":["../../../src/agents/middleware/contextEditing.d.ts"],"sourcesContent":["/**\n * Context editing middleware.\n *\n * This middleware mirrors Anthropic's context editing capabilities by clearing\n * older tool results once the conversation grows beyond a configurable token\n * threshold. The implementation is intentionally model-agnostic so it can be used\n * with any LangChain chat model.\n */\nimport type { BaseMessage } from \"@langchain/core/messages\";\n/**\n * Function type for counting tokens in a sequence of messages.\n */\nexport type TokenCounter = (messages: BaseMessage[]) => number | Promise<number>;\n/**\n * Protocol describing a context editing strategy.\n *\n * Implement this interface to create custom strategies for managing\n * conversation context size. The `apply` method should modify the\n * messages array in-place and return the updated token count.\n *\n * @example\n * ```ts\n * import { SystemMessage } from \"langchain\";\n *\n * class RemoveOldSystemMessages implements ContextEdit {\n *   async apply({ tokens, messages, countTokens }) {\n *     // Remove old system messages if over limit\n *     if (tokens > 50000) {\n *       messages = messages.filter(SystemMessage.isInstance);\n *       return await countTokens(messages);\n *     }\n *     return tokens;\n *   }\n * }\n * ```\n */\nexport interface ContextEdit {\n    /**\n     * Apply an edit to the message list, returning the new token count.\n     *\n     * This method should:\n     * 1. Check if editing is needed based on `tokens` parameter\n     * 2. Modify the `messages` array in-place (if needed)\n     * 3. Return the new token count after modifications\n     *\n     * @param params - Parameters for the editing operation\n     * @returns The updated token count after applying edits\n     */\n    apply(params: {\n        /**\n         * Current token count of all messages\n         */\n        tokens: number;\n        /**\n         * Array of messages to potentially edit (modify in-place)\n         */\n        messages: BaseMessage[];\n        /**\n         * Function to count tokens in a message array\n         */\n        countTokens: TokenCounter;\n    }): number | Promise<number>;\n}\n/**\n * Configuration for clearing tool outputs when token limits are exceeded.\n */\nexport interface ClearToolUsesEditConfig {\n    /**\n     * Token count that triggers the edit.\n     * @default 100000\n     */\n    triggerTokens?: number;\n    /**\n     * Minimum number of tokens to reclaim when the edit runs.\n     * @default 0\n     */\n    clearAtLeast?: number;\n    /**\n     * Number of most recent tool results that must be preserved.\n     * @default 3\n     */\n    keep?: number;\n    /**\n     * Whether to clear the originating tool call parameters on the AI message.\n     * @default false\n     */\n    clearToolInputs?: boolean;\n    /**\n     * List of tool names to exclude from clearing.\n     * @default []\n     */\n    excludeTools?: string[];\n    /**\n     * Placeholder text inserted for cleared tool outputs.\n     * @default \"[cleared]\"\n     */\n    placeholder?: string;\n}\n/**\n * Strategy for clearing tool outputs when token limits are exceeded.\n *\n * This strategy mirrors Anthropic's `clear_tool_uses_20250919` behavior by\n * replacing older tool results with a placeholder text when the conversation\n * grows too large. It preserves the most recent tool results and can exclude\n * specific tools from being cleared.\n *\n * @example\n * ```ts\n * import { ClearToolUsesEdit } from \"langchain\";\n *\n * const edit = new ClearToolUsesEdit({\n *   triggerTokens: 100000,       // Start clearing at 100K tokens\n *   clearAtLeast: 0,             // Clear as much as needed\n *   keep: 3,                     // Always keep 3 most recent results\n *   excludeTools: [\"important\"], // Never clear \"important\" tool\n *   clearToolInputs: false,      // Keep tool call arguments\n *   placeholder: \"[cleared]\",    // Replacement text\n * });\n * ```\n */\nexport declare class ClearToolUsesEdit implements ContextEdit {\n    #private;\n    triggerTokens: number;\n    clearAtLeast: number;\n    keep: number;\n    clearToolInputs: boolean;\n    excludeTools: Set<string>;\n    placeholder: string;\n    constructor(config?: ClearToolUsesEditConfig);\n    apply(params: {\n        tokens: number;\n        messages: BaseMessage[];\n        countTokens: TokenCounter;\n    }): Promise<number>;\n}\n/**\n * Configuration for the Context Editing Middleware.\n */\nexport interface ContextEditingMiddlewareConfig {\n    /**\n     * Sequence of edit strategies to apply. Defaults to a single\n     * ClearToolUsesEdit mirroring Anthropic defaults.\n     */\n    edits?: ContextEdit[];\n    /**\n     * Whether to use approximate token counting (faster, less accurate)\n     * or exact counting implemented by the chat model (potentially slower, more accurate).\n     * Currently only OpenAI models support exact counting.\n     * @default \"approx\"\n     */\n    tokenCountMethod?: \"approx\" | \"model\";\n}\n/**\n * Middleware that automatically prunes tool results to manage context size.\n *\n * This middleware applies a sequence of edits when the total input token count\n * exceeds configured thresholds. By default, it uses the `ClearToolUsesEdit` strategy\n * which mirrors Anthropic's `clear_tool_uses_20250919` behaviour by clearing older\n * tool results once the conversation exceeds 100,000 tokens.\n *\n * ## Basic Usage\n *\n * Use the middleware with default settings to automatically manage context:\n *\n * @example Basic usage with defaults\n * ```ts\n * import { contextEditingMiddleware } from \"langchain\";\n * import { createAgent } from \"langchain\";\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   tools: [searchTool, calculatorTool],\n *   middleware: [\n *     contextEditingMiddleware(),\n *   ],\n * });\n * ```\n *\n * The default configuration:\n * - Triggers when context exceeds **100,000 tokens**\n * - Keeps the **3 most recent** tool results\n * - Uses **approximate token counting** (fast)\n * - Does not clear tool call arguments\n *\n * ## Custom Configuration\n *\n * Customize the clearing behavior with `ClearToolUsesEdit`:\n *\n * @example Custom ClearToolUsesEdit configuration\n * ```ts\n * import { contextEditingMiddleware, ClearToolUsesEdit } from \"langchain\";\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   tools: [searchTool, calculatorTool],\n *   middleware: [\n *     contextEditingMiddleware({\n *       edits: [\n *         new ClearToolUsesEdit({\n *           triggerTokens: 50000,      // Clear when exceeding 50K tokens\n *           clearAtLeast: 1000,         // Reclaim at least 1K tokens\n *           keep: 5,                    // Keep 5 most recent tool results\n *           excludeTools: [\"search\"],   // Never clear search results\n *           clearToolInputs: true,      // Also clear tool call arguments\n *         }),\n *       ],\n *       tokenCountMethod: \"approx\",     // Use approximate counting (or \"model\")\n *     }),\n *   ],\n * });\n * ```\n *\n * ## Custom Editing Strategies\n *\n * Implement your own context editing strategy by creating a class that\n * implements the `ContextEdit` interface:\n *\n * @example Custom editing strategy\n * ```ts\n * import { contextEditingMiddleware, type ContextEdit, type TokenCounter } from \"langchain\";\n * import type { BaseMessage } from \"@langchain/core/messages\";\n *\n * class CustomEdit implements ContextEdit {\n *   async apply(params: {\n *     tokens: number;\n *     messages: BaseMessage[];\n *     countTokens: TokenCounter;\n *   }): Promise<number> {\n *     // Implement your custom editing logic here\n *     // and apply it to the messages array, then\n *     // return the new token count after edits\n *     return countTokens(messages);\n *   }\n * }\n * ```\n *\n * @param config - Configuration options for the middleware\n * @returns A middleware instance that can be used with `createAgent`\n */\nexport declare function contextEditingMiddleware(config?: ContextEditingMiddlewareConfig): import(\"./types.js\").AgentMiddleware<undefined, undefined, any>;\n"],"mappings":";;;;;AAoCA;;;AAwBqBC,KAhDTA,YAAAA,GAgDSA,CAAAA,QAAAA,EAhDiBD,WAgDjBC,EAAAA,EAAAA,GAAAA,MAAAA,GAhD4CC,OAgD5CD,CAAAA,MAAAA,CAAAA;;AACG;AAKxB;AAsDA;;;;;;;;AAA6D;AAkB7D;AAqGA;;;;AAA+H;;;;;;UA3M9GE,WAAAA;;;;;;;;;;;;;;;;;;;;cAoBCH;;;;iBAIGC;eACJC;;;;;UAKAE,uBAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsDIC,iBAAAA,YAA6BF;;;;;;gBAMhCG;;uBAEOF;;;cAGPJ;iBACGC;MACbC;;;;;UAKSK,8BAAAA;;;;;UAKLJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgGYK,wBAAAA,UAAkCD,iCAA8B"}
+{"version":3,"file":"contextEditing.d.cts","names":["BaseMessage","TokenCounter","Promise","ContextEdit","ClearToolUsesEditConfig","ClearToolUsesEdit","Set","ContextEditingMiddlewareConfig","contextEditingMiddleware","__types_js1","AgentMiddleware"],"sources":["../../../src/agents/middleware/contextEditing.d.ts"],"sourcesContent":["/**\n * Context editing middleware.\n *\n * This middleware mirrors Anthropic's context editing capabilities by clearing\n * older tool results once the conversation grows beyond a configurable token\n * threshold. The implementation is intentionally model-agnostic so it can be used\n * with any LangChain chat model.\n */\nimport type { BaseMessage } from \"@langchain/core/messages\";\n/**\n * Function type for counting tokens in a sequence of messages.\n */\nexport type TokenCounter = (messages: BaseMessage[]) => number | Promise<number>;\n/**\n * Protocol describing a context editing strategy.\n *\n * Implement this interface to create custom strategies for managing\n * conversation context size. The `apply` method should modify the\n * messages array in-place and return the updated token count.\n *\n * @example\n * ```ts\n * import { SystemMessage } from \"langchain\";\n *\n * class RemoveOldSystemMessages implements ContextEdit {\n *   async apply({ tokens, messages, countTokens }) {\n *     // Remove old system messages if over limit\n *     if (tokens > 50000) {\n *       messages = messages.filter(SystemMessage.isInstance);\n *       return await countTokens(messages);\n *     }\n *     return tokens;\n *   }\n * }\n * ```\n */\nexport interface ContextEdit {\n    /**\n     * Apply an edit to the message list, returning the new token count.\n     *\n     * This method should:\n     * 1. Check if editing is needed based on `tokens` parameter\n     * 2. Modify the `messages` array in-place (if needed)\n     * 3. Return the new token count after modifications\n     *\n     * @param params - Parameters for the editing operation\n     * @returns The updated token count after applying edits\n     */\n    apply(params: {\n        /**\n         * Current token count of all messages\n         */\n        tokens: number;\n        /**\n         * Array of messages to potentially edit (modify in-place)\n         */\n        messages: BaseMessage[];\n        /**\n         * Function to count tokens in a message array\n         */\n        countTokens: TokenCounter;\n    }): number | Promise<number>;\n}\n/**\n * Configuration for clearing tool outputs when token limits are exceeded.\n */\nexport interface ClearToolUsesEditConfig {\n    /**\n     * Token count that triggers the edit.\n     * @default 100000\n     */\n    triggerTokens?: number;\n    /**\n     * Minimum number of tokens to reclaim when the edit runs.\n     * @default 0\n     */\n    clearAtLeast?: number;\n    /**\n     * Number of most recent tool results that must be preserved.\n     * @default 3\n     */\n    keep?: number;\n    /**\n     * Whether to clear the originating tool call parameters on the AI message.\n     * @default false\n     */\n    clearToolInputs?: boolean;\n    /**\n     * List of tool names to exclude from clearing.\n     * @default []\n     */\n    excludeTools?: string[];\n    /**\n     * Placeholder text inserted for cleared tool outputs.\n     * @default \"[cleared]\"\n     */\n    placeholder?: string;\n}\n/**\n * Strategy for clearing tool outputs when token limits are exceeded.\n *\n * This strategy mirrors Anthropic's `clear_tool_uses_20250919` behavior by\n * replacing older tool results with a placeholder text when the conversation\n * grows too large. It preserves the most recent tool results and can exclude\n * specific tools from being cleared.\n *\n * @example\n * ```ts\n * import { ClearToolUsesEdit } from \"langchain\";\n *\n * const edit = new ClearToolUsesEdit({\n *   triggerTokens: 100000,       // Start clearing at 100K tokens\n *   clearAtLeast: 0,             // Clear as much as needed\n *   keep: 3,                     // Always keep 3 most recent results\n *   excludeTools: [\"important\"], // Never clear \"important\" tool\n *   clearToolInputs: false,      // Keep tool call arguments\n *   placeholder: \"[cleared]\",    // Replacement text\n * });\n * ```\n */\nexport declare class ClearToolUsesEdit implements ContextEdit {\n    #private;\n    triggerTokens: number;\n    clearAtLeast: number;\n    keep: number;\n    clearToolInputs: boolean;\n    excludeTools: Set<string>;\n    placeholder: string;\n    constructor(config?: ClearToolUsesEditConfig);\n    apply(params: {\n        tokens: number;\n        messages: BaseMessage[];\n        countTokens: TokenCounter;\n    }): Promise<number>;\n}\n/**\n * Configuration for the Context Editing Middleware.\n */\nexport interface ContextEditingMiddlewareConfig {\n    /**\n     * Sequence of edit strategies to apply. Defaults to a single\n     * ClearToolUsesEdit mirroring Anthropic defaults.\n     */\n    edits?: ContextEdit[];\n    /**\n     * Whether to use approximate token counting (faster, less accurate)\n     * or exact counting implemented by the chat model (potentially slower, more accurate).\n     * Currently only OpenAI models support exact counting.\n     * @default \"approx\"\n     */\n    tokenCountMethod?: \"approx\" | \"model\";\n}\n/**\n * Middleware that automatically prunes tool results to manage context size.\n *\n * This middleware applies a sequence of edits when the total input token count\n * exceeds configured thresholds. By default, it uses the `ClearToolUsesEdit` strategy\n * which mirrors Anthropic's `clear_tool_uses_20250919` behaviour by clearing older\n * tool results once the conversation exceeds 100,000 tokens.\n *\n * ## Basic Usage\n *\n * Use the middleware with default settings to automatically manage context:\n *\n * @example Basic usage with defaults\n * ```ts\n * import { contextEditingMiddleware } from \"langchain\";\n * import { createAgent } from \"langchain\";\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   tools: [searchTool, calculatorTool],\n *   middleware: [\n *     contextEditingMiddleware(),\n *   ],\n * });\n * ```\n *\n * The default configuration:\n * - Triggers when context exceeds **100,000 tokens**\n * - Keeps the **3 most recent** tool results\n * - Uses **approximate token counting** (fast)\n * - Does not clear tool call arguments\n *\n * ## Custom Configuration\n *\n * Customize the clearing behavior with `ClearToolUsesEdit`:\n *\n * @example Custom ClearToolUsesEdit configuration\n * ```ts\n * import { contextEditingMiddleware, ClearToolUsesEdit } from \"langchain\";\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   tools: [searchTool, calculatorTool],\n *   middleware: [\n *     contextEditingMiddleware({\n *       edits: [\n *         new ClearToolUsesEdit({\n *           triggerTokens: 50000,      // Clear when exceeding 50K tokens\n *           clearAtLeast: 1000,         // Reclaim at least 1K tokens\n *           keep: 5,                    // Keep 5 most recent tool results\n *           excludeTools: [\"search\"],   // Never clear search results\n *           clearToolInputs: true,      // Also clear tool call arguments\n *         }),\n *       ],\n *       tokenCountMethod: \"approx\",     // Use approximate counting (or \"model\")\n *     }),\n *   ],\n * });\n * ```\n *\n * ## Custom Editing Strategies\n *\n * Implement your own context editing strategy by creating a class that\n * implements the `ContextEdit` interface:\n *\n * @example Custom editing strategy\n * ```ts\n * import { contextEditingMiddleware, type ContextEdit, type TokenCounter } from \"langchain\";\n * import type { BaseMessage } from \"@langchain/core/messages\";\n *\n * class CustomEdit implements ContextEdit {\n *   async apply(params: {\n *     tokens: number;\n *     messages: BaseMessage[];\n *     countTokens: TokenCounter;\n *   }): Promise<number> {\n *     // Implement your custom editing logic here\n *     // and apply it to the messages array, then\n *     // return the new token count after edits\n *     return countTokens(messages);\n *   }\n * }\n * ```\n *\n * @param config - Configuration options for the middleware\n * @returns A middleware instance that can be used with `createAgent`\n */\nexport declare function contextEditingMiddleware(config?: ContextEditingMiddlewareConfig): import(\"./types.js\").AgentMiddleware<undefined, undefined, any>;\n"],"mappings":";;;;;AAoCA;;;AAwBqBC,KAhDTA,YAAAA,GAgDSA,CAAAA,QAAAA,EAhDiBD,WAgDjBC,EAAAA,EAAAA,GAAAA,MAAAA,GAhD4CC,OAgD5CD,CAAAA,MAAAA,CAAAA;;AACG;AAKxB;AAsDA;;;;;;;;AAA6D;AAkB7D;AAqGA;;;;AAA+H;;;;;;UA3M9GE,WAAAA;;;;;;;;;;;;;;;;;;;;cAoBCH;;;;iBAIGC;eACJC;;;;;UAKAE,uBAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsDIC,iBAAAA,YAA6BF;;;;;;gBAMhCG;;uBAEOF;;;cAGPJ;iBACGC;MACbC;;;;;UAKSK,8BAAAA;;;;;UAKLJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgGYK,wBAAAA,UAAkCD,iCAA8B"}