langchain 1.5.15 → 1.5.17

package/dist/agents/middleware/provider/openai/moderation.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"moderation.d.cts","names":[],"sources":["../../../../../src/agents/middleware/provider/openai/moderation.ts"],"mappings":";;;KA6FK;;;;UAsCY;;;;;;;;;;;;;;;;;;;;;EAqBf,gBAAgB;;;;;EAMhB,kBAAkB;;;;;EAMlB;;;;;EAMA;;;;;EAMA;;;;;;;;EASA;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+Dc,2BACd,SAAS,oCACR"}
+{"version":3,"file":"moderation.d.cts","names":[],"sources":["../../../../../src/agents/middleware/provider/openai/moderation.ts"],"mappings":";;;KA6FK;;;;iBAsCY;;;;;;;;;;;;;;;;;;;;;EAqBf,gBAAgB;;;;;EAMhB,kBAAkB;;;;;EAMlB;;;;;EAMA;;;;;EAMA;;;;;;;;EASA;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+Dc,2BACd,SAAS,oCACR"}

package/dist/agents/middleware/provider/openai/moderation.d.ts

@@ -5,7 +5,7 @@ type ModerationModel = "omni-moderation-latest" | "omni-moderation-2024-09-26" |
 /**
  * Options for configuring the OpenAI Moderation middleware.
  */
-interface OpenAIModerationMiddlewareOptions {
+export interface OpenAIModerationMiddlewareOptions {
   /**
    * OpenAI model to use for moderation. Can be either a model name or a BaseChatModel instance.
    * @example
@@ -121,7 +121,6 @@ interface OpenAIModerationMiddlewareOptions {
  * });
  * ```
  */
-declare function openAIModerationMiddleware(options: OpenAIModerationMiddlewareOptions): AgentMiddleware;
+export declare function openAIModerationMiddleware(options: OpenAIModerationMiddlewareOptions): AgentMiddleware;
 //#endregion
-export { OpenAIModerationMiddlewareOptions, openAIModerationMiddleware };
 //# sourceMappingURL=moderation.d.ts.map

package/dist/agents/middleware/provider/openai/moderation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"moderation.d.ts","names":[],"sources":["../../../../../src/agents/middleware/provider/openai/moderation.ts"],"mappings":";;;KA6FK;;;;UAsCY;;;;;;;;;;;;;;;;;;;;;EAqBf,gBAAgB;;;;;EAMhB,kBAAkB;;;;;EAMlB;;;;;EAMA;;;;;EAMA;;;;;;;;EASA;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+Dc,2BACd,SAAS,oCACR"}
+{"version":3,"file":"moderation.d.ts","names":[],"sources":["../../../../../src/agents/middleware/provider/openai/moderation.ts"],"mappings":";;;KA6FK;;;;iBAsCY;;;;;;;;;;;;;;;;;;;;;EAqBf,gBAAgB;;;;;EAMhB,kBAAkB;;;;;EAMlB;;;;;EAMA;;;;;EAMA;;;;;;;;EASA;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+Dc,2BACd,SAAS,oCACR"}

package/dist/agents/middleware/providerToolSearch.d.cts

@@ -2,8 +2,8 @@ import { AgentMiddleware } from "./types.cjs";
 import { ClientTool, ServerTool, StructuredToolInterface } from "@langchain/core/tools";
 //#region src/agents/middleware/providerToolSearch.d.ts
 type ToolName = string;
-type ToolIdentifier = ToolName | StructuredToolInterface;
-type ProviderToolSearchMiddlewareConfig = {
+export type ToolIdentifier = ToolName | StructuredToolInterface;
+export type ProviderToolSearchMiddlewareConfig = {
   /**
    * Which tools are deferred; withheld from the model until its tool search surfaces them.
    *
@@ -68,7 +68,6 @@ type ProviderToolSearchMiddlewareConfig = {
  * @param config.searchableTools - Tools to defer behind tool search
  * @returns A middleware instance that can be used with `createAgent`
  */
-declare function providerToolSearchMiddleware(config?: ProviderToolSearchMiddlewareConfig): AgentMiddleware<undefined, undefined, unknown, readonly (ServerTool | ClientTool)[], readonly []>;
+export declare function providerToolSearchMiddleware(config?: ProviderToolSearchMiddlewareConfig): AgentMiddleware<undefined, undefined, unknown, readonly (ServerTool | ClientTool)[], readonly []>;
 //#endregion
-export { ProviderToolSearchMiddlewareConfig, ToolIdentifier, providerToolSearchMiddleware };
 //# sourceMappingURL=providerToolSearch.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"providerToolSearch.d.cts","names":[],"sources":["../../../src/agents/middleware/providerToolSearch.ts"],"mappings":";;;KAcK;KACO,iBAAiB,WAAW;KAE5B;;;;;;;;EAQV,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4EJ,6BACd,SAAQ,qCAAuC,yDAAA,aAAA"}
+{"version":3,"file":"providerToolSearch.d.cts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/providerToolSearch.ts"],"mappings":";;;KAcK;YACO,iBAAiB,WAAW;YAE5B;;;;;;;;EAQV,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA4EJ,6BACd,SAAQ,qCAAuCA,yDAAA,aAAA"}

package/dist/agents/middleware/providerToolSearch.d.ts

@@ -2,8 +2,8 @@ import { AgentMiddleware } from "./types.js";
 import { ClientTool, ServerTool, StructuredToolInterface } from "@langchain/core/tools";
 //#region src/agents/middleware/providerToolSearch.d.ts
 type ToolName = string;
-type ToolIdentifier = ToolName | StructuredToolInterface;
-type ProviderToolSearchMiddlewareConfig = {
+export type ToolIdentifier = ToolName | StructuredToolInterface;
+export type ProviderToolSearchMiddlewareConfig = {
   /**
    * Which tools are deferred; withheld from the model until its tool search surfaces them.
    *
@@ -68,7 +68,6 @@ type ProviderToolSearchMiddlewareConfig = {
  * @param config.searchableTools - Tools to defer behind tool search
  * @returns A middleware instance that can be used with `createAgent`
  */
-declare function providerToolSearchMiddleware(config?: ProviderToolSearchMiddlewareConfig): AgentMiddleware<undefined, undefined, unknown, readonly (ServerTool | ClientTool)[], readonly []>;
+export declare function providerToolSearchMiddleware(config?: ProviderToolSearchMiddlewareConfig): AgentMiddleware<undefined, undefined, unknown, readonly (ServerTool | ClientTool)[], readonly []>;
 //#endregion
-export { ProviderToolSearchMiddlewareConfig, ToolIdentifier, providerToolSearchMiddleware };
 //# sourceMappingURL=providerToolSearch.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"providerToolSearch.d.ts","names":[],"sources":["../../../src/agents/middleware/providerToolSearch.ts"],"mappings":";;;KAcK;KACO,iBAAiB,WAAW;KAE5B;;;;;;;;EAQV,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4EJ,6BACd,SAAQ,qCAAuC,yDAAA,aAAA"}
+{"version":3,"file":"providerToolSearch.d.ts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/providerToolSearch.ts"],"mappings":";;;KAcK;YACO,iBAAiB,WAAW;YAE5B;;;;;;;;EAQV,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA4EJ,6BACd,SAAQ,qCAAuCA,yDAAA,aAAA"}

package/dist/agents/middleware/summarization.d.cts

@@ -4,8 +4,8 @@ import { BaseLanguageModel } from "@langchain/core/language_models/base";
 import { InferInteropZodInput } from "@langchain/core/utils/types";
 import { z } from "zod/v3";
 //#region src/agents/middleware/summarization.d.ts
-type TokenCounter = (messages: BaseMessage[]) => number | Promise<number>;
-declare const contextSizeSchema: z.ZodEffects<z.ZodObject<{
+export type TokenCounter = (messages: BaseMessage[]) => number | Promise<number>;
+export declare const contextSizeSchema: z.ZodEffects<z.ZodObject<{
   /**
    * Fraction of the model's context size to use as the trigger
    */
@@ -35,8 +35,8 @@ declare const contextSizeSchema: z.ZodEffects<z.ZodObject<{
   tokens?: number | undefined;
   messages?: number | undefined;
 }>;
-type ContextSize = z.infer<typeof contextSizeSchema>;
-declare const keepSchema: z.ZodEffects<z.ZodObject<{
+export type ContextSize = z.infer<typeof contextSizeSchema>;
+export declare const keepSchema: z.ZodEffects<z.ZodObject<{
   /**
    * Fraction of the model's context size to keep
    */
@@ -63,7 +63,7 @@ declare const keepSchema: z.ZodEffects<z.ZodObject<{
   tokens?: number | undefined;
   messages?: number | undefined;
 }>;
-type KeepSize = z.infer<typeof keepSchema>;
+export type KeepSize = z.infer<typeof keepSchema>;
 declare const contextSchema: z.ZodObject<{
   /**
    * Model to use for summarization
@@ -244,7 +244,7 @@ declare const contextSchema: z.ZodObject<{
   maxTokensBeforeSummary?: number | undefined;
   messagesToKeep?: number | undefined;
 }>;
-type SummarizationMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;
+export type SummarizationMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;
 /**
  * Summarization middleware that automatically summarizes conversation history when token limits are approached.
  *
@@ -291,7 +291,7 @@ type SummarizationMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;
  *
  * ```
  */
-declare function summarizationMiddleware(options: SummarizationMiddlewareConfig): AgentMiddleware<undefined, z.ZodObject<{
+export declare function summarizationMiddleware(options: SummarizationMiddlewareConfig): AgentMiddleware<undefined, z.ZodObject<{
   trigger: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodObject<{
     /**
      * Fraction of the model's context size to use as the trigger
@@ -454,5 +454,4 @@ declare function summarizationMiddleware(options: SummarizationMiddlewareConfig)
   model?: BaseLanguageModel<any, import("@langchain/core/language_models/base").BaseLanguageModelCallOptions> | undefined;
 }, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>;
 //#endregion
-export { ContextSize, KeepSize, SummarizationMiddlewareConfig, TokenCounter, contextSizeSchema, keepSchema, summarizationMiddleware };
 //# sourceMappingURL=summarization.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"summarization.d.cts","names":[],"sources":["../../../src/agents/middleware/summarization.ts"],"mappings":";;;;;;KAyEY,gBACV,UAAU,2BACE;cAED,mBAAiB,EAAA,WAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkClB,cAAc,EAAE,aAAa;cAE5B,YAAU,EAAA,WAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkCX,WAAW,EAAE,aAAa;cAEhC,eAAa,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqDP,gCAAgC,4BACnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4EO,wBACd,SAAS,2DAA6B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CA+LvC,6CAAA"}
+{"version":3,"file":"summarization.d.cts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/summarization.ts"],"mappings":";;;;;;YAyEY,gBACV,UAAU,2BACE;qBAED,mBAAiB,EAAA,WAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAkClB,cAAc,EAAE,aAAa;qBAE5B,YAAU,EAAA,WAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;YAkCX,WAAW,EAAE,aAAa;cAEhC,eAAa,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqDP,gCAAgC,4BACnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA4EO,wBACd,SAAS,2DAA6B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CA+LvC,6CAAA"}

package/dist/agents/middleware/summarization.d.ts

@@ -4,8 +4,8 @@ import { InferInteropZodInput } from "@langchain/core/utils/types";
 import { z } from "zod/v3";
 import { BaseLanguageModel } from "@langchain/core/language_models/base";
 //#region src/agents/middleware/summarization.d.ts
-type TokenCounter = (messages: BaseMessage[]) => number | Promise<number>;
-declare const contextSizeSchema: z.ZodEffects<z.ZodObject<{
+export type TokenCounter = (messages: BaseMessage[]) => number | Promise<number>;
+export declare const contextSizeSchema: z.ZodEffects<z.ZodObject<{
   /**
    * Fraction of the model's context size to use as the trigger
    */
@@ -35,8 +35,8 @@ declare const contextSizeSchema: z.ZodEffects<z.ZodObject<{
   tokens?: number | undefined;
   messages?: number | undefined;
 }>;
-type ContextSize = z.infer<typeof contextSizeSchema>;
-declare const keepSchema: z.ZodEffects<z.ZodObject<{
+export type ContextSize = z.infer<typeof contextSizeSchema>;
+export declare const keepSchema: z.ZodEffects<z.ZodObject<{
   /**
    * Fraction of the model's context size to keep
    */
@@ -63,7 +63,7 @@ declare const keepSchema: z.ZodEffects<z.ZodObject<{
   tokens?: number | undefined;
   messages?: number | undefined;
 }>;
-type KeepSize = z.infer<typeof keepSchema>;
+export type KeepSize = z.infer<typeof keepSchema>;
 declare const contextSchema: z.ZodObject<{
   /**
    * Model to use for summarization
@@ -244,7 +244,7 @@ declare const contextSchema: z.ZodObject<{
   maxTokensBeforeSummary?: number | undefined;
   messagesToKeep?: number | undefined;
 }>;
-type SummarizationMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;
+export type SummarizationMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;
 /**
  * Summarization middleware that automatically summarizes conversation history when token limits are approached.
  *
@@ -291,7 +291,7 @@ type SummarizationMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;
  *
  * ```
  */
-declare function summarizationMiddleware(options: SummarizationMiddlewareConfig): AgentMiddleware<undefined, z.ZodObject<{
+export declare function summarizationMiddleware(options: SummarizationMiddlewareConfig): AgentMiddleware<undefined, z.ZodObject<{
   trigger: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodObject<{
     /**
      * Fraction of the model's context size to use as the trigger
@@ -454,5 +454,4 @@ declare function summarizationMiddleware(options: SummarizationMiddlewareConfig)
   model?: BaseLanguageModel<any, import("@langchain/core/language_models/base").BaseLanguageModelCallOptions> | undefined;
 }, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>;
 //#endregion
-export { ContextSize, KeepSize, SummarizationMiddlewareConfig, TokenCounter, contextSizeSchema, keepSchema, summarizationMiddleware };
 //# sourceMappingURL=summarization.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"summarization.d.ts","names":[],"sources":["../../../src/agents/middleware/summarization.ts"],"mappings":";;;;;;KAyEY,gBACV,UAAU,2BACE;cAED,mBAAiB,EAAA,WAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkClB,cAAc,EAAE,aAAa;cAE5B,YAAU,EAAA,WAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkCX,WAAW,EAAE,aAAa;cAEhC,eAAa,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqDP,gCAAgC,4BACnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4EO,wBACd,SAAS,2DAA6B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CA+LvC,6CAAA"}
+{"version":3,"file":"summarization.d.ts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/summarization.ts"],"mappings":";;;;;;YAyEY,gBACV,UAAU,2BACE;qBAED,mBAAiB,EAAA,WAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAkClB,cAAc,EAAE,aAAa;qBAE5B,YAAU,EAAA,WAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;YAkCX,WAAW,EAAE,aAAa;cAEhC,eAAa,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqDP,gCAAgC,4BACnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA4EO,wBACd,SAAS,2DAA6B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CA+LvC,6CAAA"}

package/dist/agents/middleware/todoListMiddleware.d.cts

@@ -3,7 +3,7 @@ import { ToolMessage } from "@langchain/core/messages";
 import { Command } from "@langchain/langgraph";
 import { z } from "zod/v3";
 //#region src/agents/middleware/todoListMiddleware.d.ts
-declare const TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT = "## `write_todos`\n\nYou have access to the `write_todos` tool to help you manage and plan complex objectives. \nUse this tool for complex objectives to ensure that you are tracking each necessary step and giving the user visibility into your progress.\nThis tool is very helpful for planning complex objectives, and for breaking down these larger complex objectives into smaller steps.\n\nIt is critical that you mark todos as completed as soon as you are done with a step. Do not batch up multiple steps before marking them as completed.\nFor simple objectives that only require a few steps, it is better to just complete the objective directly and NOT use this tool.\nWriting todos takes time and tokens, use it when it is helpful for managing complex many-step problems! But not for simple few-step requests.\n\n## Important To-Do List Usage Notes to Remember\n- The `write_todos` tool should never be called multiple times in parallel.\n- Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.";
+export declare const TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT = "## `write_todos`\n\nYou have access to the `write_todos` tool to help you manage and plan complex objectives. \nUse this tool for complex objectives to ensure that you are tracking each necessary step and giving the user visibility into your progress.\nThis tool is very helpful for planning complex objectives, and for breaking down these larger complex objectives into smaller steps.\n\nIt is critical that you mark todos as completed as soon as you are done with a step. Do not batch up multiple steps before marking them as completed.\nFor simple objectives that only require a few steps, it is better to just complete the objective directly and NOT use this tool.\nWriting todos takes time and tokens, use it when it is helpful for managing complex many-step problems! But not for simple few-step requests.\n\n## Important To-Do List Usage Notes to Remember\n- The `write_todos` tool should never be called multiple times in parallel.\n- Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.";
 declare const TodoSchema: z.ZodObject<{
   content: z.ZodString;
   status: z.ZodEnum<["pending", "in_progress", "completed"]>;
@@ -14,8 +14,8 @@ declare const TodoSchema: z.ZodObject<{
   content: string;
   status: "completed" | "in_progress" | "pending";
 }>;
-type Todo = z.infer<typeof TodoSchema>;
-interface TodoListMiddlewareOptions {
+export type Todo = z.infer<typeof TodoSchema>;
+export interface TodoListMiddlewareOptions {
   /**
    * Custom system prompt to guide the agent on using the todo tool.
    * If not provided, uses the default {@link PLANNING_MIDDLEWARE_SYSTEM_PROMPT}.
@@ -62,7 +62,7 @@ interface TodoListMiddlewareOptions {
  * @see {@link TodoMiddlewareState} for the state schema
  * @see {@link writeTodos} for the tool implementation
  */
-declare function todoListMiddleware(options?: TodoListMiddlewareOptions): AgentMiddleware<z.ZodObject<{
+export declare function todoListMiddleware(options?: TodoListMiddlewareOptions): AgentMiddleware<z.ZodObject<{
   todos: z.ZodDefault<z.ZodArray<z.ZodObject<{
     content: z.ZodString;
     status: z.ZodEnum<["pending", "in_progress", "completed"]>;
@@ -122,5 +122,4 @@ declare function todoListMiddleware(options?: TodoListMiddlewareOptions): AgentM
   messages: ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>[];
 }, string>, unknown, "write_todos">], readonly []>;
 //#endregion
-export { TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT, Todo, TodoListMiddlewareOptions, todoListMiddleware };
 //# sourceMappingURL=todoListMiddleware.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"todoListMiddleware.d.cts","names":[],"sources":["../../../src/agents/middleware/todoListMiddleware.ts"],"mappings":";;;;;cAiOa;cAiBP,YAAU,EAAA;;;;;;;;;;KAIJ,OAAO,EAAE,aAAa;UAOjB;;;;;EAKf;;;;;EAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCc,mBAAmB,UAAU,4CAAyB,EAAA"}
+{"version":3,"file":"todoListMiddleware.d.cts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/todoListMiddleware.ts"],"mappings":";;;;;qBAiOa;cAiBP,YAAU,EAAA;;;;;;;;;;YAIJ,OAAO,EAAE,aAAa;iBAOjB;;;;;EAKf;;;;;EAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAsCc,mBAAmB,UAAU,4CAAyB,EAAA"}

package/dist/agents/middleware/todoListMiddleware.d.ts

@@ -3,7 +3,7 @@ import { ToolMessage } from "@langchain/core/messages";
 import { Command } from "@langchain/langgraph";
 import { z } from "zod/v3";
 //#region src/agents/middleware/todoListMiddleware.d.ts
-declare const TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT = "## `write_todos`\n\nYou have access to the `write_todos` tool to help you manage and plan complex objectives. \nUse this tool for complex objectives to ensure that you are tracking each necessary step and giving the user visibility into your progress.\nThis tool is very helpful for planning complex objectives, and for breaking down these larger complex objectives into smaller steps.\n\nIt is critical that you mark todos as completed as soon as you are done with a step. Do not batch up multiple steps before marking them as completed.\nFor simple objectives that only require a few steps, it is better to just complete the objective directly and NOT use this tool.\nWriting todos takes time and tokens, use it when it is helpful for managing complex many-step problems! But not for simple few-step requests.\n\n## Important To-Do List Usage Notes to Remember\n- The `write_todos` tool should never be called multiple times in parallel.\n- Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.";
+export declare const TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT = "## `write_todos`\n\nYou have access to the `write_todos` tool to help you manage and plan complex objectives. \nUse this tool for complex objectives to ensure that you are tracking each necessary step and giving the user visibility into your progress.\nThis tool is very helpful for planning complex objectives, and for breaking down these larger complex objectives into smaller steps.\n\nIt is critical that you mark todos as completed as soon as you are done with a step. Do not batch up multiple steps before marking them as completed.\nFor simple objectives that only require a few steps, it is better to just complete the objective directly and NOT use this tool.\nWriting todos takes time and tokens, use it when it is helpful for managing complex many-step problems! But not for simple few-step requests.\n\n## Important To-Do List Usage Notes to Remember\n- The `write_todos` tool should never be called multiple times in parallel.\n- Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.";
 declare const TodoSchema: z.ZodObject<{
   content: z.ZodString;
   status: z.ZodEnum<["pending", "in_progress", "completed"]>;
@@ -14,8 +14,8 @@ declare const TodoSchema: z.ZodObject<{
   content: string;
   status: "completed" | "in_progress" | "pending";
 }>;
-type Todo = z.infer<typeof TodoSchema>;
-interface TodoListMiddlewareOptions {
+export type Todo = z.infer<typeof TodoSchema>;
+export interface TodoListMiddlewareOptions {
   /**
    * Custom system prompt to guide the agent on using the todo tool.
    * If not provided, uses the default {@link PLANNING_MIDDLEWARE_SYSTEM_PROMPT}.
@@ -62,7 +62,7 @@ interface TodoListMiddlewareOptions {
  * @see {@link TodoMiddlewareState} for the state schema
  * @see {@link writeTodos} for the tool implementation
  */
-declare function todoListMiddleware(options?: TodoListMiddlewareOptions): AgentMiddleware<z.ZodObject<{
+export declare function todoListMiddleware(options?: TodoListMiddlewareOptions): AgentMiddleware<z.ZodObject<{
   todos: z.ZodDefault<z.ZodArray<z.ZodObject<{
     content: z.ZodString;
     status: z.ZodEnum<["pending", "in_progress", "completed"]>;
@@ -122,5 +122,4 @@ declare function todoListMiddleware(options?: TodoListMiddlewareOptions): AgentM
   messages: ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>[];
 }, string>, unknown, "write_todos">], readonly []>;
 //#endregion
-export { TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT, Todo, TodoListMiddlewareOptions, todoListMiddleware };
 //# sourceMappingURL=todoListMiddleware.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"todoListMiddleware.d.ts","names":[],"sources":["../../../src/agents/middleware/todoListMiddleware.ts"],"mappings":";;;;;cAiOa;cAiBP,YAAU,EAAA;;;;;;;;;;KAIJ,OAAO,EAAE,aAAa;UAOjB;;;;;EAKf;;;;;EAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCc,mBAAmB,UAAU,4CAAyB,EAAA"}
+{"version":3,"file":"todoListMiddleware.d.ts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/todoListMiddleware.ts"],"mappings":";;;;;qBAiOa;cAiBP,YAAU,EAAA;;;;;;;;;;YAIJ,OAAO,EAAE,aAAa;iBAOjB;;;;;EAKf;;;;;EAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAsCc,mBAAmB,UAAU,4CAAyB,EAAA"}

package/dist/agents/middleware/toolCallLimit.d.cts

@@ -8,7 +8,7 @@ import { z } from "zod/v3";
  * This exception is raised when the configured exit behavior is 'error'
  * and either the thread or run tool call limit has been exceeded.
  */
-declare class ToolCallLimitExceededError extends Error {
+export declare class ToolCallLimitExceededError extends Error {
   /**
    * Current thread tool call count.
    */
@@ -34,7 +34,7 @@ declare class ToolCallLimitExceededError extends Error {
 /**
  * Options for configuring the Tool Call Limit middleware.
  */
-declare const ToolCallLimitOptionsSchema: z.ZodObject<{
+export declare const ToolCallLimitOptionsSchema: z.ZodObject<{
   /**
    * Name of the specific tool to limit. If undefined, limits apply to all tools.
    */
@@ -71,7 +71,7 @@ declare const ToolCallLimitOptionsSchema: z.ZodObject<{
   runLimit?: number | undefined;
   exitBehavior?: "continue" | "end" | "error" | undefined;
 }>;
-type ToolCallLimitConfig = InferInteropZodInput<typeof ToolCallLimitOptionsSchema>;
+export type ToolCallLimitConfig = InferInteropZodInput<typeof ToolCallLimitOptionsSchema>;
 /**
  * Middleware that tracks tool call counts and enforces limits.
  *
@@ -152,7 +152,7 @@ type ToolCallLimitConfig = InferInteropZodInput<typeof ToolCallLimitOptionsSchem
  * }
  * ```
  */
-declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): AgentMiddleware<z.ZodObject<{
+export declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): AgentMiddleware<z.ZodObject<{
   threadToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
   runToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
@@ -163,5 +163,4 @@ declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): AgentMid
   runToolCallCount?: Record<string, number> | undefined;
 }>, undefined, unknown, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>;
 //#endregion
-export { ToolCallLimitConfig, ToolCallLimitExceededError, ToolCallLimitOptionsSchema, toolCallLimitMiddleware };
 //# sourceMappingURL=toolCallLimit.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"toolCallLimit.d.cts","names":[],"sources":["../../../src/agents/middleware/toolCallLimit.ts"],"mappings":";;;;;;;;;;cA6Ea,mCAAmC;;;;EAI9C;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;EAEA,YACE,qBACA,kBACA,iCACA,8BACA;;;;;cAuBS,4BAA0B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA4B3B,sBAAsB,4BACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6FO,wBAAwB,SAAS,sBAAmB,gBAAA,EAAA;;;;;;;;;kEAuRnE,6CAAA"}
+{"version":3,"file":"toolCallLimit.d.cts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/toolCallLimit.ts"],"mappings":";;;;;;;;;;qBA6Ea,mCAAmC;;;;EAI9C;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;EAEA,YACE,qBACA,kBACA,iCACA,8BACA;;;;;qBAuBS,4BAA0B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA4B3B,sBAAsB,4BACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6FO,wBAAwB,SAAS,sBAAmBA,gBAAA,EAAA;;;;;;;;;kEAuRnE,6CAAA"}

package/dist/agents/middleware/toolCallLimit.d.ts

@@ -8,7 +8,7 @@ import { z } from "zod/v3";
  * This exception is raised when the configured exit behavior is 'error'
  * and either the thread or run tool call limit has been exceeded.
  */
-declare class ToolCallLimitExceededError extends Error {
+export declare class ToolCallLimitExceededError extends Error {
   /**
    * Current thread tool call count.
    */
@@ -34,7 +34,7 @@ declare class ToolCallLimitExceededError extends Error {
 /**
  * Options for configuring the Tool Call Limit middleware.
  */
-declare const ToolCallLimitOptionsSchema: z.ZodObject<{
+export declare const ToolCallLimitOptionsSchema: z.ZodObject<{
   /**
    * Name of the specific tool to limit. If undefined, limits apply to all tools.
    */
@@ -71,7 +71,7 @@ declare const ToolCallLimitOptionsSchema: z.ZodObject<{
   runLimit?: number | undefined;
   exitBehavior?: "continue" | "end" | "error" | undefined;
 }>;
-type ToolCallLimitConfig = InferInteropZodInput<typeof ToolCallLimitOptionsSchema>;
+export type ToolCallLimitConfig = InferInteropZodInput<typeof ToolCallLimitOptionsSchema>;
 /**
  * Middleware that tracks tool call counts and enforces limits.
  *
@@ -152,7 +152,7 @@ type ToolCallLimitConfig = InferInteropZodInput<typeof ToolCallLimitOptionsSchem
  * }
  * ```
  */
-declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): AgentMiddleware<z.ZodObject<{
+export declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): AgentMiddleware<z.ZodObject<{
   threadToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
   runToolCallCount: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
@@ -163,5 +163,4 @@ declare function toolCallLimitMiddleware(options: ToolCallLimitConfig): AgentMid
   runToolCallCount?: Record<string, number> | undefined;
 }>, undefined, unknown, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>;
 //#endregion
-export { ToolCallLimitConfig, ToolCallLimitExceededError, ToolCallLimitOptionsSchema, toolCallLimitMiddleware };
 //# sourceMappingURL=toolCallLimit.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"toolCallLimit.d.ts","names":[],"sources":["../../../src/agents/middleware/toolCallLimit.ts"],"mappings":";;;;;;;;;;cA6Ea,mCAAmC;;;;EAI9C;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;EAEA,YACE,qBACA,kBACA,iCACA,8BACA;;;;;cAuBS,4BAA0B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA4B3B,sBAAsB,4BACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6FO,wBAAwB,SAAS,sBAAmB,gBAAA,EAAA;;;;;;;;;kEAuRnE,6CAAA"}
+{"version":3,"file":"toolCallLimit.d.ts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/toolCallLimit.ts"],"mappings":";;;;;;;;;;qBA6Ea,mCAAmC;;;;EAI9C;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;EAEA,YACE,qBACA,kBACA,iCACA,8BACA;;;;;qBAuBS,4BAA0B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA4B3B,sBAAsB,4BACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6FO,wBAAwB,SAAS,sBAAmBA,gBAAA,EAAA;;;;;;;;;kEAuRnE,6CAAA"}

package/dist/agents/middleware/toolEmulator.d.cts

@@ -5,7 +5,7 @@ import { ClientTool, ServerTool } from "@langchain/core/tools";
 /**
  * Options for configuring the Tool Emulator middleware.
  */
-interface ToolEmulatorOptions {
+export interface ToolEmulatorOptions {
   /**
    * List of tool names (string) or tool instances to emulate.
    * - If `undefined` (default), ALL tools will be emulated.
@@ -68,7 +68,6 @@ interface ToolEmulatorOptions {
  * });
  * ```
  */
-declare function toolEmulatorMiddleware(options?: ToolEmulatorOptions): AgentMiddleware<undefined, undefined, unknown, readonly (ServerTool | ClientTool)[], readonly []>;
+export declare function toolEmulatorMiddleware(options?: ToolEmulatorOptions): AgentMiddleware<undefined, undefined, unknown, readonly (ServerTool | ClientTool)[], readonly []>;
 //#endregion
-export { ToolEmulatorOptions, toolEmulatorMiddleware };
 //# sourceMappingURL=toolEmulator.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"toolEmulator.d.cts","names":[],"sources":["../../../src/agents/middleware/toolEmulator.ts"],"mappings":";;;;;;;UAeiB;;;;;;;EAOf,kBAAkB,aAAa;;;;;;;EAQ/B,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkDH,uBAAuB,UAAS,sBAAwB,yDAAA,aAAA"}
+{"version":3,"file":"toolEmulator.d.cts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/toolEmulator.ts"],"mappings":";;;;;;;iBAeiB;;;;;;;EAOf,kBAAkB,aAAa;;;;;;;EAQ/B,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkDH,uBAAuB,UAAS,sBAAwBA,yDAAA,aAAA"}

package/dist/agents/middleware/toolEmulator.d.ts

@@ -5,7 +5,7 @@ import { ClientTool, ServerTool } from "@langchain/core/tools";
 /**
  * Options for configuring the Tool Emulator middleware.
  */
-interface ToolEmulatorOptions {
+export interface ToolEmulatorOptions {
   /**
    * List of tool names (string) or tool instances to emulate.
    * - If `undefined` (default), ALL tools will be emulated.
@@ -68,7 +68,6 @@ interface ToolEmulatorOptions {
  * });
  * ```
  */
-declare function toolEmulatorMiddleware(options?: ToolEmulatorOptions): AgentMiddleware<undefined, undefined, unknown, readonly (ServerTool | ClientTool)[], readonly []>;
+export declare function toolEmulatorMiddleware(options?: ToolEmulatorOptions): AgentMiddleware<undefined, undefined, unknown, readonly (ServerTool | ClientTool)[], readonly []>;
 //#endregion
-export { ToolEmulatorOptions, toolEmulatorMiddleware };
 //# sourceMappingURL=toolEmulator.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"toolEmulator.d.ts","names":[],"sources":["../../../src/agents/middleware/toolEmulator.ts"],"mappings":";;;;;;;UAeiB;;;;;;;EAOf,kBAAkB,aAAa;;;;;;;EAQ/B,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkDH,uBAAuB,UAAS,sBAAwB,yDAAA,aAAA"}
+{"version":3,"file":"toolEmulator.d.ts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/toolEmulator.ts"],"mappings":";;;;;;;iBAeiB;;;;;;;EAOf,kBAAkB,aAAa;;;;;;;EAQ/B,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkDH,uBAAuB,UAAS,sBAAwBA,yDAAA,aAAA"}

package/dist/agents/middleware/toolError.d.cts

@@ -8,11 +8,11 @@ import { ClientTool, ServerTool } from "@langchain/core/tools";
  * Return content to surface the error to the model as an error `ToolMessage`.
  * Return nothing to propagate the original error.
  */
-type ToolErrorHandler = (error: unknown, request: ToolCallRequest) => MessageContent | void | Promise<MessageContent | void>;
+export type ToolErrorHandler = (error: unknown, request: ToolCallRequest) => MessageContent | void | Promise<MessageContent | void>;
 /**
  * Configuration for {@link toolErrorMiddleware}.
  */
-interface ToolErrorMiddlewareConfig {
+export interface ToolErrorMiddlewareConfig {
   /**
    * Handler called when tool execution throws. Return content to convert the
    * error into an error `ToolMessage`, or return nothing to propagate it.
@@ -57,7 +57,6 @@ interface ToolErrorMiddlewareConfig {
  * });
  * ```
  */
-declare function toolErrorMiddleware(config: ToolErrorMiddlewareConfig): AgentMiddleware<undefined, undefined, unknown, readonly (ServerTool | ClientTool)[], readonly []>;
+export declare function toolErrorMiddleware(config: ToolErrorMiddlewareConfig): AgentMiddleware<undefined, undefined, unknown, readonly (ServerTool | ClientTool)[], readonly []>;
 //#endregion
-export { ToolErrorHandler, ToolErrorMiddlewareConfig, toolErrorMiddleware };
 //# sourceMappingURL=toolError.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"toolError.d.cts","names":[],"sources":["../../../src/agents/middleware/toolError.ts"],"mappings":";;;;;;;;;;KAgBY,oBACV,gBACA,SAAS,oBACN,wBAAwB,QAAQ;;;;UAKpB;;;;;EAKf,SAAS;;;;;EAMT,QAAQ,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoCb,oBAAoB,QAAQ,4BAAyB,yDAAA,aAAA"}
+{"version":3,"file":"toolError.d.cts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/toolError.ts"],"mappings":";;;;;;;;;;YAgBY,oBACV,gBACA,SAAS,oBACN,wBAAwB,QAAQ;;;;iBAKpB;;;;;EAKf,SAAS;;;;;EAMT,QAAQ,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAoCb,oBAAoB,QAAQ,4BAAyBA,yDAAA,aAAA"}

package/dist/agents/middleware/toolError.d.ts

@@ -8,11 +8,11 @@ import { ClientTool, ServerTool } from "@langchain/core/tools";
  * Return content to surface the error to the model as an error `ToolMessage`.
  * Return nothing to propagate the original error.
  */
-type ToolErrorHandler = (error: unknown, request: ToolCallRequest) => MessageContent | void | Promise<MessageContent | void>;
+export type ToolErrorHandler = (error: unknown, request: ToolCallRequest) => MessageContent | void | Promise<MessageContent | void>;
 /**
  * Configuration for {@link toolErrorMiddleware}.
  */
-interface ToolErrorMiddlewareConfig {
+export interface ToolErrorMiddlewareConfig {
   /**
    * Handler called when tool execution throws. Return content to convert the
    * error into an error `ToolMessage`, or return nothing to propagate it.
@@ -57,7 +57,6 @@ interface ToolErrorMiddlewareConfig {
  * });
  * ```
  */
-declare function toolErrorMiddleware(config: ToolErrorMiddlewareConfig): AgentMiddleware<undefined, undefined, unknown, readonly (ServerTool | ClientTool)[], readonly []>;
+export declare function toolErrorMiddleware(config: ToolErrorMiddlewareConfig): AgentMiddleware<undefined, undefined, unknown, readonly (ServerTool | ClientTool)[], readonly []>;
 //#endregion
-export { ToolErrorHandler, ToolErrorMiddlewareConfig, toolErrorMiddleware };
 //# sourceMappingURL=toolError.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"toolError.d.ts","names":[],"sources":["../../../src/agents/middleware/toolError.ts"],"mappings":";;;;;;;;;;KAgBY,oBACV,gBACA,SAAS,oBACN,wBAAwB,QAAQ;;;;UAKpB;;;;;EAKf,SAAS;;;;;EAMT,QAAQ,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoCb,oBAAoB,QAAQ,4BAAyB,yDAAA,aAAA"}
+{"version":3,"file":"toolError.d.ts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/toolError.ts"],"mappings":";;;;;;;;;;YAgBY,oBACV,gBACA,SAAS,oBACN,wBAAwB,QAAQ;;;;iBAKpB;;;;;EAKf,SAAS;;;;;EAMT,QAAQ,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAoCb,oBAAoB,QAAQ,4BAAyBA,yDAAA,aAAA"}

package/dist/agents/middleware/toolRetry.d.cts

@@ -5,7 +5,7 @@ import { z } from "zod/v3";
 /**
  * Configuration options for the Tool Retry Middleware.
  */
-declare const ToolRetryMiddlewareOptionsSchema: z.ZodObject<{
+export declare const ToolRetryMiddlewareOptionsSchema: z.ZodObject<{
   /**
    * Optional list of tools or tool names to apply retry logic to.
    * Can be a list of `BaseTool` instances or tool name strings.
@@ -51,7 +51,7 @@ declare const ToolRetryMiddlewareOptionsSchema: z.ZodObject<{
   tools?: (string | ServerTool | ClientTool)[] | undefined;
   onFailure?: "continue" | "error" | "raise" | "return_message" | ((args_0: Error, ...args: unknown[]) => string) | undefined;
 }>;
-type ToolRetryMiddlewareConfig = z.input<typeof ToolRetryMiddlewareOptionsSchema>;
+export type ToolRetryMiddlewareConfig = z.input<typeof ToolRetryMiddlewareOptionsSchema>;
 /**
  * Middleware that automatically retries failed tool calls with configurable backoff.
  *
@@ -151,7 +151,7 @@ type ToolRetryMiddlewareConfig = z.input<typeof ToolRetryMiddlewareOptionsSchema
  * @param config - Configuration options for the retry middleware
  * @returns A middleware instance that handles tool failures with retries
  */
-declare function toolRetryMiddleware(config?: ToolRetryMiddlewareConfig): AgentMiddleware<undefined, z.ZodObject<{
+export declare function toolRetryMiddleware(config?: ToolRetryMiddlewareConfig): AgentMiddleware<undefined, z.ZodObject<{
   /**
    * Optional list of tools or tool names to apply retry logic to.
    * Can be a list of `BaseTool` instances or tool name strings.
@@ -207,5 +207,4 @@ declare function toolRetryMiddleware(config?: ToolRetryMiddlewareConfig): AgentM
   onFailure: "continue" | "error" | "raise" | "return_message" | ((args_0: Error, ...args: unknown[]) => string);
 }, readonly (ServerTool | ClientTool)[], readonly []>;
 //#endregion
-export { ToolRetryMiddlewareConfig, ToolRetryMiddlewareOptionsSchema, toolRetryMiddleware };
 //# sourceMappingURL=toolRetry.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"toolRetry.d.cts","names":[],"sources":["../../../src/agents/middleware/toolRetry.ts"],"mappings":";;;;;;;cAea,kCAAgC,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA2CjC,4BAA4B,EAAE,aACjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsGO,oBAAoB,SAAQ,4BA2K3C,2BA3KyE,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA2KzE,aAAA"}
+{"version":3,"file":"toolRetry.d.cts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/toolRetry.ts"],"mappings":";;;;;;;qBAea,kCAAgC,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA2CjC,4BAA4B,EAAE,aACjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAsGO,oBAAoB,SAAQ,4BA2K3CA,2BA3KyE,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA2KzE,aAAA"}

package/dist/agents/middleware/toolRetry.d.ts

@@ -5,7 +5,7 @@ import { z } from "zod/v3";
 /**
  * Configuration options for the Tool Retry Middleware.
  */
-declare const ToolRetryMiddlewareOptionsSchema: z.ZodObject<{
+export declare const ToolRetryMiddlewareOptionsSchema: z.ZodObject<{
   /**
    * Optional list of tools or tool names to apply retry logic to.
    * Can be a list of `BaseTool` instances or tool name strings.
@@ -51,7 +51,7 @@ declare const ToolRetryMiddlewareOptionsSchema: z.ZodObject<{
   tools?: (string | ServerTool | ClientTool)[] | undefined;
   onFailure?: "continue" | "error" | "raise" | "return_message" | ((args_0: Error, ...args: unknown[]) => string) | undefined;
 }>;
-type ToolRetryMiddlewareConfig = z.input<typeof ToolRetryMiddlewareOptionsSchema>;
+export type ToolRetryMiddlewareConfig = z.input<typeof ToolRetryMiddlewareOptionsSchema>;
 /**
  * Middleware that automatically retries failed tool calls with configurable backoff.
  *
@@ -151,7 +151,7 @@ type ToolRetryMiddlewareConfig = z.input<typeof ToolRetryMiddlewareOptionsSchema
  * @param config - Configuration options for the retry middleware
  * @returns A middleware instance that handles tool failures with retries
  */
-declare function toolRetryMiddleware(config?: ToolRetryMiddlewareConfig): AgentMiddleware<undefined, z.ZodObject<{
+export declare function toolRetryMiddleware(config?: ToolRetryMiddlewareConfig): AgentMiddleware<undefined, z.ZodObject<{
   /**
    * Optional list of tools or tool names to apply retry logic to.
    * Can be a list of `BaseTool` instances or tool name strings.
@@ -207,5 +207,4 @@ declare function toolRetryMiddleware(config?: ToolRetryMiddlewareConfig): AgentM
   onFailure: "continue" | "error" | "raise" | "return_message" | ((args_0: Error, ...args: unknown[]) => string);
 }, readonly (ServerTool | ClientTool)[], readonly []>;
 //#endregion
-export { ToolRetryMiddlewareConfig, ToolRetryMiddlewareOptionsSchema, toolRetryMiddleware };
 //# sourceMappingURL=toolRetry.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"toolRetry.d.ts","names":[],"sources":["../../../src/agents/middleware/toolRetry.ts"],"mappings":";;;;;;;cAea,kCAAgC,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA2CjC,4BAA4B,EAAE,aACjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsGO,oBAAoB,SAAQ,4BA2K3C,2BA3KyE,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA2KzE,aAAA"}
+{"version":3,"file":"toolRetry.d.ts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/toolRetry.ts"],"mappings":";;;;;;;qBAea,kCAAgC,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA2CjC,4BAA4B,EAAE,aACjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAsGO,oBAAoB,SAAQ,4BA2K3CA,2BA3KyE,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA2KzE,aAAA"}