langchain 1.2.20 → 1.2.22

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["InteropZodObject","InteropZodType","ClientTool","ServerTool","StateDefinitionInit","ResponseFormatUndefined","CreateAgentParams","AgentTypeConfig","CombineTools","AgentMiddleware","AnyAnnotationRoot","ExtractZodArrayTypes","ToolStrategy","TypedToolStrategy","ProviderStrategy","ResponseFormat","JsonSchemaFormat","ReactAgent","createAgent","StructuredResponseFormat","TStateSchema","ContextSchema","TMiddleware","TTools","Record","Omit","JumpToTarget","Runtime","toolStrategy","providerStrategy","createMiddleware","MIDDLEWARE_BRAND","FakeToolCallingModel"],"sources":["../../src/agents/index.d.ts"],"sourcesContent":["import type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\nimport type { StateDefinitionInit } from \"@langchain/langgraph\";\nimport type { ResponseFormatUndefined } from \"./responses.js\";\nimport type { CreateAgentParams, AgentTypeConfig, CombineTools } 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 * @example With StateSchema\n * ```ts\n * import { createAgent } from \"langchain\";\n * import { StateSchema, ReducedValue } from \"@langchain/langgraph\";\n * import { z } from \"zod\";\n *\n * const AgentState = new StateSchema({\n *   userId: z.string(),\n *   count: z.number().default(0),\n *   history: new ReducedValue(\n *     z.array(z.string()).default(() => []),\n *     { inputSchema: z.string(), reducer: (c, n) => [...c, n] }\n *   ),\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [searchTool],\n *   stateSchema: AgentState,\n * });\n * ```\n */\nexport declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, InteropZodType<StructuredResponseFormat>> & {\n    responseFormat: InteropZodType<StructuredResponseFormat>;\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<StructuredResponseFormat extends readonly InteropZodType<any>[], TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<ExtractZodArrayTypes<StructuredResponseFormat> extends Record<string, any> ? ExtractZodArrayTypes<StructuredResponseFormat> : Record<string, any>, TStateSchema, ContextSchema, StructuredResponseFormat> & {\n    responseFormat: StructuredResponseFormat;\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<ExtractZodArrayTypes<StructuredResponseFormat> extends Record<string, any> ? ExtractZodArrayTypes<StructuredResponseFormat> : Record<string, any>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat> & {\n    responseFormat: JsonSchemaFormat;\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<Record<string, unknown>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat[]> & {\n    responseFormat: JsonSchemaFormat[];\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<Record<string, unknown>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat | JsonSchemaFormat[]> & {\n    responseFormat: JsonSchemaFormat | JsonSchemaFormat[];\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<Record<string, unknown>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, TypedToolStrategy<StructuredResponseFormat>> & {\n    responseFormat: TypedToolStrategy<StructuredResponseFormat>;\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ToolStrategy<StructuredResponseFormat>> & {\n    responseFormat: ToolStrategy<StructuredResponseFormat>;\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ProviderStrategy<StructuredResponseFormat>> & {\n    responseFormat: ProviderStrategy<StructuredResponseFormat>;\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, TStateSchema, ContextSchema, never>, \"responseFormat\"> & {\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<ResponseFormatUndefined, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, TStateSchema, ContextSchema, never>, \"responseFormat\"> & {\n    responseFormat?: undefined;\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<ResponseFormatUndefined, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ResponseFormat> & {\n    responseFormat: ResponseFormat;\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\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 { MIDDLEWARE_BRAND } from \"./middleware/types.js\";\nexport type * from \"./middleware/types.js\";\nexport { FakeToolCallingModel } from \"./tests/utils.js\";\nexport type { ReactAgent } from \"./ReactAgent.js\";\n//# sourceMappingURL=index.d.ts.map"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":["InteropZodObject","InteropZodType","ClientTool","ServerTool","StateDefinitionInit","ResponseFormatUndefined","CreateAgentParams","AgentTypeConfig","CombineTools","AgentMiddleware","AnyAnnotationRoot","ExtractZodArrayTypes","ToolStrategy","TypedToolStrategy","ProviderStrategy","ResponseFormat","JsonSchemaFormat","ReactAgent","createAgent","StructuredResponseFormat","TStateSchema","ContextSchema","TMiddleware","TTools","Record","Omit","JumpToTarget","Runtime","toolStrategy","providerStrategy","createMiddleware","MIDDLEWARE_BRAND","FakeToolCallingModel"],"sources":["../../src/agents/index.d.ts"],"sourcesContent":["import type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\nimport type { StateDefinitionInit } from \"@langchain/langgraph\";\nimport type { ResponseFormatUndefined } from \"./responses.js\";\nimport type { CreateAgentParams, AgentTypeConfig, CombineTools } 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 * @example With StateSchema\n * ```ts\n * import { createAgent } from \"langchain\";\n * import { StateSchema, ReducedValue } from \"@langchain/langgraph\";\n * import { z } from \"zod\";\n *\n * const AgentState = new StateSchema({\n *   userId: z.string(),\n *   count: z.number().default(0),\n *   history: new ReducedValue(\n *     z.array(z.string()).default(() => []),\n *     { inputSchema: z.string(), reducer: (c, n) => [...c, n] }\n *   ),\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [searchTool],\n *   stateSchema: AgentState,\n * });\n * ```\n */\nexport declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, InteropZodType<StructuredResponseFormat>> & {\n    responseFormat: InteropZodType<StructuredResponseFormat>;\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<StructuredResponseFormat extends readonly InteropZodType<any>[], TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<ExtractZodArrayTypes<StructuredResponseFormat> extends Record<string, any> ? ExtractZodArrayTypes<StructuredResponseFormat> : Record<string, any>, TStateSchema, ContextSchema, StructuredResponseFormat> & {\n    responseFormat: StructuredResponseFormat;\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<ExtractZodArrayTypes<StructuredResponseFormat> extends Record<string, any> ? ExtractZodArrayTypes<StructuredResponseFormat> : Record<string, any>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat> & {\n    responseFormat: JsonSchemaFormat;\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<Record<string, unknown>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat[]> & {\n    responseFormat: JsonSchemaFormat[];\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<Record<string, unknown>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<Record<string, unknown>, TStateSchema, ContextSchema, JsonSchemaFormat | JsonSchemaFormat[]> & {\n    responseFormat: JsonSchemaFormat | JsonSchemaFormat[];\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<Record<string, unknown>, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, TypedToolStrategy<StructuredResponseFormat>> & {\n    responseFormat: TypedToolStrategy<StructuredResponseFormat>;\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ToolStrategy<StructuredResponseFormat>> & {\n    responseFormat: ToolStrategy<StructuredResponseFormat>;\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ProviderStrategy<StructuredResponseFormat>> & {\n    responseFormat: ProviderStrategy<StructuredResponseFormat>;\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, TStateSchema, ContextSchema, never>, \"responseFormat\"> & {\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<ResponseFormatUndefined, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: Omit<CreateAgentParams<ResponseFormatUndefined, TStateSchema, ContextSchema, never>, \"responseFormat\"> & {\n    responseFormat?: undefined;\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<ResponseFormatUndefined, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\nexport declare function createAgent<StructuredResponseFormat extends Record<string, any> = Record<string, any>, TStateSchema extends StateDefinitionInit | undefined = undefined, ContextSchema extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, const TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[], const TTools extends readonly (ClientTool | ServerTool)[] = readonly (ClientTool | ServerTool)[]>(params: CreateAgentParams<StructuredResponseFormat, TStateSchema, ContextSchema, ResponseFormat> & {\n    responseFormat: ResponseFormat;\n    middleware?: TMiddleware;\n    tools?: TTools;\n}): ReactAgent<AgentTypeConfig<StructuredResponseFormat, TStateSchema, ContextSchema, TMiddleware, CombineTools<TTools, TMiddleware>>>;\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 TypedToolStrategy, type ResponseFormat, type ResponseFormatUndefined, } from \"./responses.js\";\nexport { createMiddleware } from \"./middleware.js\";\nexport { MIDDLEWARE_BRAND } from \"./middleware/types.js\";\nexport type * from \"./middleware/types.js\";\nexport { FakeToolCallingModel } from \"./tests/utils.js\";\nexport type { ReactAgent } from \"./ReactAgent.js\";\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;;;;;;;AAsJA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIc;AACd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIc;AACd;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIc;AACd;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIc;AACd;;;;;AAAyNS,iBApBjMS,WAoBiMT,CAAAA,iCApBpJe,MAoBoJf,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GApB9He,MAoB8Hf,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAAAA,qBApBpFL,mBAoBoFK,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBApBjBC,iBAoBiBD,GApBGT,gBAoBHS,GApBsBC,iBAoBtBD,EAAAA,0BAAAA,SApB4EA,eAoB5EA,EAAAA,GAAAA,SApByGA,eAoBzGA,EAAAA,EAAAA,qBAAAA,SAAAA,CApB2JP,UAoB3JO,GApBwKN,UAoBxKM,CAAAA,EAAAA,GAAAA,SAAAA,CApBkMP,UAoBlMO,GApB+MN,UAoB/MM,CAAAA,EAAAA,CAAAA,CAAAA,MAAAA,EApBsOH,iBAoBtOG,CApBwPU,wBAoBxPV,EApBkRW,YAoBlRX,EApBgSY,aAoBhSZ,EApB+SR,cAoB/SQ,CApB8TU,wBAoB9TV,CAAAA,CAAAA,GAAAA;EAA6BA,cAAAA,EAnBlOR,cAmBkOQ,CAnBnNU,wBAmBmNV,CAAAA;EAAkDP,UAAAA,CAAAA,EAlBvRoB,WAkBuRpB;EAAaC,KAAAA,CAAAA,EAjBzSoB,MAiBySpB;CAA0BD,CAAAA,EAhB3Ue,UAgB2Uf,CAhBhUK,eAgBgUL,CAhBhTiB,wBAgBgTjB,EAhBtRkB,YAgBsRlB,EAhBxQmB,aAgBwQnB,EAhBzPoB,WAgByPpB,EAhB5OM,YAgB4ON,CAhB/NqB,MAgB+NrB,EAhBvNoB,WAgBuNpB,CAAAA,CAAAA,CAAAA;AAAaC,iBAfpUe,WAeoUf,CAAAA,iCAAAA,SAf9QF,cAe8QE,CAAAA,GAAAA,CAAAA,EAAAA,EAAAA,qBAflOC,mBAekOD,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBAf/JO,iBAe+JP,GAf3IH,gBAe2IG,GAfxHO,iBAewHP,EAAAA,0BAAAA,SAflEM,eAekEN,EAAAA,GAAAA,SAfrCM,eAeqCN,EAAAA,EAAAA,qBAAAA,SAAAA,CAfaD,UAebC,GAf0BA,UAe1BA,CAAAA,EAAAA,GAAAA,SAAAA,CAfoDD,UAepDC,GAfiEA,UAejEA,CAAAA,EAAAA,CAAAA,CAAAA,MAAAA,EAfwFG,iBAexFH,CAf0GQ,oBAe1GR,CAf+HgB,wBAe/HhB,CAAAA,SAfiKqB,MAejKrB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAfuLQ,oBAevLR,CAf4MgB,wBAe5MhB,CAAAA,GAfwOqB,MAexOrB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAf6PiB,YAe7PjB,EAf2QkB,aAe3QlB,EAf0RgB,wBAe1RhB,CAAAA,GAAAA;EAAyCqB,cAAAA,EAdjXL,wBAciXK;EAAyBJ,UAAAA,CAAAA,EAb7YE,WAa6YF;EAAcC,KAAAA,CAAAA,EAZhaE,MAYgaF;CAAeL,CAAAA,EAXvbC,UAWubD,CAX5aT,eAW4aS,CAX5ZL,oBAW4ZK,CAXvYG,wBAWuYH,CAAAA,SAXrWQ,MAWqWR,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAX/UL,oBAW+UK,CAX1TG,wBAW0TH,CAAAA,GAX9RQ,MAW8RR,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAXzQI,YAWyQJ,EAX3PK,aAW2PL,EAX5OM,WAW4ON,EAX/NR,YAW+NQ,CAXlNO,MAWkNP,EAX1MM,WAW0MN,CAAAA,CAAAA,CAAAA;AAAmBA,iBAVtbE,WAUsbF,CAAAA,qBAVrZZ,mBAUqZY,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBAVlVN,iBAUkVM,GAV9ThB,gBAU8TgB,GAV3SN,iBAU2SM,EAAAA,0BAAAA,SAVrPP,eAUqPO,EAAAA,GAAAA,SAVxNP,eAUwNO,EAAAA,EAAAA,qBAAAA,SAAAA,CAVtKd,UAUsKc,GAVzJb,UAUyJa,CAAAA,EAAAA,GAAAA,SAAAA,CAV/Hd,UAU+Hc,GAVlHb,UAUkHa,CAAAA,EAAAA,CAAAA,CAAAA,MAAAA,EAV3FV,iBAU2FU,CAVzEQ,MAUyER,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAVhDI,YAUgDJ,EAVlCK,aAUkCL,EAVnBA,gBAUmBA,CAAAA,GAAAA;EAA3FV,cAAAA,EAT/VU,gBAS+VV;EAC/VU,UAAAA,CAAAA,EATHM,WASGN;EAAmBA,KAAAA,CAAAA,EAR3BO,MAQ2BP;CACtBM,CAAAA,EARbL,UAQaK,CARFf,eAQEe,CARcE,MAQdF,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EARuCF,YAQvCE,EARqDD,aAQrDC,EARoEA,WAQpEA,EARiFd,YAQjFc,CAR8FC,MAQ9FD,EARsGA,WAQtGA,CAAAA,CAAAA,CAAAA;AACLC,iBARYL,WAQZK,CAAAA,qBAR6CnB,mBAQ7CmB,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBARgHb,iBAQhHa,GARoIvB,gBAQpIuB,GARuJb,iBAQvJa,EAAAA,0BAAAA,SAR6Md,eAQ7Mc,EAAAA,GAAAA,SAR0Od,eAQ1Oc,EAAAA,EAAAA,qBAAAA,SAAAA,CAR4RrB,UAQ5RqB,GARySpB,UAQzSoB,CAAAA,EAAAA,GAAAA,SAAAA,CARmUrB,UAQnUqB,GARgVpB,UAQhVoB,CAAAA,EAAAA,CAAAA,CAAAA,MAAAA,EARuWjB,iBAQvWiB,CARyXC,MAQzXD,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EARkZH,YAQlZG,EARgaF,aAQhaE,EAR+aP,gBAQ/aO,EAAAA,CAAAA,GAAAA;EACmBC,cAAAA,EARXR,gBAQWQ,EAAAA;EAAyBJ,UAAAA,CAAAA,EAPvCE,WAOuCF;EAAcC,KAAAA,CAAAA,EAN1DE,MAM0DF;CAAeC,CAAAA,EALjFL,UAKiFK,CALtEf,eAKsEe,CALtDE,MAKsDF,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAL7BF,YAK6BE,EALfD,aAKeC,EALAA,WAKAA,EALad,YAKbc,CAL0BC,MAK1BD,EALkCA,WAKlCA,CAAAA,CAAAA,CAAAA;AAA0BC,iBAJvFL,WAIuFK,CAAAA,qBAJtDnB,mBAIsDmB,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBAJab,iBAIba,GAJiCvB,gBAIjCuB,GAJoDb,iBAIpDa,EAAAA,0BAAAA,SAJ0Gd,eAI1Gc,EAAAA,GAAAA,SAJuId,eAIvIc,EAAAA,EAAAA,qBAAAA,SAAAA,CAJyLrB,UAIzLqB,GAJsMpB,UAItMoB,CAAAA,EAAAA,GAAAA,SAAAA,CAJgOrB,UAIhOqB,GAJ6OpB,UAI7OoB,CAAAA,EAAAA,CAAAA,CAAAA,MAAAA,EAJoQjB,iBAIpQiB,CAJsRC,MAItRD,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAJ+SH,YAI/SG,EAJ6TF,aAI7TE,EAJ4UP,gBAI5UO,GAJ+VP,gBAI/VO,EAAAA,CAAAA,GAAAA;EAAQD,cAAAA,EAHnGN,gBAGmGM,GAHhFN,gBAGgFM,EAAAA;EAArBd,UAAAA,CAAAA,EAFjFc,WAEiFd;EAAnFD,KAAAA,CAAAA,EADHgB,MACGhB;CAAXU,CAAAA,EAAAA,UAAAA,CAAWV,eAAXU,CAA2BO,MAA3BP,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAAoDG,YAApDH,EAAkEI,aAAlEJ,EAAiFK,WAAjFL,EAA8FT,YAA9FS,CAA2GM,MAA3GN,EAAmHK,WAAnHL,CAAAA,CAAAA,CAAAA;AAAU,iBACUC,WADV,CAAA,iCACuDM,MADvD,CAAA,MAAA,EAAA,GAAA,CAAA,GAC6EA,MAD7E,CAAA,MAAA,EAAA,GAAA,CAAA,EAAA,qBACuHpB,mBADvH,GAAA,SAAA,GAAA,SAAA,EAAA,sBAC0LM,iBAD1L,GAC8MV,gBAD9M,GACiOU,iBADjO,EAAA,0BAAA,SACuRD,eADvR,EAAA,GAAA,SACoTA,eADpT,EAAA,EAAA,qBAAA,SAAA,CACsWP,UADtW,GACmXC,UADnX,CAAA,EAAA,GAAA,SAAA,CAC6YD,UAD7Y,GAC0ZC,UAD1Z,CAAA,EAAA,CAAA,CAAA,MAAA,EACibG,iBADjb,CACmca,wBADnc,EAC6dC,YAD7d,EAC2eC,aAD3e,EAC0fR,iBAD1f,CAC4gBM,wBAD5gB,CAAA,CAAA,GAAA;EACUD,cAAW,EACfL,iBADeM,CACGA,wBADHC,CAAAA;EAAkCI,UAAAA,CAAAA,EAEpDF,WAFoDE;EAAsBA,KAAAA,CAAAA,EAG/ED,MAH+EC;CAA0CpB,CAAAA,EAIjIa,UAJiIb,CAItHG,eAJsHH,CAItGe,wBAJsGf,EAI5EgB,YAJ4EhB,EAI9DiB,aAJ8DjB,EAI/CkB,WAJ+ClB,EAIlCI,YAJkCJ,CAIrBmB,MAJqBnB,EAIbkB,WAJalB,CAAAA,CAAAA,CAAAA;AAAmEM,iBAKhLQ,WALgLR,CAAAA,iCAKnIc,MALmId,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAK7Gc,MAL6Gd,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAAAA,qBAKnEN,mBALmEM,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBAKAA,iBALAA,GAKoBV,gBALpBU,GAKuCA,iBALvCA,EAAAA,0BAAAA,SAK6FD,eAL7FC,EAAAA,GAAAA,SAK0HD,eAL1HC,EAAAA,EAAAA,qBAAAA,SAAAA,CAK4KR,UAL5KQ,GAKyLP,UALzLO,CAAAA,EAAAA,GAAAA,SAAAA,CAKmNR,UALnNQ,GAKgOP,UALhOO,CAAAA,EAAAA,CAAAA,CAAAA,MAAAA,EAKuPJ,iBALvPI,CAKyQS,wBALzQT,EAKmSU,YALnSV,EAKiTW,aALjTX,EAKgUE,YALhUF,CAK6US,wBAL7UT,CAAAA,CAAAA,GAAAA;EAAoBV,cAAAA,EAMxMY,YANwMZ,CAM3LmB,wBAN2LnB,CAAAA;EAAmBU,UAAAA,CAAAA,EAO9NY,WAP8NZ;EAAsDD,KAAAA,CAAAA,EAQzRc,MARyRd;CAA6BA,CAAAA,EAS9TQ,UAT8TR,CASnTF,eATmTE,CASnSU,wBATmSV,EASzQW,YATyQX,EAS3PY,aAT2PZ,EAS5Oa,WAT4Ob,EAS/ND,YAT+NC,CASlNc,MATkNd,EAS1Ma,WAT0Mb,CAAAA,CAAAA,CAAAA;AAAkDP,iBAU5VgB,WAV4VhB,CAAAA,iCAU/SsB,MAV+StB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAUzRsB,MAVyRtB,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAAAA,qBAU/OE,mBAV+OF,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBAU5KQ,iBAV4KR,GAUxJF,gBAVwJE,GAUrIQ,iBAVqIR,EAAAA,0BAAAA,SAU/EO,eAV+EP,EAAAA,GAAAA,SAUlDO,eAVkDP,EAAAA,EAAAA,qBAAAA,SAAAA,CAUAA,UAVAA,GAUaC,UAVbD,CAAAA,EAAAA,GAAAA,SAAAA,CAUuCA,UAVvCA,GAUoDC,UAVpDD,CAAAA,EAAAA,CAAAA,CAAAA,MAAAA,EAU2EI,iBAV3EJ,CAU6FiB,wBAV7FjB,EAUuHkB,YAVvHlB,EAUqImB,aAVrInB,EAUoJY,gBAVpJZ,CAUqKiB,wBAVrKjB,CAAAA,CAAAA,GAAAA;EAAaC,cAAAA,EAW7WW,gBAX6WX,CAW5VgB,wBAX4VhB,CAAAA;EAA0BD,UAAAA,CAAAA,EAY1YoB,WAZ0YpB;EAAaC,KAAAA,CAAAA,EAa5ZoB,MAb4ZpB;CAAyCgB,CAAAA,EAc7cF,UAd6cE,CAclcZ,eAdkcY,CAclbA,wBAdkbA,EAcxZC,YAdwZD,EAc1YE,aAd0YF,EAc3XG,WAd2XH,EAc9WX,YAd8WW,CAcjWI,MAdiWJ,EAczVG,WAdyVH,CAAAA,CAAAA,CAAAA;AAA0BC,iBAendF,WAfmdE,CAAAA,qBAelbhB,mBAfkbgB,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBAe/WV,iBAf+WU,GAe3VpB,gBAf2VoB,GAexUV,iBAfwUU,EAAAA,0BAAAA,SAelRX,eAfkRW,EAAAA,GAAAA,SAerPX,eAfqPW,EAAAA,EAAAA,qBAAAA,SAAAA,CAenMlB,UAfmMkB,GAetLjB,UAfsLiB,CAAAA,EAAAA,GAAAA,SAAAA,CAe5JlB,UAf4JkB,GAe/IjB,UAf+IiB,CAAAA,EAAAA,CAAAA,CAAAA,MAAAA,EAexHK,IAfwHL,CAenHd,iBAfmHc,CAejGf,uBAfiGe,EAexEA,YAfwEA,EAe1DC,aAf0DD,EAAAA,KAAAA,CAAAA,EAAAA,gBAAAA,CAAAA,GAAAA;EAAcC,UAAAA,CAAAA,EAgBxeC,WAhBweD;EAAiCF,KAAAA,CAAAA,EAiB9gBI,MAjB8gBJ;CAAlBN,CAAAA,EAkBpgBI,UAlBogBJ,CAkBzfN,eAlByfM,CAkBzeR,uBAlByeQ,EAkBhdO,YAlBgdP,EAkBlcQ,aAlBkcR,EAkBnbS,WAlBmbT,EAkBtaL,YAlBsaK,CAkBzZU,MAlByZV,EAkBjZS,WAlBiZT,CAAAA,CAAAA,CAAAA;AAAzEP,iBAmBvaY,WAnBuaZ,CAAAA,qBAmBtYF,mBAnBsYE,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBAmBnUI,iBAnBmUJ,GAmB/SN,gBAnB+SM,GAmB5RI,iBAnB4RJ,EAAAA,0BAAAA,SAmBtOG,eAnBsOH,EAAAA,GAAAA,SAmBzMG,eAnByMH,EAAAA,EAAAA,qBAAAA,SAAAA,CAmBvJJ,UAnBuJI,GAmB1IH,UAnB0IG,CAAAA,EAAAA,GAAAA,SAAAA,CAmBhHJ,UAnBgHI,GAmBnGH,UAnBmGG,CAAAA,EAAAA,CAAAA,CAAAA,MAAAA,EAmB5EmB,IAnB4EnB,CAmBvEA,iBAnBuEA,CAmBrDD,uBAnBqDC,EAmB5Bc,YAnB4Bd,EAmBde,aAnBcf,EAAAA,KAAAA,CAAAA,EAAAA,gBAAAA,CAAAA,GAAAA;EACzZa,cAAAA,CAAAA,EAAAA,SAAAA;EAAlBN,UAAAA,CAAAA,EAoBHS,WApBGT;EACHS,KAAAA,CAAAA,EAoBLC,MApBKD;CACLC,CAAAA,EAoBRN,UApBQM,CAoBGhB,eApBHgB,CAoBmBlB,uBApBnBkB,EAoB4CH,YApB5CG,EAoB0DF,aApB1DE,EAoByED,WApBzEC,EAoBsFf,YApBtFe,CAoBmGA,MApBnGA,EAoB2GD,WApB3GC,CAAAA,CAAAA,CAAAA;AACmBJ,iBAoBPD,WApBOC,CAAAA,iCAoBsCK,MApBtCL,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAoB4DK,MApB5DL,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAAAA,qBAoBsGf,mBApBtGe,GAAAA,SAAAA,GAAAA,SAAAA,EAAAA,sBAoByKT,iBApBzKS,GAoB6LnB,gBApB7LmB,GAoBgNT,iBApBhNS,EAAAA,0BAAAA,SAoBsQV,eApBtQU,EAAAA,GAAAA,SAoBmSV,eApBnSU,EAAAA,EAAAA,qBAAAA,SAAAA,CAoBqVjB,UApBrViB,GAoBkWhB,UApBlWgB,CAAAA,EAAAA,GAAAA,SAAAA,CAoB4XjB,UApB5XiB,GAoByYhB,UApBzYgB,CAAAA,EAAAA,CAAAA,CAAAA,MAAAA,EAoBgab,iBApBhaa,CAoBkbA,wBApBlbA,EAoB4cC,YApB5cD,EAoB0dE,aApB1dF,EAoByeJ,cApBzeI,CAAAA,GAAAA;EAA0BC,cAAAA,EAqBrCL,cArBqCK;EAAcC,UAAAA,CAAAA,EAsBtDC,WAtBsDD;EAAeC,KAAAA,CAAAA,EAuB1EC,MAvB0ED;CAA0BC,CAAAA,EAwB5GN,UAxB4GM,CAwBjGhB,eAxBiGgB,CAwBjFJ,wBAxBiFI,EAwBvDH,YAxBuDG,EAwBzCF,aAxByCE,EAwB1BD,WAxB0BC,EAwBbf,YAxBae,CAwBAA,MAxBAA,EAwBQD,WAxBRC,CAAAA,CAAAA,CAAAA"}

package/dist/agents/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["params: CreateAgentParams<\n    StructuredResponseFormat,\n    TStateSchema,\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\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\nimport type { StateDefinitionInit } from \"@langchain/langgraph\";\n\nimport type { ResponseFormatUndefined } from \"./responses.js\";\nimport type {\n  CreateAgentParams,\n  AgentTypeConfig,\n  CombineTools,\n} 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 * @example With StateSchema\n * ```ts\n * import { createAgent } from \"langchain\";\n * import { StateSchema, ReducedValue } from \"@langchain/langgraph\";\n * import { z } from \"zod\";\n *\n * const AgentState = new StateSchema({\n *   userId: z.string(),\n *   count: z.number().default(0),\n *   history: new ReducedValue(\n *     z.array(z.string()).default(() => []),\n *     { inputSchema: z.string(), reducer: (c, n) => [...c, n] }\n *   ),\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [searchTool],\n *   stateSchema: AgentState,\n * });\n * ```\n */\n// Overload 1: With responseFormat as single InteropZodType\nexport function createAgent<\n  StructuredResponseFormat extends Record<string, any> = Record<string, any>,\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    InteropZodType<StructuredResponseFormat>\n  > & {\n    responseFormat: InteropZodType<StructuredResponseFormat>;\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 2: With responseFormat as array of InteropZodTypes (infers union type)\nexport function createAgent<\n  StructuredResponseFormat extends readonly InteropZodType<any>[],\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    ExtractZodArrayTypes<StructuredResponseFormat> extends Record<string, any>\n      ? ExtractZodArrayTypes<StructuredResponseFormat>\n      : Record<string, any>,\n    TStateSchema,\n    ContextSchema,\n    StructuredResponseFormat\n  > & {\n    responseFormat: StructuredResponseFormat;\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    ExtractZodArrayTypes<StructuredResponseFormat> extends Record<string, any>\n      ? ExtractZodArrayTypes<StructuredResponseFormat>\n      : Record<string, any>,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 3: With responseFormat as JsonSchemaFormat (JSON schema object)\nexport function createAgent<\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    Record<string, unknown>,\n    TStateSchema,\n    ContextSchema,\n    JsonSchemaFormat\n  > & {\n    responseFormat: JsonSchemaFormat;\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    Record<string, unknown>,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 4: With responseFormat as array of JsonSchemaFormat (JSON schema objects)\nexport function createAgent<\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    Record<string, unknown>,\n    TStateSchema,\n    ContextSchema,\n    JsonSchemaFormat[]\n  > & {\n    responseFormat: JsonSchemaFormat[];\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    Record<string, unknown>,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 4.5: With responseFormat as union of JsonSchemaFormat | JsonSchemaFormat[]\nexport function createAgent<\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    Record<string, unknown>,\n    TStateSchema,\n    ContextSchema,\n    JsonSchemaFormat | JsonSchemaFormat[]\n  > & {\n    responseFormat: JsonSchemaFormat | JsonSchemaFormat[];\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    Record<string, unknown>,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 5: With responseFormat as TypedToolStrategy (for union types from toolStrategy)\nexport function createAgent<\n  StructuredResponseFormat extends Record<string, any> = Record<string, any>,\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    TypedToolStrategy<StructuredResponseFormat>\n  > & {\n    responseFormat: TypedToolStrategy<StructuredResponseFormat>;\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 6: With responseFormat as single ToolStrategy instance\nexport function createAgent<\n  StructuredResponseFormat extends Record<string, any> = Record<string, any>,\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    ToolStrategy<StructuredResponseFormat>\n  > & {\n    responseFormat: ToolStrategy<StructuredResponseFormat>;\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 7: With responseFormat as ProviderStrategy\nexport function createAgent<\n  StructuredResponseFormat extends Record<string, any> = Record<string, any>,\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    ProviderStrategy<StructuredResponseFormat>\n  > & {\n    responseFormat: ProviderStrategy<StructuredResponseFormat>;\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 8: Without responseFormat property at all - with proper middleware state typing\nexport function createAgent<\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: Omit<\n    CreateAgentParams<\n      ResponseFormatUndefined,\n      TStateSchema,\n      ContextSchema,\n      never\n    >,\n    \"responseFormat\"\n  > & { middleware?: TMiddleware; tools?: TTools }\n): ReactAgent<\n  AgentTypeConfig<\n    ResponseFormatUndefined,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 9: With responseFormat explicitly undefined\nexport function createAgent<\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: Omit<\n    CreateAgentParams<\n      ResponseFormatUndefined,\n      TStateSchema,\n      ContextSchema,\n      never\n    >,\n    \"responseFormat\"\n  > & {\n    responseFormat?: undefined;\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    ResponseFormatUndefined,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 10: For other ResponseFormat values (failsafe)\nexport function createAgent<\n  StructuredResponseFormat extends Record<string, any> = Record<string, any>,\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    ResponseFormat\n  > & {\n    responseFormat: ResponseFormat;\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Implementation\nexport function createAgent<\n  StructuredResponseFormat extends Record<string, any>,\n  TStateSchema extends StateDefinitionInit,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject,\n  TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[],\n  TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    any\n  >\n): ReactAgent<\n  AgentTypeConfig<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\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 { MIDDLEWARE_BRAND } from \"./middleware/types.js\";\nexport type * from \"./middleware/types.js\";\nexport { FakeToolCallingModel } from \"./tests/utils.js\";\nexport type { ReactAgent } from \"./ReactAgent.js\";\n"],"mappings":";;;;;;;;AAmhBA,SAAgB,YAUdA,QAcA;AACA,QAAO,IAAI,WAAW;AACvB"}
+{"version":3,"file":"index.js","names":["params: CreateAgentParams<\n    StructuredResponseFormat,\n    TStateSchema,\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\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\nimport type { StateDefinitionInit } from \"@langchain/langgraph\";\n\nimport type { ResponseFormatUndefined } from \"./responses.js\";\nimport type {\n  CreateAgentParams,\n  AgentTypeConfig,\n  CombineTools,\n} 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 * @example With StateSchema\n * ```ts\n * import { createAgent } from \"langchain\";\n * import { StateSchema, ReducedValue } from \"@langchain/langgraph\";\n * import { z } from \"zod\";\n *\n * const AgentState = new StateSchema({\n *   userId: z.string(),\n *   count: z.number().default(0),\n *   history: new ReducedValue(\n *     z.array(z.string()).default(() => []),\n *     { inputSchema: z.string(), reducer: (c, n) => [...c, n] }\n *   ),\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [searchTool],\n *   stateSchema: AgentState,\n * });\n * ```\n */\n// Overload 1: With responseFormat as single InteropZodType\nexport function createAgent<\n  StructuredResponseFormat extends Record<string, any> = Record<string, any>,\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    InteropZodType<StructuredResponseFormat>\n  > & {\n    responseFormat: InteropZodType<StructuredResponseFormat>;\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 2: With responseFormat as array of InteropZodTypes (infers union type)\nexport function createAgent<\n  StructuredResponseFormat extends readonly InteropZodType<any>[],\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    ExtractZodArrayTypes<StructuredResponseFormat> extends Record<string, any>\n      ? ExtractZodArrayTypes<StructuredResponseFormat>\n      : Record<string, any>,\n    TStateSchema,\n    ContextSchema,\n    StructuredResponseFormat\n  > & {\n    responseFormat: StructuredResponseFormat;\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    ExtractZodArrayTypes<StructuredResponseFormat> extends Record<string, any>\n      ? ExtractZodArrayTypes<StructuredResponseFormat>\n      : Record<string, any>,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 3: With responseFormat as JsonSchemaFormat (JSON schema object)\nexport function createAgent<\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    Record<string, unknown>,\n    TStateSchema,\n    ContextSchema,\n    JsonSchemaFormat\n  > & {\n    responseFormat: JsonSchemaFormat;\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    Record<string, unknown>,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 4: With responseFormat as array of JsonSchemaFormat (JSON schema objects)\nexport function createAgent<\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    Record<string, unknown>,\n    TStateSchema,\n    ContextSchema,\n    JsonSchemaFormat[]\n  > & {\n    responseFormat: JsonSchemaFormat[];\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    Record<string, unknown>,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 4.5: With responseFormat as union of JsonSchemaFormat | JsonSchemaFormat[]\nexport function createAgent<\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    Record<string, unknown>,\n    TStateSchema,\n    ContextSchema,\n    JsonSchemaFormat | JsonSchemaFormat[]\n  > & {\n    responseFormat: JsonSchemaFormat | JsonSchemaFormat[];\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    Record<string, unknown>,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 5: With responseFormat as TypedToolStrategy (for union types from toolStrategy)\nexport function createAgent<\n  StructuredResponseFormat extends Record<string, any> = Record<string, any>,\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    TypedToolStrategy<StructuredResponseFormat>\n  > & {\n    responseFormat: TypedToolStrategy<StructuredResponseFormat>;\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 6: With responseFormat as single ToolStrategy instance\nexport function createAgent<\n  StructuredResponseFormat extends Record<string, any> = Record<string, any>,\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    ToolStrategy<StructuredResponseFormat>\n  > & {\n    responseFormat: ToolStrategy<StructuredResponseFormat>;\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 7: With responseFormat as ProviderStrategy\nexport function createAgent<\n  StructuredResponseFormat extends Record<string, any> = Record<string, any>,\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    ProviderStrategy<StructuredResponseFormat>\n  > & {\n    responseFormat: ProviderStrategy<StructuredResponseFormat>;\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 8: Without responseFormat property at all - with proper middleware state typing\nexport function createAgent<\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: Omit<\n    CreateAgentParams<\n      ResponseFormatUndefined,\n      TStateSchema,\n      ContextSchema,\n      never\n    >,\n    \"responseFormat\"\n  > & { middleware?: TMiddleware; tools?: TTools }\n): ReactAgent<\n  AgentTypeConfig<\n    ResponseFormatUndefined,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 9: With responseFormat explicitly undefined\nexport function createAgent<\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: Omit<\n    CreateAgentParams<\n      ResponseFormatUndefined,\n      TStateSchema,\n      ContextSchema,\n      never\n    >,\n    \"responseFormat\"\n  > & {\n    responseFormat?: undefined;\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    ResponseFormatUndefined,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Overload 10: For other ResponseFormat values (failsafe)\nexport function createAgent<\n  StructuredResponseFormat extends Record<string, any> = Record<string, any>,\n  TStateSchema extends StateDefinitionInit | undefined = undefined,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject =\n    AnyAnnotationRoot,\n  const TMiddleware extends readonly AgentMiddleware[] =\n    readonly AgentMiddleware[],\n  const TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    ResponseFormat\n  > & {\n    responseFormat: ResponseFormat;\n    middleware?: TMiddleware;\n    tools?: TTools;\n  }\n): ReactAgent<\n  AgentTypeConfig<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\n>;\n\n// Implementation\nexport function createAgent<\n  StructuredResponseFormat extends Record<string, any>,\n  TStateSchema extends StateDefinitionInit,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject,\n  TMiddleware extends readonly AgentMiddleware[] = readonly AgentMiddleware[],\n  TTools extends readonly (ClientTool | ServerTool)[] = readonly (\n    | ClientTool\n    | ServerTool\n  )[],\n>(\n  params: CreateAgentParams<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    any\n  >\n): ReactAgent<\n  AgentTypeConfig<\n    StructuredResponseFormat,\n    TStateSchema,\n    ContextSchema,\n    TMiddleware,\n    CombineTools<TTools, TMiddleware>\n  >\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 TypedToolStrategy,\n  type ResponseFormat,\n  type ResponseFormatUndefined,\n} from \"./responses.js\";\nexport { createMiddleware } from \"./middleware.js\";\nexport { MIDDLEWARE_BRAND } from \"./middleware/types.js\";\nexport type * from \"./middleware/types.js\";\nexport { FakeToolCallingModel } from \"./tests/utils.js\";\nexport type { ReactAgent } from \"./ReactAgent.js\";\n"],"mappings":";;;;;;;;AAmhBA,SAAgB,YAUdA,QAcA;AACA,QAAO,IAAI,WAAW;AACvB"}

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

@@ -1 +1 @@
-{"version":3,"file":"hitl.d.cts","names":["__types_js7","z","ToolCall","InferInteropZodInput","AgentBuiltInState","Runtime","DescriptionFunctionSchema","Record","ZodTypeDef","ZodType","ZodUnknown","ZodTuple","ZodString","ZodPromise","ZodUnion","ZodFunction","DescriptionFactory","infer","DecisionType","ZodEnum","InterruptOnConfigSchema","ZodArray","ZodOptional","ZodAny","ZodRecord","ZodTypeAny","Promise","ZodObject","InterruptOnConfig","input","Action","ActionRequest","ReviewConfig","HITLRequest","ApproveDecision","EditDecision","RejectDecision","Decision","HITLResponse","contextSchema","ZodBoolean","ZodDefault","HumanInTheLoopMiddlewareConfig","humanInTheLoopMiddleware","NonNullable","_langchain_core_tools0","ServerTool","ClientTool","AgentMiddleware"],"sources":["../../../src/agents/middleware/hitl.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { ToolCall } from \"@langchain/core/messages\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\nimport type { AgentBuiltInState, Runtime } from \"../runtime.js\";\ndeclare const DescriptionFunctionSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>;\n/**\n * Function type that dynamically generates a description for a tool call approval request.\n *\n * @param toolCall - The tool call being reviewed\n * @param state - The current agent state\n * @param runtime - The agent runtime context\n * @returns A string description or Promise that resolves to a string description\n *\n * @example\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n *\n * const descriptionFactory: DescriptionFactory = (toolCall, state, runtime) => {\n *   return `Please review: ${toolCall.name}(${JSON.stringify(toolCall.args)})`;\n * };\n * ```\n */\nexport type DescriptionFactory = z.infer<typeof DescriptionFunctionSchema>;\ndeclare const DecisionType: z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>;\nexport type DecisionType = z.infer<typeof DecisionType>;\ndeclare const InterruptOnConfigSchema: z.ZodObject<{\n    /**\n     * The decisions that are allowed for this action.\n     */\n    allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n    /**\n     * The description attached to the request for human input.\n     * Can be either:\n     * - A static string describing the approval request\n     * - A callable that dynamically generates the description based on agent state,\n     *   runtime, and tool call information\n     *\n     * @example\n     * Static string description\n     * ```typescript\n     * import type { InterruptOnConfig } from \"langchain\";\n     *\n     * const config: InterruptOnConfig = {\n     *   allowedDecisions: [\"approve\", \"reject\"],\n     *   description: \"Please review this tool execution\"\n     * };\n     * ```\n     *\n     * @example\n     * Dynamic callable description\n     * ```typescript\n     * import type {\n     *   AgentBuiltInState,\n     *   Runtime,\n     *   DescriptionFactory,\n     *   ToolCall,\n     *   InterruptOnConfig\n     * } from \"langchain\";\n     *\n     * const formatToolDescription: DescriptionFactory = (\n     *   toolCall: ToolCall,\n     *   state: AgentBuiltInState,\n     *   runtime: Runtime<unknown>\n     * ) => {\n     *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n     * };\n     *\n     * const config: InterruptOnConfig = {\n     *   allowedDecisions: [\"approve\", \"edit\"],\n     *   description: formatToolDescription\n     * };\n     * ```\n     */\n    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n    /**\n     * JSON schema for the arguments associated with the action, if edits are allowed.\n     */\n    argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n}, \"strip\", z.ZodTypeAny, {\n    allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n    description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n    argsSchema?: Record<string, any> | undefined;\n}, {\n    allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n    description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n    argsSchema?: Record<string, any> | undefined;\n}>;\nexport type InterruptOnConfig = z.input<typeof InterruptOnConfigSchema>;\n/**\n * Represents an action with a name and arguments.\n */\nexport interface Action {\n    /**\n     * The type or name of action being requested (e.g., \"add_numbers\").\n     */\n    name: string;\n    /**\n     * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n     */\n    args: Record<string, any>;\n}\n/**\n * Represents an action request with a name, arguments, and description.\n */\nexport interface ActionRequest {\n    /**\n     * The name of the action being requested.\n     */\n    name: string;\n    /**\n     * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n     */\n    args: Record<string, any>;\n    /**\n     * The description of the action to be reviewed.\n     */\n    description?: string;\n}\n/**\n * Policy for reviewing a HITL request.\n */\nexport interface ReviewConfig {\n    /**\n     * Name of the action associated with this review configuration.\n     */\n    actionName: string;\n    /**\n     * The decisions that are allowed for this request.\n     */\n    allowedDecisions: DecisionType[];\n    /**\n     * JSON schema for the arguments associated with the action, if edits are allowed.\n     */\n    argsSchema?: Record<string, any>;\n}\n/**\n * Request for human feedback on a sequence of actions requested by a model.\n *\n * @example\n * ```ts\n * const hitlRequest: HITLRequest = {\n *   actionRequests: [\n *     { name: \"send_email\", args: { to: \"user@example.com\", subject: \"Hello\" } }\n *   ],\n *   reviewConfigs: [\n *     {\n *       actionName: \"send_email\",\n *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\n *       description: \"Please review the email before sending\"\n *     }\n *   ]\n * };\n * const response = interrupt(hitlRequest);\n * ```\n */\nexport interface HITLRequest {\n    /**\n     * A list of agent actions for human review.\n     */\n    actionRequests: ActionRequest[];\n    /**\n     * Review configuration for all possible actions.\n     */\n    reviewConfigs: ReviewConfig[];\n}\n/**\n * Response when a human approves the action.\n */\nexport interface ApproveDecision {\n    type: \"approve\";\n}\n/**\n * Response when a human edits the action.\n */\nexport interface EditDecision {\n    type: \"edit\";\n    /**\n     * Edited action for the agent to perform.\n     * Ex: for a tool call, a human reviewer can edit the tool name and args.\n     */\n    editedAction: Action;\n}\n/**\n * Response when a human rejects the action.\n */\nexport interface RejectDecision {\n    type: \"reject\";\n    /**\n     * The message sent to the model explaining why the action was rejected.\n     */\n    message?: string;\n}\n/**\n * Union of all possible decision types.\n */\nexport type Decision = ApproveDecision | EditDecision | RejectDecision;\n/**\n * Response payload for a HITLRequest.\n */\nexport interface HITLResponse {\n    /**\n     * The decisions made by the human.\n     */\n    decisions: Decision[];\n}\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * Mapping of tool name to allowed reviewer responses.\n     * If a tool doesn't have an entry, it's auto-approved by default.\n     *\n     * - `true` -> pause for approval and allow approve/edit/reject decisions\n     * - `false` -> auto-approve (no human review)\n     * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * The decisions that are allowed for this action.\n         */\n        allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n        /**\n         * The description attached to the request for human input.\n         * Can be either:\n         * - A static string describing the approval request\n         * - A callable that dynamically generates the description based on agent state,\n         *   runtime, and tool call information\n         *\n         * @example\n         * Static string description\n         * ```typescript\n         * import type { InterruptOnConfig } from \"langchain\";\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"reject\"],\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * import type {\n         *   AgentBuiltInState,\n         *   Runtime,\n         *   DescriptionFactory,\n         *   ToolCall,\n         *   InterruptOnConfig\n         * } from \"langchain\";\n         *\n         * const formatToolDescription: DescriptionFactory = (\n         *   toolCall: ToolCall,\n         *   state: AgentBuiltInState,\n         *   runtime: Runtime<unknown>\n         * ) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"edit\"],\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n        /**\n         * JSON schema for the arguments associated with the action, if edits are allowed.\n         */\n        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }>]>>>;\n    /**\n     * Prefix used when constructing human-facing approval messages.\n     * Provides context about the tool call being reviewed; does not change the underlying action.\n     *\n     * Note: This prefix is only applied for tools that do not provide a custom\n     * `description` via their {@link InterruptOnConfig}. If a tool specifies a custom\n     * `description`, that per-tool text is used and this prefix is ignored.\n     */\n    descriptionPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>;\nexport type HumanInTheLoopMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;\n/**\n * Creates a Human-in-the-Loop (HITL) middleware for tool approval and oversight.\n *\n * This middleware intercepts tool calls made by an AI agent and provides human oversight\n * capabilities before execution. It enables selective approval workflows where certain tools\n * require human intervention while others can execute automatically.\n *\n * A invocation result that has been interrupted by the middleware will have a `__interrupt__`\n * property that contains the interrupt request.\n *\n * ```ts\n * import { type HITLRequest, type HITLResponse } from \"langchain\";\n * import { type Interrupt } from \"langchain\";\n *\n * const result = await agent.invoke(request);\n * const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n * // Examine the action requests and review configs\n * const actionRequests = interruptRequest.value.actionRequests;\n * const reviewConfigs = interruptRequest.value.reviewConfigs;\n *\n * // Create decisions for each action\n * const resume: HITLResponse = {\n *   decisions: actionRequests.map((action, i) => {\n *     if (action.name === \"calculator\") {\n *       return { type: \"approve\" };\n *     } else if (action.name === \"write_file\") {\n *       return {\n *         type: \"edit\",\n *         editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Safe content\" } }\n *       };\n *     }\n *     return { type: \"reject\", message: \"Action not allowed\" };\n *   })\n * };\n *\n * // Resume with decisions\n * await agent.invoke(new Command({ resume }), config);\n * ```\n *\n * ## Features\n *\n * - **Selective Tool Approval**: Configure which tools require human approval\n * - **Multiple Decision Types**: Approve, edit, or reject tool calls\n * - **Asynchronous Workflow**: Uses LangGraph's interrupt mechanism for non-blocking approval\n * - **Custom Approval Messages**: Provide context-specific descriptions for approval requests\n *\n * ## Decision Types\n *\n * When a tool requires approval, the human operator can respond with:\n * - `approve`: Execute the tool with original arguments\n * - `edit`: Modify the tool name and/or arguments before execution\n * - `reject`: Provide a manual response instead of executing the tool\n *\n * @param options - Configuration options for the middleware\n * @param options.interruptOn - Per-tool configuration mapping tool names to their settings\n * @param options.interruptOn[toolName].allowedDecisions - Array of decision types allowed for this tool (e.g., [\"approve\", \"edit\", \"reject\"])\n * @param options.interruptOn[toolName].description - Custom approval message for the tool. Can be either a static string or a callable that dynamically generates the description based on agent state, runtime, and tool call information\n * @param options.interruptOn[toolName].argsSchema - JSON schema for the arguments associated with the action, if edits are allowed\n * @param options.descriptionPrefix - Default prefix for approval messages (default: \"Tool execution requires approval\"). Only used for tools that do not define a custom `description` in their InterruptOnConfig.\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @example\n * Basic usage with selective tool approval\n * ```typescript\n * import { humanInTheLoopMiddleware } from \"langchain\";\n * import { createAgent } from \"langchain\";\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     // Interrupt write_file tool and allow edits or approvals\n *     \"write_file\": {\n *       allowedDecisions: [\"approve\", \"edit\"],\n *       description: \"⚠️ File write operation requires approval\"\n *     },\n *     // Auto-approve read_file tool\n *     \"read_file\": false\n *   }\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4\",\n *   tools: [writeFileTool, readFileTool],\n *   middleware: [hitlMiddleware]\n * });\n * ```\n *\n * @example\n * Handling approval requests\n * ```typescript\n * import { type HITLRequest, type HITLResponse, type Interrupt } from \"langchain\";\n * import { Command } from \"@langchain/langgraph\";\n *\n * // Initial agent invocation\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Write 'Hello' to output.txt\")]\n * }, config);\n *\n * // Check if agent is paused for approval\n * if (result.__interrupt__) {\n *   const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n *   // Show tool call details to user\n *   console.log(\"Actions:\", interruptRequest.value.actionRequests);\n *   console.log(\"Review configs:\", interruptRequest.value.reviewConfigs);\n *\n *   // Resume with approval\n *   const resume: HITLResponse = {\n *     decisions: [{ type: \"approve\" }]\n *   };\n *   await agent.invoke(\n *     new Command({ resume }),\n *     config\n *   );\n * }\n * ```\n *\n * @example\n * Different decision types\n * ```typescript\n * import { type HITLResponse } from \"langchain\";\n *\n * // Approve the tool call as-is\n * const resume: HITLResponse = {\n *   decisions: [{ type: \"approve\" }]\n * };\n *\n * // Edit the tool arguments\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"edit\",\n *     editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Modified\" } }\n *   }]\n * };\n *\n * // Reject with feedback\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"reject\",\n *     message: \"File operation not allowed in demo mode\"\n *   }]\n * };\n * ```\n *\n * @example\n * Production use case with database operations\n * ```typescript\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     \"execute_sql\": {\n *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\n *       description: \"🚨 SQL query requires DBA approval\\nPlease review for safety and performance\"\n *     },\n *     \"read_schema\": false,  // Reading metadata is safe\n *     \"delete_records\": {\n *       allowedDecisions: [\"approve\", \"reject\"],\n *       description: \"⛔ DESTRUCTIVE OPERATION - Requires manager approval\"\n *     }\n *   },\n *   descriptionPrefix: \"Database operation pending approval\"\n * });\n * ```\n *\n * @example\n * Using dynamic callable descriptions\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n * import type { AgentBuiltInState, Runtime } from \"langchain/agents\";\n *\n * // Define a dynamic description factory\n * const formatToolDescription: DescriptionFactory = (\n *   toolCall: ToolCall,\n *   state: AgentBuiltInState,\n *   runtime: Runtime<unknown>\n * ) => {\n *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n * };\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     \"write_file\": {\n *       allowedDecisions: [\"approve\", \"edit\"],\n *       // Use dynamic description that can access tool call, state, and runtime\n *       description: formatToolDescription\n *     },\n *     // Or use an inline function\n *     \"send_email\": {\n *       allowedDecisions: [\"approve\", \"reject\"],\n *       description: (toolCall, state, runtime) => {\n *         const { to, subject } = toolCall.args;\n *         return `Email to ${to}\\nSubject: ${subject}\\n\\nRequires approval before sending`;\n *       }\n *     }\n *   }\n * });\n * ```\n *\n * @remarks\n * - Tool calls are processed in the order they appear in the AI message\n * - Auto-approved tools execute immediately without interruption\n * - Multiple tools requiring approval are bundled into a single interrupt request\n * - The middleware operates in the `afterModel` phase, intercepting before tool execution\n * - Requires a checkpointer to maintain state across interruptions\n *\n * @see {@link createAgent} for agent creation\n * @see {@link Command} for resuming interrupted execution\n * @public\n */\nexport declare function humanInTheLoopMiddleware(options: NonNullable<HumanInTheLoopMiddlewareConfig>): import(\"./types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    /**\n     * Mapping of tool name to allowed reviewer responses.\n     * If a tool doesn't have an entry, it's auto-approved by default.\n     *\n     * - `true` -> pause for approval and allow approve/edit/reject decisions\n     * - `false` -> auto-approve (no human review)\n     * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * The decisions that are allowed for this action.\n         */\n        allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n        /**\n         * The description attached to the request for human input.\n         * Can be either:\n         * - A static string describing the approval request\n         * - A callable that dynamically generates the description based on agent state,\n         *   runtime, and tool call information\n         *\n         * @example\n         * Static string description\n         * ```typescript\n         * import type { InterruptOnConfig } from \"langchain\";\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"reject\"],\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * import type {\n         *   AgentBuiltInState,\n         *   Runtime,\n         *   DescriptionFactory,\n         *   ToolCall,\n         *   InterruptOnConfig\n         * } from \"langchain\";\n         *\n         * const formatToolDescription: DescriptionFactory = (\n         *   toolCall: ToolCall,\n         *   state: AgentBuiltInState,\n         *   runtime: Runtime<unknown>\n         * ) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"edit\"],\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n        /**\n         * JSON schema for the arguments associated with the action, if edits are allowed.\n         */\n        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }>]>>>;\n    /**\n     * Prefix used when constructing human-facing approval messages.\n     * Provides context about the tool call being reviewed; does not change the underlying action.\n     *\n     * Note: This prefix is only applied for tools that do not provide a custom\n     * `description` via their {@link InterruptOnConfig}. If a tool specifies a custom\n     * `description`, that per-tool text is used and this prefix is ignored.\n     */\n    descriptionPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, readonly (import(\"@langchain/core/tools\").ServerTool | import(\"@langchain/core/tools\").ClientTool)[]>;\nexport {};\n//# sourceMappingURL=hitl.d.ts.map"],"mappings":";;;;;;;;cAIcM,2BAA2BL,CAAAA,CAAEc,YAAYd,CAAAA,CAAEU,UAAUV,CAAAA,CAAEQ,QAAQP,iBAAiBK,sBAAsBN,CAAAA,CAAEO,YAAYN,iBAAiBK,uBAAuBN,CAAAA,CAAEQ,QAAQL,mBAAmBH,CAAAA,CAAEO,YAAYJ,oBAAoBH,CAAAA,CAAEQ,QAAQJ,kBAAkBJ,CAAAA,CAAEO,YAAYH,oBAAoBJ,CAAAA,CAAES,aAAaT,CAAAA,CAAEa,UAAUb,CAAAA,CAAEW,WAAWX,CAAAA,CAAEY,WAAWZ,CAAAA,CAAEW;;;;AAD9R;;;;;;;;;;;;;;AAC2KH,KAkB/NO,kBAAAA,GAAqBf,CAAAA,CAAEgB,KAlBwMR,CAAAA,OAkB3LH,yBAlB2LG,CAAAA;cAmB7NS,YAnB2RR,EAmB7QT,CAAAA,CAAEkB,OAnB2QT,CAAAA,CAAAA,SAAAA,EAAAA,MAAAA,EAAAA,QAAAA,CAAAA,CAAAA;AAAhPC,KAoB7CO,YAAAA,GAAejB,CAAAA,CAAEgB,KApB4BN,CAAAA,OAoBfO,YApBeP,CAAAA;cAqB3CS,uBArBsTR,EAqB7RX,CAAAA,CAAE0B,SArB2Rf,CAAAA;EAA0BA;;;EAAnTG,gBAAAA,EAyBrBd,CAAAA,CAAEoB,QAzBmBN,CAyBVd,CAAAA,CAAEkB,OAzBQJ,CAAAA,CAAAA,SAAAA,EAAAA,MAAAA,EAAAA,QAAAA,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA;EAAW;AAkBtD;AAA2E;AAE3E;AAAwD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4DnBb,WAAAA,EAXpBD,CAAAA,CAAEqB,WAWkBpB,CAXND,CAAAA,CAAEa,QAWIZ,CAAAA,CAXMD,CAAAA,CAAEW,SAWRV,EAXmBD,CAAAA,CAAEc,WAWrBb,CAXiCD,CAAAA,CAAEU,QAWnCT,CAAAA,CAX6CD,CAAAA,CAAEQ,OAW/CP,CAXuDA,QAWvDA,CAAAA,MAAAA,EAXwEK,MAWxEL,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,CAAAA,EAX8FD,CAAAA,CAAEO,UAWhGN,EAX4GA,QAW5GA,CAAAA,MAAAA,EAX6HK,MAW7HL,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,CAAAA,CAAAA,EAXoJD,CAAAA,CAAEQ,OAWtJP,CAX8JE,iBAW9JF,EAXiLD,CAAAA,CAAEO,UAWnLN,EAX+LE,iBAW/LF,CAAAA,EAXmND,CAAAA,CAAEQ,OAWrNP,CAX6NG,OAW7NH,CAAAA,OAAAA,CAAAA,EAX+OD,CAAAA,CAAEO,UAWjPN,EAX6PG,OAW7PH,CAAAA,OAAAA,CAAAA,CAAAA,CAAAA,EAXiRD,CAAAA,CAAES,UAWnRR,CAAAA,EAXgSD,CAAAA,CAAEa,QAWlSZ,CAAAA,CAX4SD,CAAAA,CAAEW,SAW9SV,EAXyTD,CAAAA,CAAEY,UAW3TX,CAXsUD,CAAAA,CAAEW,SAWxUV,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA;EAA+CE;;;EACnEG,UAAAA,EARDN,CAAAA,CAAEqB,WAQDf,CARaN,CAAAA,CAAEuB,SAQfjB,CARyBN,CAAAA,CAAEW,SAQ3BL,EARsCN,CAAAA,CAAEsB,MAQxChB,CAAAA,CAAAA;CA5DsBN,EAAE0B,OAAAA,EAqD7B1B,CAAAA,CAAEwB,UArD2BE,EAAAA;EAAS,gBAAA,EAAA,CAAA,SAAA,GAAA,MAAA,GAAA,QAAA,CAAA,EAAA;EA8DtCC,WAAAA,CAAAA,EAAAA,MAAiB,GAAA,CAAA,CAAA,MAAA,EAPQ1B,QAOUkB,CAAAA,MAAAA,EAPOb,MAOPa,CAAAA,MAAbS,EAAK,GAAA,CAAA,CAAA,EAAA,MAAA,EAP6CzB,iBAO7C,EAAA,MAAA,EAPwEC,OAOxE,CAAA,OAAA,CAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,EAAA,GAAA,MAAA,GAP0HqB,OAO1H,CAAA,MAAA,CAAA,CAAA,GAAA,SAAA;EAItBI,UAAM,CAAA,EAVNvB,MAUM,CAAA,MAQbA,EAAM,GAAA,CAAA,GAAA,SAAA;AAKhB,CAAA,EAAA;EAiBiByB,gBAAY,EAAA,CAAA,SAQPd,GAAAA,MAAAA,GAAAA,QAIC,CAAA,EAAA;EAsBNe,WAAAA,CAAAA,EAAW,MAAA,GAAA,CAAA,CAAA,MAIRF,EA3EiB7B,QA2EjB6B,CAIDC,MAAAA,EA/EmCzB,MA+EvB,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,EAAA,MAAA,EA/EqDH,iBA+ErD,EAAA,MAAA,EA/EgFC,OA+EhF,CAAA,OAAA,CAAA,EAAA,GAAA,IAAA,EAAA,OAAA,EAAA,EAAA,GAAA,MAAA,GA/EkIqB,OA+ElI,CAAA,MAAA,CAAA,CAAA,GAAA,SAAA;EAKdQ,UAAAA,CAAAA,EAnFA3B,MAmFe,CAAA,MAAA,EAAA,GAAA,CAAA,GAAA,SAAA;AAMhC,CAAA,CAAA;AAWiB6B,KAlGLR,iBAAAA,GAAoB3B,CAAAA,CAAE4B,KAkGH,CAAA,OAlGgBT,uBAkGhB,CAAA;AAU/B;;;AAAwDgB,UAxGvCN,MAAAA,CAwGuCM;EAAc;AAItE;AAKC;EAU4CxB,IAAAA,EAAAA,MAAAA;EAAyB4B;;;EAgDrB5B,IAAAA,EAnKvCL,MAmKuCK,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;;;;;AAAoGV,UA9JpI6B,aAAAA,CA8JoI7B;EAA7DO;;;EAAgJL,IAAAA,EAAAA,MAAAA;EAAzCK;;;EAAuGJ,IAAAA,EAtJ5RE,MAsJ4RF,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAAxCI;;;EAAyFG,WAAAA,CAAAA,EAAAA,MAAAA;;;;;AAAlTE,UA7IpBkB,YAAAA,CA6IoBlB;EAAdQ;;;EAIaE,UAAAA,EAAAA,MAAAA;EAAdF;;;EAGmBpB,gBAAAA,EA5InBgB,YA4ImBhB,EAAAA;EAA+CE;;;EACnEG,UAAAA,CAAAA,EAzIJA,MAyIIA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;;;;;;;;;;;;;;;;;;;;;;AAyBoBL,UA5IxB+B,WAAAA,CA4IwB/B;EAA+CE;;;EACnEG,cAAAA,EAzIDwB,aAyICxB,EAAAA;EAHHA;;AAxFsB;EA+F5BmC,aAAAA,EAzIOV,YAyIPU,EAAAA;AAkNZ;;;;AASsEF,UA/VrDN,eAAAA,CA+VqDM;EAI/BrB,IAAAA,EAAAA,SAAAA;;;;;AA4CkGX,UAzYxH2B,YAAAA,CAyYwH3B;EAA6BD,IAAAA,EAAAA,MAAAA;EAAjBL;;;;EAAmFE,YAAAA,EAnYtN0B,MAmYsN1B;;;;;AAAsBK,UA9X7O2B,cAAAA,CA8X6O3B;EAA8DC,IAAAA,EAAAA,QAAAA;EAAhPC;;;EAAwRE,OAAAA,CAAAA,EAAAA,MAAAA;;;;;AAIpTD,KAxXpCyB,QAAAA,GAAWH,eAwXyBtB,GAxXPuB,YAwXOvB,GAxXQwB,cAwXRxB;;;;AAC9Ba,UArXDa,YAAAA,CAqXCb;EAEwClB;;;EAAyDF,SAAAA,EAnXpGgC,QAmXoGhC,EAAAA;;cAjXrGkC,aAkXOhC,EAlXQN,CAAAA,CAAE0B,SAkXVpB,CAAAA;EAGqCA;;;;;;;;EA3DzBiB,WAAAA,EAjThBvB,CAAAA,CAAEqB,WAiTcE,CAjTFvB,CAAAA,CAAEuB,SAiTAA,CAjTUvB,CAAAA,CAAEW,SAiTZY,EAjTuBvB,CAAAA,CAAEa,QAiTzBU,CAAAA,CAjTmCvB,CAAAA,CAAEuC,UAiTrChB,EAjTiDvB,CAAAA,CAAE0B,SAiTnDH,CAAAA;IAAdF;;;IAuELG,gBAAAA,EApXYxB,CAAAA,CAAEoB,QAoXdI,CApXuBxB,CAAAA,CAAEkB,OAoXzBM,CAAAA,CAAAA,SAAAA,EAAAA,MAAAA,EAAAA,QAAAA,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA;IAG4ClB;;;;;;;;;;;;;;;;;;;;;;;;;AAnFkF;;;;;;;;;;;;;;;;;;iBAxPvHN,CAAAA,CAAEqB,YAAYrB,CAAAA,CAAEa,UAAUb,CAAAA,CAAEW,WAAWX,CAAAA,CAAEc,YAAYd,CAAAA,CAAEU,UAAUV,CAAAA,CAAEQ,QAAQP,iBAAiBK,sBAAsBN,CAAAA,CAAEO,YAAYN,iBAAiBK,uBAAuBN,CAAAA,CAAEQ,QAAQL,mBAAmBH,CAAAA,CAAEO,YAAYJ,oBAAoBH,CAAAA,CAAEQ,QAAQJ,kBAAkBJ,CAAAA,CAAEO,YAAYH,oBAAoBJ,CAAAA,CAAES,aAAaT,CAAAA,CAAEa,UAAUb,CAAAA,CAAEW,WAAWX,CAAAA,CAAEY,WAAWZ,CAAAA,CAAEW;;;;gBAI7VX,CAAAA,CAAEqB,YAAYrB,CAAAA,CAAEuB,UAAUvB,CAAAA,CAAEW,WAAWX,CAAAA,CAAEsB;cAC7CtB,CAAAA,CAAEwB;;qCAEuBvB,iBAAiBK,8BAA8BH,2BAA2BC,kDAAkDqB;iBAChJnB;;;qCAGoBL,iBAAiBK,8BAA8BH,2BAA2BC,kDAAkDqB;iBAChJnB;;;;;;;;;;qBAUEN,CAAAA,CAAEwC,WAAWxC,CAAAA,CAAEW;YAC1BX,CAAAA,CAAEwB;gBACIlB;;qCAEuBL,iBAAiBK,8BAA8BH,2BAA2BC,kDAAkDqB;iBAChJnB;;;;gBAIHA;;qCAEuBL,iBAAiBK,8BAA8BH,2BAA2BC,kDAAkDqB;iBAChJnB;;;;KAITmC,8BAAAA,GAAiCvC,4BAA4BoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkNjDI,wBAAAA,UAAkCC,YAAYF,6DAAkFzC,CAAAA,CAAE0B;;;;;;;;;eASzI1B,CAAAA,CAAEqB,YAAYrB,CAAAA,CAAEuB,UAAUvB,CAAAA,CAAEW,WAAWX,CAAAA,CAAEa,UAAUb,CAAAA,CAAEuC,YAAYvC,CAAAA,CAAE0B;;;;sBAI1D1B,CAAAA,CAAEoB,SAASpB,CAAAA,CAAEkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4ClBlB,CAAAA,CAAEqB,YAAYrB,CAAAA,CAAEa,UAAUb,CAAAA,CAAEW,WAAWX,CAAAA,CAAEc,YAAYd,CAAAA,CAAEU,UAAUV,CAAAA,CAAEQ,QAAQP,iBAAiBK,sBAAsBN,CAAAA,CAAEO,YAAYN,iBAAiBK,uBAAuBN,CAAAA,CAAEQ,QAAQL,mBAAmBH,CAAAA,CAAEO,YAAYJ,oBAAoBH,CAAAA,CAAEQ,QAAQJ,kBAAkBJ,CAAAA,CAAEO,YAAYH,oBAAoBJ,CAAAA,CAAES,aAAaT,CAAAA,CAAEa,UAAUb,CAAAA,CAAEW,WAAWX,CAAAA,CAAEY,WAAWZ,CAAAA,CAAEW;;;;gBAI7VX,CAAAA,CAAEqB,YAAYrB,CAAAA,CAAEuB,UAAUvB,CAAAA,CAAEW,WAAWX,CAAAA,CAAEsB;cAC7CtB,CAAAA,CAAEwB;;qCAEuBvB,iBAAiBK,8BAA8BH,2BAA2BC,kDAAkDqB;iBAChJnB;;;qCAGoBL,iBAAiBK,8BAA8BH,2BAA2BC,kDAAkDqB;iBAChJnB;;;;;;;;;;qBAUEN,CAAAA,CAAEwC,WAAWxC,CAAAA,CAAEW;YAC1BX,CAAAA,CAAEwB;gBACIlB;;qCAEuBL,iBAAiBK,8BAA8BH,2BAA2BC,kDAAkDqB;iBAChJnB;;;;gBAIHA;;qCAEuBL,iBAAiBK,8BAA8BH,2BAA2BC,kDAAkDqB;iBAChJnB;;;;gBAIHA;;qCAEuBL,iBAAiBK,8BAA8BH,2BAA2BC,kDAAkDqB;iBAChJnB;;;aAHGsC,sBAAAA,CAMqBC,UAAAA,GAAUD,sBAAAA,CAAmCE"}
+{"version":3,"file":"hitl.d.cts","names":["__types_js7","z","ToolCall","InferInteropZodInput","AgentBuiltInState","Runtime","DescriptionFunctionSchema","Record","ZodTypeDef","ZodType","ZodUnknown","ZodTuple","ZodString","ZodPromise","ZodUnion","ZodFunction","DescriptionFactory","infer","DecisionType","ZodEnum","InterruptOnConfigSchema","ZodArray","ZodOptional","ZodAny","ZodRecord","ZodTypeAny","Promise","ZodObject","InterruptOnConfig","input","Action","ActionRequest","ReviewConfig","HITLRequest","ApproveDecision","EditDecision","RejectDecision","Decision","HITLResponse","contextSchema","ZodBoolean","ZodDefault","HumanInTheLoopMiddlewareConfig","humanInTheLoopMiddleware","NonNullable","_langchain_core_tools0","ServerTool","ClientTool","AgentMiddleware"],"sources":["../../../src/agents/middleware/hitl.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { ToolCall } from \"@langchain/core/messages\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\nimport type { AgentBuiltInState, Runtime } from \"../runtime.js\";\ndeclare const DescriptionFunctionSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>;\n/**\n * Function type that dynamically generates a description for a tool call approval request.\n *\n * @param toolCall - The tool call being reviewed\n * @param state - The current agent state\n * @param runtime - The agent runtime context\n * @returns A string description or Promise that resolves to a string description\n *\n * @example\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n *\n * const descriptionFactory: DescriptionFactory = (toolCall, state, runtime) => {\n *   return `Please review: ${toolCall.name}(${JSON.stringify(toolCall.args)})`;\n * };\n * ```\n */\nexport type DescriptionFactory = z.infer<typeof DescriptionFunctionSchema>;\ndeclare const DecisionType: z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>;\nexport type DecisionType = z.infer<typeof DecisionType>;\ndeclare const InterruptOnConfigSchema: z.ZodObject<{\n    /**\n     * The decisions that are allowed for this action.\n     */\n    allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n    /**\n     * The description attached to the request for human input.\n     * Can be either:\n     * - A static string describing the approval request\n     * - A callable that dynamically generates the description based on agent state,\n     *   runtime, and tool call information\n     *\n     * @example\n     * Static string description\n     * ```typescript\n     * import type { InterruptOnConfig } from \"langchain\";\n     *\n     * const config: InterruptOnConfig = {\n     *   allowedDecisions: [\"approve\", \"reject\"],\n     *   description: \"Please review this tool execution\"\n     * };\n     * ```\n     *\n     * @example\n     * Dynamic callable description\n     * ```typescript\n     * import type {\n     *   AgentBuiltInState,\n     *   Runtime,\n     *   DescriptionFactory,\n     *   ToolCall,\n     *   InterruptOnConfig\n     * } from \"langchain\";\n     *\n     * const formatToolDescription: DescriptionFactory = (\n     *   toolCall: ToolCall,\n     *   state: AgentBuiltInState,\n     *   runtime: Runtime<unknown>\n     * ) => {\n     *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n     * };\n     *\n     * const config: InterruptOnConfig = {\n     *   allowedDecisions: [\"approve\", \"edit\"],\n     *   description: formatToolDescription\n     * };\n     * ```\n     */\n    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n    /**\n     * JSON schema for the arguments associated with the action, if edits are allowed.\n     */\n    argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n}, \"strip\", z.ZodTypeAny, {\n    allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n    description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n    argsSchema?: Record<string, any> | undefined;\n}, {\n    allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n    description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n    argsSchema?: Record<string, any> | undefined;\n}>;\nexport type InterruptOnConfig = z.input<typeof InterruptOnConfigSchema>;\n/**\n * Represents an action with a name and arguments.\n */\nexport interface Action {\n    /**\n     * The type or name of action being requested (e.g., \"add_numbers\").\n     */\n    name: string;\n    /**\n     * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n     */\n    args: Record<string, any>;\n}\n/**\n * Represents an action request with a name, arguments, and description.\n */\nexport interface ActionRequest {\n    /**\n     * The name of the action being requested.\n     */\n    name: string;\n    /**\n     * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n     */\n    args: Record<string, any>;\n    /**\n     * The description of the action to be reviewed.\n     */\n    description?: string;\n}\n/**\n * Policy for reviewing a HITL request.\n */\nexport interface ReviewConfig {\n    /**\n     * Name of the action associated with this review configuration.\n     */\n    actionName: string;\n    /**\n     * The decisions that are allowed for this request.\n     */\n    allowedDecisions: DecisionType[];\n    /**\n     * JSON schema for the arguments associated with the action, if edits are allowed.\n     */\n    argsSchema?: Record<string, any>;\n}\n/**\n * Request for human feedback on a sequence of actions requested by a model.\n *\n * @example\n * ```ts\n * const hitlRequest: HITLRequest = {\n *   actionRequests: [\n *     { name: \"send_email\", args: { to: \"user@example.com\", subject: \"Hello\" } }\n *   ],\n *   reviewConfigs: [\n *     {\n *       actionName: \"send_email\",\n *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\n *       description: \"Please review the email before sending\"\n *     }\n *   ]\n * };\n * const response = interrupt(hitlRequest);\n * ```\n */\nexport interface HITLRequest {\n    /**\n     * A list of agent actions for human review.\n     */\n    actionRequests: ActionRequest[];\n    /**\n     * Review configuration for all possible actions.\n     */\n    reviewConfigs: ReviewConfig[];\n}\n/**\n * Response when a human approves the action.\n */\nexport interface ApproveDecision {\n    type: \"approve\";\n}\n/**\n * Response when a human edits the action.\n */\nexport interface EditDecision {\n    type: \"edit\";\n    /**\n     * Edited action for the agent to perform.\n     * Ex: for a tool call, a human reviewer can edit the tool name and args.\n     */\n    editedAction: Action;\n}\n/**\n * Response when a human rejects the action.\n */\nexport interface RejectDecision {\n    type: \"reject\";\n    /**\n     * The message sent to the model explaining why the action was rejected.\n     */\n    message?: string;\n}\n/**\n * Union of all possible decision types.\n */\nexport type Decision = ApproveDecision | EditDecision | RejectDecision;\n/**\n * Response payload for a HITLRequest.\n */\nexport interface HITLResponse {\n    /**\n     * The decisions made by the human.\n     */\n    decisions: Decision[];\n}\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * Mapping of tool name to allowed reviewer responses.\n     * If a tool doesn't have an entry, it's auto-approved by default.\n     *\n     * - `true` -> pause for approval and allow approve/edit/reject decisions\n     * - `false` -> auto-approve (no human review)\n     * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * The decisions that are allowed for this action.\n         */\n        allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n        /**\n         * The description attached to the request for human input.\n         * Can be either:\n         * - A static string describing the approval request\n         * - A callable that dynamically generates the description based on agent state,\n         *   runtime, and tool call information\n         *\n         * @example\n         * Static string description\n         * ```typescript\n         * import type { InterruptOnConfig } from \"langchain\";\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"reject\"],\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * import type {\n         *   AgentBuiltInState,\n         *   Runtime,\n         *   DescriptionFactory,\n         *   ToolCall,\n         *   InterruptOnConfig\n         * } from \"langchain\";\n         *\n         * const formatToolDescription: DescriptionFactory = (\n         *   toolCall: ToolCall,\n         *   state: AgentBuiltInState,\n         *   runtime: Runtime<unknown>\n         * ) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"edit\"],\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n        /**\n         * JSON schema for the arguments associated with the action, if edits are allowed.\n         */\n        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }>]>>>;\n    /**\n     * Prefix used when constructing human-facing approval messages.\n     * Provides context about the tool call being reviewed; does not change the underlying action.\n     *\n     * Note: This prefix is only applied for tools that do not provide a custom\n     * `description` via their {@link InterruptOnConfig}. If a tool specifies a custom\n     * `description`, that per-tool text is used and this prefix is ignored.\n     */\n    descriptionPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>;\nexport type HumanInTheLoopMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;\n/**\n * Creates a Human-in-the-Loop (HITL) middleware for tool approval and oversight.\n *\n * This middleware intercepts tool calls made by an AI agent and provides human oversight\n * capabilities before execution. It enables selective approval workflows where certain tools\n * require human intervention while others can execute automatically.\n *\n * A invocation result that has been interrupted by the middleware will have a `__interrupt__`\n * property that contains the interrupt request.\n *\n * ```ts\n * import { type HITLRequest, type HITLResponse } from \"langchain\";\n * import { type Interrupt } from \"langchain\";\n *\n * const result = await agent.invoke(request);\n * const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n * // Examine the action requests and review configs\n * const actionRequests = interruptRequest.value.actionRequests;\n * const reviewConfigs = interruptRequest.value.reviewConfigs;\n *\n * // Create decisions for each action\n * const resume: HITLResponse = {\n *   decisions: actionRequests.map((action, i) => {\n *     if (action.name === \"calculator\") {\n *       return { type: \"approve\" };\n *     } else if (action.name === \"write_file\") {\n *       return {\n *         type: \"edit\",\n *         editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Safe content\" } }\n *       };\n *     }\n *     return { type: \"reject\", message: \"Action not allowed\" };\n *   })\n * };\n *\n * // Resume with decisions\n * await agent.invoke(new Command({ resume }), config);\n * ```\n *\n * ## Features\n *\n * - **Selective Tool Approval**: Configure which tools require human approval\n * - **Multiple Decision Types**: Approve, edit, or reject tool calls\n * - **Asynchronous Workflow**: Uses LangGraph's interrupt mechanism for non-blocking approval\n * - **Custom Approval Messages**: Provide context-specific descriptions for approval requests\n *\n * ## Decision Types\n *\n * When a tool requires approval, the human operator can respond with:\n * - `approve`: Execute the tool with original arguments\n * - `edit`: Modify the tool name and/or arguments before execution\n * - `reject`: Provide a manual response instead of executing the tool\n *\n * @param options - Configuration options for the middleware\n * @param options.interruptOn - Per-tool configuration mapping tool names to their settings\n * @param options.interruptOn[toolName].allowedDecisions - Array of decision types allowed for this tool (e.g., [\"approve\", \"edit\", \"reject\"])\n * @param options.interruptOn[toolName].description - Custom approval message for the tool. Can be either a static string or a callable that dynamically generates the description based on agent state, runtime, and tool call information\n * @param options.interruptOn[toolName].argsSchema - JSON schema for the arguments associated with the action, if edits are allowed\n * @param options.descriptionPrefix - Default prefix for approval messages (default: \"Tool execution requires approval\"). Only used for tools that do not define a custom `description` in their InterruptOnConfig.\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @example\n * Basic usage with selective tool approval\n * ```typescript\n * import { humanInTheLoopMiddleware } from \"langchain\";\n * import { createAgent } from \"langchain\";\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     // Interrupt write_file tool and allow edits or approvals\n *     \"write_file\": {\n *       allowedDecisions: [\"approve\", \"edit\"],\n *       description: \"⚠️ File write operation requires approval\"\n *     },\n *     // Auto-approve read_file tool\n *     \"read_file\": false\n *   }\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4\",\n *   tools: [writeFileTool, readFileTool],\n *   middleware: [hitlMiddleware]\n * });\n * ```\n *\n * @example\n * Handling approval requests\n * ```typescript\n * import { type HITLRequest, type HITLResponse, type Interrupt } from \"langchain\";\n * import { Command } from \"@langchain/langgraph\";\n *\n * // Initial agent invocation\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Write 'Hello' to output.txt\")]\n * }, config);\n *\n * // Check if agent is paused for approval\n * if (result.__interrupt__) {\n *   const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n *   // Show tool call details to user\n *   console.log(\"Actions:\", interruptRequest.value.actionRequests);\n *   console.log(\"Review configs:\", interruptRequest.value.reviewConfigs);\n *\n *   // Resume with approval\n *   const resume: HITLResponse = {\n *     decisions: [{ type: \"approve\" }]\n *   };\n *   await agent.invoke(\n *     new Command({ resume }),\n *     config\n *   );\n * }\n * ```\n *\n * @example\n * Different decision types\n * ```typescript\n * import { type HITLResponse } from \"langchain\";\n *\n * // Approve the tool call as-is\n * const resume: HITLResponse = {\n *   decisions: [{ type: \"approve\" }]\n * };\n *\n * // Edit the tool arguments\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"edit\",\n *     editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Modified\" } }\n *   }]\n * };\n *\n * // Reject with feedback\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"reject\",\n *     message: \"File operation not allowed in demo mode\"\n *   }]\n * };\n * ```\n *\n * @example\n * Production use case with database operations\n * ```typescript\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     \"execute_sql\": {\n *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\n *       description: \"🚨 SQL query requires DBA approval\\nPlease review for safety and performance\"\n *     },\n *     \"read_schema\": false,  // Reading metadata is safe\n *     \"delete_records\": {\n *       allowedDecisions: [\"approve\", \"reject\"],\n *       description: \"⛔ DESTRUCTIVE OPERATION - Requires manager approval\"\n *     }\n *   },\n *   descriptionPrefix: \"Database operation pending approval\"\n * });\n * ```\n *\n * @example\n * Using dynamic callable descriptions\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n * import type { AgentBuiltInState, Runtime } from \"langchain/agents\";\n *\n * // Define a dynamic description factory\n * const formatToolDescription: DescriptionFactory = (\n *   toolCall: ToolCall,\n *   state: AgentBuiltInState,\n *   runtime: Runtime<unknown>\n * ) => {\n *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n * };\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     \"write_file\": {\n *       allowedDecisions: [\"approve\", \"edit\"],\n *       // Use dynamic description that can access tool call, state, and runtime\n *       description: formatToolDescription\n *     },\n *     // Or use an inline function\n *     \"send_email\": {\n *       allowedDecisions: [\"approve\", \"reject\"],\n *       description: (toolCall, state, runtime) => {\n *         const { to, subject } = toolCall.args;\n *         return `Email to ${to}\\nSubject: ${subject}\\n\\nRequires approval before sending`;\n *       }\n *     }\n *   }\n * });\n * ```\n *\n * @remarks\n * - Tool calls are processed in the order they appear in the AI message\n * - Auto-approved tools execute immediately without interruption\n * - Multiple tools requiring approval are bundled into a single interrupt request\n * - The middleware operates in the `afterModel` phase, intercepting before tool execution\n * - Requires a checkpointer to maintain state across interruptions\n *\n * @see {@link createAgent} for agent creation\n * @see {@link Command} for resuming interrupted execution\n * @public\n */\nexport declare function humanInTheLoopMiddleware(options: NonNullable<HumanInTheLoopMiddlewareConfig>): import(\"./types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    /**\n     * Mapping of tool name to allowed reviewer responses.\n     * If a tool doesn't have an entry, it's auto-approved by default.\n     *\n     * - `true` -> pause for approval and allow approve/edit/reject decisions\n     * - `false` -> auto-approve (no human review)\n     * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * The decisions that are allowed for this action.\n         */\n        allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\n        /**\n         * The description attached to the request for human input.\n         * Can be either:\n         * - A static string describing the approval request\n         * - A callable that dynamically generates the description based on agent state,\n         *   runtime, and tool call information\n         *\n         * @example\n         * Static string description\n         * ```typescript\n         * import type { InterruptOnConfig } from \"langchain\";\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"reject\"],\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * import type {\n         *   AgentBuiltInState,\n         *   Runtime,\n         *   DescriptionFactory,\n         *   ToolCall,\n         *   InterruptOnConfig\n         * } from \"langchain\";\n         *\n         * const formatToolDescription: DescriptionFactory = (\n         *   toolCall: ToolCall,\n         *   state: AgentBuiltInState,\n         *   runtime: Runtime<unknown>\n         * ) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"edit\"],\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n        /**\n         * JSON schema for the arguments associated with the action, if edits are allowed.\n         */\n        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }>]>>>;\n    /**\n     * Prefix used when constructing human-facing approval messages.\n     * Provides context about the tool call being reviewed; does not change the underlying action.\n     *\n     * Note: This prefix is only applied for tools that do not provide a custom\n     * `description` via their {@link InterruptOnConfig}. If a tool specifies a custom\n     * `description`, that per-tool text is used and this prefix is ignored.\n     */\n    descriptionPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, readonly (import(\"@langchain/core/tools\").ServerTool | import(\"@langchain/core/tools\").ClientTool)[]>;\nexport {};\n//# sourceMappingURL=hitl.d.ts.map"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"responses.d.cts","names":["InteropZodObject","InteropZodType","AIMessage","LanguageModelLike","FunctionDefinition","StructuredOutputParsingError","MultipleStructuredOutputsError","ResponseFormatUndefined","ToolStrategy","S","_T","Record","ToolStrategyOptions","U","ProviderStrategy","T","ResponseFormat","transformResponseFormat","JsonSchemaFormat","TypedToolStrategy","Array","ToolStrategyError","Promise","toolStrategy","K","providerStrategy","hasSupportForJsonSchemaOutput"],"sources":["../../src/agents/responses.d.ts"],"sourcesContent":["import { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport { type AIMessage } from \"@langchain/core/messages\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { type FunctionDefinition } from \"@langchain/core/language_models/base\";\nimport { StructuredOutputParsingError, MultipleStructuredOutputsError } from \"./errors.js\";\n/**\n * Special type to indicate that no response format is provided.\n * When this type is used, the structuredResponse property should not be present in the result.\n */\nexport type ResponseFormatUndefined = {\n    __responseFormatUndefined: true;\n};\n/**\n * Information for tracking structured output tool metadata.\n * This contains all necessary information to handle structured responses generated\n * via tool calls, including the original schema, its type classification, and the\n * corresponding tool implementation used by the tools strategy.\n */\nexport declare class ToolStrategy<_T = unknown> {\n    /**\n     * The original JSON Schema provided for structured output\n     */\n    readonly schema: Record<string, unknown>;\n    /**\n     * The tool that will be used to parse the tool call arguments.\n     */\n    readonly tool: {\n        type: \"function\";\n        function: FunctionDefinition;\n    };\n    /**\n     * The options to use for the tool output.\n     */\n    readonly options?: ToolStrategyOptions | undefined;\n    private constructor();\n    get name(): string;\n    static fromSchema<S extends InteropZodObject>(schema: S, outputOptions?: ToolStrategyOptions): ToolStrategy<S extends InteropZodType<infer U> ? U : unknown>;\n    static fromSchema(schema: Record<string, unknown>, outputOptions?: ToolStrategyOptions): ToolStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema.\n     *\n     * @throws {StructuredOutputParsingError} if the response is not valid\n     * @param toolArgs - The arguments from the tool call\n     * @returns The parsed response according to the schema type\n     */\n    parse(toolArgs: Record<string, unknown>): Record<string, unknown>;\n}\nexport declare class ProviderStrategy<T = unknown> {\n    private _schemaType?;\n    /**\n     * The schema to use for the provider strategy\n     */\n    readonly schema: Record<string, unknown>;\n    /**\n     * Whether to use strict mode for the provider strategy\n     */\n    readonly strict: boolean;\n    private constructor();\n    private constructor();\n    static fromSchema<T>(schema: InteropZodType<T>, strict?: boolean): ProviderStrategy<T>;\n    static fromSchema(schema: Record<string, unknown>, strict?: boolean): ProviderStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema. If the response is not valid, return undefined.\n     *\n     * @param response - The AI message response to parse\n     * @returns The parsed response according to the schema type\n     */\n    parse(response: AIMessage): any;\n}\nexport type ResponseFormat = ToolStrategy<any> | ProviderStrategy<any>;\n/**\n * Handle user input for `responseFormat` parameter of `CreateAgentParams`.\n * This function defines the default behavior for the `responseFormat` parameter, which is:\n *\n * - if value is a Zod schema, default to structured output via tool calling\n * - if value is a JSON schema, default to structured output via tool calling\n * - if value is a custom response format, return it as is\n * - if value is an array, ensure all array elements are instance of `ToolStrategy`\n * @param responseFormat - The response format to transform, provided by the user\n * @param options - The response format options for tool strategy\n * @param model - The model to check if it supports JSON schema output\n * @returns\n */\nexport declare function transformResponseFormat(responseFormat?: InteropZodType<any> | InteropZodType<any>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | ToolStrategy<any>[] | ResponseFormatUndefined, options?: ToolStrategyOptions, model?: LanguageModelLike | string): ResponseFormat[];\n/**\n * Branded type for ToolStrategy arrays that preserves type information\n */\nexport interface TypedToolStrategy<T = unknown> extends Array<ToolStrategy<any>> {\n    _schemaType?: T;\n}\nexport type ToolStrategyError = StructuredOutputParsingError | MultipleStructuredOutputsError;\nexport interface ToolStrategyOptions {\n    /**\n     * Allows you to customize the message that appears in the conversation history when structured\n     * output is generated.\n     */\n    toolMessageContent?: string;\n    /**\n     * Handle errors from the structured output tool call. Using tools to generate structured output\n     * can cause errors, e.g. if:\n     * - you provide multiple structured output schemas and the model calls multiple structured output tools\n     * - if the structured output generated by the tool call doesn't match provided schema\n     *\n     * This property allows to handle these errors in different ways:\n     * - `true` - retry the tool call\n     * - `false` - throw an error\n     * - `string` - retry the tool call with the provided message\n     * - `(error: ToolStrategyError) => Promise<string> | string` - retry with the provided message or throw the error\n     *\n     * @default true\n     */\n    handleError?: boolean | string | ((error: ToolStrategyError) => Promise<string> | string);\n}\nexport declare function toolStrategy<T extends InteropZodType<any>>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function toolStrategy<T extends readonly InteropZodType<any>[]>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<{\n    [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never;\n}[number]>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\n/**\n * Creates a provider strategy for structured output using native JSON schema support.\n *\n * This function is used to configure structured output for agents when the underlying model\n * supports native JSON schema output (e.g., OpenAI's `gpt-4o`, `gpt-4o-mini`, and newer models).\n * Unlike `toolStrategy`, which uses function calling to extract structured output, `providerStrategy`\n * leverages the provider's native structured output capabilities, resulting in more efficient\n * and reliable schema enforcement.\n *\n * When used with a model that supports JSON schema output, the model will return responses\n * that directly conform to the provided schema without requiring tool calls. This is the\n * recommended approach for structured output when your model supports it.\n *\n * @param responseFormat - The schema to enforce, either a Zod schema, a JSON schema object, or an options object with `schema` and optional `strict` flag\n * @returns A `ProviderStrategy` instance that can be used as the `responseFormat` in `createAgent`\n *\n * @example\n * ```ts\n * import { providerStrategy, createAgent } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy(\n *     z.object({\n *       answer: z.string().describe(\"The answer to the question\"),\n *       confidence: z.number().min(0).max(1),\n *     })\n *   ),\n * });\n * ```\n *\n * @example\n * ```ts\n * // Using strict mode for stricter schema enforcement\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy({\n *     schema: z.object({\n *       name: z.string(),\n *       age: z.number(),\n *     }),\n *     strict: true\n *   }),\n * });\n * ```\n */\nexport declare function providerStrategy<T extends InteropZodType<unknown>>(responseFormat: T | {\n    schema: T;\n    strict?: boolean;\n}): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function providerStrategy(responseFormat: JsonSchemaFormat | {\n    schema: JsonSchemaFormat;\n    strict?: boolean;\n}): ProviderStrategy<Record<string, unknown>>;\n/**\n * Type representing a JSON Schema object format.\n * This is a strict type that excludes ToolStrategy and ProviderStrategy instances.\n */\nexport type JsonSchemaFormat = {\n    type: \"null\" | \"boolean\" | \"object\" | \"array\" | \"number\" | \"string\" | \"integer\";\n    properties?: Record<string, unknown>;\n    required?: string[];\n    additionalProperties?: boolean;\n    [key: string]: unknown;\n} & {\n    __brand?: never;\n};\n/**\n * Identifies the models that support JSON schema output\n * @param model - The model to check\n * @returns True if the model supports JSON schema output, false otherwise\n */\nexport declare function hasSupportForJsonSchemaOutput(model?: LanguageModelLike | string): boolean;\n//# sourceMappingURL=responses.d.ts.map"],"mappings":"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"}
+{"version":3,"file":"responses.d.cts","names":["InteropZodObject","InteropZodType","AIMessage","LanguageModelLike","FunctionDefinition","StructuredOutputParsingError","MultipleStructuredOutputsError","ResponseFormatUndefined","ToolStrategy","S","_T","Record","ToolStrategyOptions","U","ProviderStrategy","T","ResponseFormat","transformResponseFormat","JsonSchemaFormat","TypedToolStrategy","Array","ToolStrategyError","Promise","toolStrategy","K","providerStrategy","hasSupportForJsonSchemaOutput"],"sources":["../../src/agents/responses.d.ts"],"sourcesContent":["import { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport { type AIMessage } from \"@langchain/core/messages\";\nimport { type LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { type FunctionDefinition } from \"@langchain/core/language_models/base\";\nimport { StructuredOutputParsingError, MultipleStructuredOutputsError } from \"./errors.js\";\n/**\n * Special type to indicate that no response format is provided.\n * When this type is used, the structuredResponse property should not be present in the result.\n */\nexport type ResponseFormatUndefined = {\n    __responseFormatUndefined: true;\n};\n/**\n * Information for tracking structured output tool metadata.\n * This contains all necessary information to handle structured responses generated\n * via tool calls, including the original schema, its type classification, and the\n * corresponding tool implementation used by the tools strategy.\n */\nexport declare class ToolStrategy<_T = unknown> {\n    /**\n     * The original JSON Schema provided for structured output\n     */\n    readonly schema: Record<string, unknown>;\n    /**\n     * The tool that will be used to parse the tool call arguments.\n     */\n    readonly tool: {\n        type: \"function\";\n        function: FunctionDefinition;\n    };\n    /**\n     * The options to use for the tool output.\n     */\n    readonly options?: ToolStrategyOptions | undefined;\n    private constructor();\n    get name(): string;\n    static fromSchema<S extends InteropZodObject>(schema: S, outputOptions?: ToolStrategyOptions): ToolStrategy<S extends InteropZodType<infer U> ? U : unknown>;\n    static fromSchema(schema: Record<string, unknown>, outputOptions?: ToolStrategyOptions): ToolStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema.\n     *\n     * @throws {StructuredOutputParsingError} if the response is not valid\n     * @param toolArgs - The arguments from the tool call\n     * @returns The parsed response according to the schema type\n     */\n    parse(toolArgs: Record<string, unknown>): Record<string, unknown>;\n}\nexport declare class ProviderStrategy<T = unknown> {\n    private _schemaType?;\n    /**\n     * The schema to use for the provider strategy\n     */\n    readonly schema: Record<string, unknown>;\n    /**\n     * Whether to use strict mode for the provider strategy\n     */\n    readonly strict: boolean;\n    private constructor();\n    private constructor();\n    static fromSchema<T>(schema: InteropZodType<T>, strict?: boolean): ProviderStrategy<T>;\n    static fromSchema(schema: Record<string, unknown>, strict?: boolean): ProviderStrategy<Record<string, unknown>>;\n    /**\n     * Parse tool arguments according to the schema. If the response is not valid, return undefined.\n     *\n     * @param response - The AI message response to parse\n     * @returns The parsed response according to the schema type\n     */\n    parse(response: AIMessage): any;\n}\nexport type ResponseFormat = ToolStrategy<any> | ProviderStrategy<any>;\n/**\n * Handle user input for `responseFormat` parameter of `CreateAgentParams`.\n * This function defines the default behavior for the `responseFormat` parameter, which is:\n *\n * - if value is a Zod schema, default to structured output via tool calling\n * - if value is a JSON schema, default to structured output via tool calling\n * - if value is a custom response format, return it as is\n * - if value is an array, ensure all array elements are instance of `ToolStrategy`\n * @param responseFormat - The response format to transform, provided by the user\n * @param options - The response format options for tool strategy\n * @param model - The model to check if it supports JSON schema output\n * @returns\n */\nexport declare function transformResponseFormat(responseFormat?: InteropZodType<any> | InteropZodType<any>[] | JsonSchemaFormat | JsonSchemaFormat[] | ResponseFormat | ToolStrategy<any>[] | ResponseFormatUndefined, options?: ToolStrategyOptions, model?: LanguageModelLike | string): ResponseFormat[];\n/**\n * Branded type for ToolStrategy arrays that preserves type information\n */\nexport interface TypedToolStrategy<T = unknown> extends Array<ToolStrategy<any>> {\n    _schemaType?: T;\n}\nexport type ToolStrategyError = StructuredOutputParsingError | MultipleStructuredOutputsError;\nexport interface ToolStrategyOptions {\n    /**\n     * Allows you to customize the message that appears in the conversation history when structured\n     * output is generated.\n     */\n    toolMessageContent?: string;\n    /**\n     * Handle errors from the structured output tool call. Using tools to generate structured output\n     * can cause errors, e.g. if:\n     * - you provide multiple structured output schemas and the model calls multiple structured output tools\n     * - if the structured output generated by the tool call doesn't match provided schema\n     *\n     * This property allows to handle these errors in different ways:\n     * - `true` - retry the tool call\n     * - `false` - throw an error\n     * - `string` - retry the tool call with the provided message\n     * - `(error: ToolStrategyError) => Promise<string> | string` - retry with the provided message or throw the error\n     *\n     * @default true\n     */\n    handleError?: boolean | string | ((error: ToolStrategyError) => Promise<string> | string);\n}\nexport declare function toolStrategy<T extends InteropZodType<any>>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function toolStrategy<T extends readonly InteropZodType<any>[]>(responseFormat: T, options?: ToolStrategyOptions): TypedToolStrategy<{\n    [K in keyof T]: T[K] extends InteropZodType<infer U> ? U : never;\n}[number]>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat, options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\nexport declare function toolStrategy(responseFormat: JsonSchemaFormat[], options?: ToolStrategyOptions): TypedToolStrategy<Record<string, unknown>>;\n/**\n * Creates a provider strategy for structured output using native JSON schema support.\n *\n * This function is used to configure structured output for agents when the underlying model\n * supports native JSON schema output (e.g., OpenAI's `gpt-4o`, `gpt-4o-mini`, and newer models).\n * Unlike `toolStrategy`, which uses function calling to extract structured output, `providerStrategy`\n * leverages the provider's native structured output capabilities, resulting in more efficient\n * and reliable schema enforcement.\n *\n * When used with a model that supports JSON schema output, the model will return responses\n * that directly conform to the provided schema without requiring tool calls. This is the\n * recommended approach for structured output when your model supports it.\n *\n * @param responseFormat - The schema to enforce, either a Zod schema, a JSON schema object, or an options object with `schema` and optional `strict` flag\n * @returns A `ProviderStrategy` instance that can be used as the `responseFormat` in `createAgent`\n *\n * @example\n * ```ts\n * import { providerStrategy, createAgent } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy(\n *     z.object({\n *       answer: z.string().describe(\"The answer to the question\"),\n *       confidence: z.number().min(0).max(1),\n *     })\n *   ),\n * });\n * ```\n *\n * @example\n * ```ts\n * // Using strict mode for stricter schema enforcement\n * const agent = createAgent({\n *   model: \"claude-haiku-4-5\",\n *   responseFormat: providerStrategy({\n *     schema: z.object({\n *       name: z.string(),\n *       age: z.number(),\n *     }),\n *     strict: true\n *   }),\n * });\n * ```\n */\nexport declare function providerStrategy<T extends InteropZodType<unknown>>(responseFormat: T | {\n    schema: T;\n    strict?: boolean;\n}): ProviderStrategy<T extends InteropZodType<infer U> ? U : never>;\nexport declare function providerStrategy(responseFormat: JsonSchemaFormat | {\n    schema: JsonSchemaFormat;\n    strict?: boolean;\n}): ProviderStrategy<Record<string, unknown>>;\n/**\n * Type representing a JSON Schema object format.\n * This is a strict type that excludes ToolStrategy and ProviderStrategy instances.\n */\nexport type JsonSchemaFormat = {\n    type: \"null\" | \"boolean\" | \"object\" | \"array\" | \"number\" | \"string\" | \"integer\";\n    properties?: Record<string, unknown>;\n    required?: string[];\n    additionalProperties?: boolean;\n    [key: string]: unknown;\n} & {\n    __brand?: never;\n};\n/**\n * Identifies the models that support JSON schema output\n * @param model - The model to check\n * @returns True if the model supports JSON schema output, false otherwise\n */\nexport declare function hasSupportForJsonSchemaOutput(model?: LanguageModelLike | string): boolean;\n//# sourceMappingURL=responses.d.ts.map"],"mappings":";;;;;;;;AASA;AASA;;AAUkBI,KAnBNG,uBAAAA,GAmBMH;EAKKQ,yBAAAA,EAAAA,IAAAA;CAGSZ;;;;;;;AACFW,cAnBTH,YAmBSG,CAAAA,KAAAA,OAAAA,CAAAA,CAAAA;EAAyCC;;;EAQnDD,SAAAA,MAAAA,EAvBCA,MAuBDA,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;EAA0BA;AAAM;AAEpD;EAKqBA,SAAAA,IAAAA,EAAAA;IAO2BI,IAAAA,EAAAA,UAAAA;IAAfd,QAAAA,EA/BfG,kBA+BeH;EAAuDc,CAAAA;EAAjBD;;;EACGA,SAAAA,OAAAA,CAAAA,EA3BnDF,mBA2BmDE,GAAAA,SAAAA;EAOtDZ,QAAAA,WAAAA,CAAAA;EAAS,IAAA,IAAA,CAAA,CAAA,EAAA,MAAA;EAEjBc,OAAAA,UAAc,CAAA,UAjCMhB,gBAiCiBc,CAAAA,CAAAA,MAAAA,EAjCSL,CAiCTK,EAAAA,aAAgB,CAAA,EAjCYF,mBAiCZ,CAAA,EAjCkCJ,YAiClC,CAjC+CC,CAiC/C,SAjCyDR,cAiCzD,CAAA,KAAA,EAAA,CAAA,GAjCmFY,CAiCnF,GAAA,OAAA,CAAA;EAkBhDM,OAAAA,UAAAA,CAAAA,MAAiB,EAlDJR,MAkDII,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,aAAA,CAAA,EAlDqCH,mBAkDrC,CAAA,EAlD2DJ,YAkD3D,CAlDwEG,MAkDxE,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA;EAA4BH;;;AAAD;AAG7D;AACA;AAsBA;EAA+CP,KAAAA,CAAAA,QAAAA,EApE3BU,MAoE2BV,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,CAAAA,EApEDU,MAoECV,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;;AAAkDW,cAlE5EE,gBAkE4EF,CAAAA,IAAAA,OAAAA,CAAAA,CAAAA;EAAwCG,QAAAA,WAAAA;EAAUd;;;EAAX,SAAA,MAAA,EA7DnHU,MA6DmH,CAAA,MAAA,EAAA,OAAA,CAAA;EAChHY;;;EAAoFX,SAAAA,MAAAA,EAAAA,OAAAA;EAC5FG,QAAAA,WAAAA,CAAAA;EAAIA,QAAAA,WAAAA,CAAAA;EAAES,OAAAA,UAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAxDWvB,cAwDXuB,CAxD0BT,CAwD1BS,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA,OAAAA,CAAAA,EAxDiDV,gBAwDjDU,CAxDkET,CAwDlES,CAAAA;EAAWvB,OAAAA,UAAAA,CAAAA,MAAAA,EAvDHU,MAuDGV,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA,OAAAA,CAAAA,EAvDyCa,gBAuDzCb,CAvD0DU,MAuD1DV,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,CAAAA;EAA0BY;;AADwF;AAGnJ;;;EAAyHF,KAAAA,CAAAA,QAAAA,EAlDrGT,SAkDqGS,CAAAA,EAAAA,GAAAA;;AAAD,KAhD5GK,cAAAA,GAAiBR,YAgD2F,CAAA,GAAA,CAAA,GAhDvEM,gBAgDuE,CAAA,GAAA,CAAA;AAoDpG;AACpB;;AACYI,UApFKC,iBAoFLD,CAAAA,IAAAA,OAAAA,CAAAA,SApF4CE,KAoF5CF,CApFkDV,YAoFlDU,CAAAA,GAAAA,CAAAA,CAAAA,CAAAA;EAESP,WAAAA,CAAAA,EArFHI,CAqFGJ;;AAAD,KAnFRU,iBAAAA,GAAoBhB,4BAmFZ,GAnF2CC,8BAmF3C;AAKRY,UAvFKN,mBAAAA,CAyFAD;;;;;;;;;;;;;;;;;;;;4CArE6BU,sBAAsBC;;iBAE5CC,uBAAuBtB,qCAAqCc,aAAaH,sBAAsBO,kBAAkBJ,UAAUd,0BAA0BY;iBACrJU,gCAAgCtB,uCAAuCc,aAAaH,sBAAsBO,gCAClHJ,IAAIA,EAAES,WAAWvB,0BAA0BY;iBAEnCU,YAAAA,iBAA6BL,4BAA4BN,sBAAsBO,kBAAkBR;iBACjGY,YAAAA,iBAA6BL,8BAA8BN,sBAAsBO,kBAAkBR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDnGc,2BAA2BxB,yCAAyCc;UAChFA;;IAERD,iBAAiBC,UAAUd,0BAA0BY;iBACjCY,gBAAAA,iBAAiCP;UAC7CA;;IAERJ,iBAAiBH;;;;;KAKTO,gBAAAA;;eAEKP"}