langchain 1.0.5 → 1.1.0

package/dist/agents/middleware/todoListMiddleware.js.map

@@ -1 +1 @@
-{"version":3,"file":"todoListMiddleware.js","names":["options?: TodoListMiddlewareOptions"],"sources":["../../../src/agents/middleware/todoListMiddleware.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { Command } from \"@langchain/langgraph\";\nimport { tool } from \"@langchain/core/tools\";\nimport { ToolMessage } from \"@langchain/core/messages\";\n\nimport { createMiddleware } from \"../index.js\";\n\n/**\n * Description for the write_todos tool\n * Ported exactly from Python WRITE_TODOS_DESCRIPTION\n */\nconst WRITE_TODOS_DESCRIPTION = `Use this tool to create and manage a structured task list for your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.\nIt also helps the user understand the progress of the task and overall progress of their requests.\nOnly use this tool if you think it will be helpful in staying organized. If the user's request is trivial and takes less than 3 steps, it is better to NOT use this tool and just do the taks directly.\n\n## When to Use This Tool\nUse this tool in these scenarios:\n\n1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions\n2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations\n3. User explicitly requests todo list - When the user directly asks you to use the todo list\n4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)\n5. The plan may need future revisions or updates based on results from the first few steps. Keeping track of this in a list is helpful.\n\n## How to Use This Tool\n1. When you start working on a task - Mark it as in_progress BEFORE beginning work.\n2. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation.\n3. You can also update future tasks, such as deleting them if they are no longer necessary, or adding new tasks that are necessary. Don't change previously completed tasks.\n4. You can make several updates to the todo list at once. For example, when you complete a task, you can mark the next task you need to start as in_progress.\n\n## When NOT to Use This Tool\nIt is important to skip using this tool when:\n1. There is only a single, straightforward task\n2. The task is trivial and tracking it provides no benefit\n3. The task can be completed in less than 3 trivial steps\n4. The task is purely conversational or informational\n\n## Examples of When to Use the Todo List\n\n<example>\nUser: I want to add a dark mode toggle to the application settings. Make sure you run the tests and build when you're done!\nAssistant: I'll help add a dark mode toggle to your application settings. Let me create a todo list to track this implementation.\n*Creates todo list with the following items:*\n1. Create dark mode toggle component in Settings page\n2. Add dark mode state management (context/store)\n3. Implement CSS-in-JS styles for dark theme\n4. Update existing components to support theme switching\n5. Run tests and build process, addressing any failures or errors that occur\n*Begins working on the first task*\n\n<reasoning>\nThe assistant used the todo list because:\n1. Adding dark mode in it of itself is a multi-step feature requiring UI, state management, and styling changes\n2. The assistant inferred that tests and build need to pass by adding \"Ensure tests and build succeed\" as the final task\n3. Both of the user's requests are complex and require multiple steps to complete.\n</reasoning>\n</example>\n\n<example>\nUser: Help me plan a comprehensive marketing campaign for our new product launch, including social media, email marketing, and press releases.\nAssistant: I'll help you plan a comprehensive marketing campaign for your product launch. Let me create a todo list to organize all the components.\n*Creates todo list with the following items:*\n1. Define target audience and key messaging\n2. Create social media content calendar and posting schedule\n3. Design email marketing sequence and automation flows\n4. Draft press release and identify media contacts\n5. Set up tracking and analytics for campaign performance\n6. Create visual assets and brand materials\n7. Coordinate launch timeline and deliverables\n*Begins working on the first task*\n\n<reasoning>\nThe assistant used the todo list because:\n1. Marketing campaign planning involves multiple distinct channels and activities\n2. Each component requires careful coordination and planning\n3. The systematic approach ensures all aspects of the launch are covered\n</reasoning>\n</example>\n\n<example>\nUser: Help me rename the function getCwd to getCurrentWorkingDirectory across my project\nAssistant: Let me first search through your codebase to find all occurrences of 'getCwd'.\n*Uses search tools to locate all instances of getCwd in the codebase*\nAssistant: I've found 15 instances of 'getCwd' across 8 different files. Let me create a todo list to track these changes.\n*Creates todo list with specific items for each file that needs updating*\n\n<reasoning>\nThe assistant used the todo list because:\n1. The assistant searched to understand the scope of the task\n2. Upon finding multiple occurrences across different files, it determined this was a complex task with multiple steps (>3)\n3. The todo list helps ensure every instance is tracked and updated systematically\n4. This approach prevents missing any occurrences and maintains consistency.\n</reasoning>\n</example>\n\n<example>\nUser: I need help organizing my home office: decluttering the desk, setting up a filing system, organizing digital files, and creating a daily workflow.\nAssistant: I'll help you organize your home office systematically. Let me create a todo list to track each area of organization.\n*Creates todo list with items like: 1) Sort and declutter desk items, 2) Set up physical filing system for documents, 3) Organize digital files and folders, 4) Create daily workflow and productivity systems, 5) Establish maintenance routines*\nLet's start with decluttering your desk space to create a clean foundation for the other organizational systems.\n\n<reasoning>\nThe assistant used the todo list because:\n1. The user provided multiple distinct organizational tasks\n2. Each area requires different approaches and careful planning\n3. Home organization benefits from systematic, step-by-step completion\n4. Progress tracking ensures all areas are addressed thoroughly\n</reasoning>\n</example>\n\n## Examples of When NOT to Use the Todo List\n\n<example>\nUser: How do I print 'Hello World' in Python?\nAssistant: In Python, you can print \"Hello World\" with this simple code:\n\n\\`\\`\\`python\nprint(\"Hello World\")\n\\`\\`\\`\n\nThis will output the text \"Hello World\" to the console when executed.</assistant>\n\n<reasoning>\nThe assistant did not use the todo list because this is a single, trivial task that can be completed in one step. There's no need to track multiple tasks or steps for such a straightforward request.\n</reasoning>\n</example>\n\n<example>\nUser: What's the best way to water houseplants?\nAssistant: The best way to water houseplants depends on the specific plant type, but here are some general guidelines:\n\n- Check soil moisture by inserting your finger about 1-2 inches into the soil\n- Water thoroughly when the top inch feels dry, allowing water to drain from the bottom\n- Use room temperature water and water in the morning when possible\n- Avoid overwatering, which is more harmful than underwatering for most plants\n\nDifferent plants have different needs, so it's important to research your specific varieties for optimal care.\n\n<reasoning>\nThe assistant did not use the todo list because this is an informational request with no actual tasks to complete. The user is simply asking for advice and explanation, not for the assistant to perform multiple steps or activities.\n</reasoning>\n</example>\n\n<example>\nUser: Can you add a comment to the calculateTotal function to explain what it does?\nAssistant: Sure, let me add a comment to the calculateTotal function to explain what it does.\n* Uses the Edit tool to add a comment to the calculateTotal function *\n\n<reasoning>\nThe assistant did not use the todo list because this is a single, straightforward task confined to one location. Adding a comment doesn't require tracking multiple steps or systematic organization.\n</reasoning>\n</example>\n\n<example>\nUser: What time is it in Tokyo right now?\nAssistant: I'll check the current time in Tokyo for you.\n\n*Searches for current time in Tokyo*\n\nThe current time in Tokyo, Japan is [current time]. Tokyo is in the Japan Standard Time (JST) zone, which is UTC+9.\n\n<reasoning>\nThe assistant did not use the todo list because this is a single information lookup with immediate results. There are no multiple steps to track or organize, making the todo list unnecessary for this straightforward request.\n</reasoning>\n</example>\n\n<example>\nUser: I need to write a function that checks if a number is prime and then test it out.\nAssistant: I'll help you write a function that checks if a number is prime and then test it out.\n*Writes function that checks if a number is prime*\n*Tests the function*\n\n<reasoning>\nEven though this is a multi-step task, it is very straightforward and can be completed in two trivial steps (which is less than 3 steps!). Using the todo list here is overkill and wastes time and tokens.\n</reasoning>\n</example>\n\n<example>\nUser: I want you to order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway.\nAssistant: I'll help you order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway.\n*Orders a pizza from Dominos*\n*Orders a burger from McDonald's*\n*Orders a salad from Subway*\n\n<reasoning>\nEven though this is a multi-step task, assuming the assistant has the ability to order from these restaurants, it is very straightforward and can be completed in three trivial tool calls. \nUsing the todo list here is overkill and wastes time and tokens. These three tool calls should be made in parallel, in fact.\n</reasoning>\n</example>\n\n\n## Task States and Management\n\n1. **Task States**: Use these states to track progress:\n   - pending: Task not yet started\n   - in_progress: Currently working on (you can have multiple tasks in_progress at a time if they are not related to each other and can be run in parallel)\n   - completed: Task finished successfully\n\n2. **Task Management**:\n   - Update task status in real-time as you work\n   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)\n   - Complete current tasks before starting new ones\n   - Remove tasks that are no longer relevant from the list entirely\n   - IMPORTANT: When you write this todo list, you should mark your first task (or tasks) as in_progress immediately!.\n   - IMPORTANT: Unless all tasks are completed, you should always have at least one task in_progress to show the user that you are working on something.\n\n3. **Task Completion Requirements**:\n   - ONLY mark a task as completed when you have FULLY accomplished it\n   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress\n   - When blocked, create a new task describing what needs to be resolved\n   - Never mark a task as completed if:\n     - There are unresolved issues or errors\n     - Work is partial or incomplete\n     - You encountered blockers that prevent completion\n     - You couldn't find necessary resources or dependencies\n     - Quality standards haven't been met\n\n4. **Task Breakdown**:\n   - Create specific, actionable items\n   - Break complex tasks into smaller, manageable steps\n   - Use clear, descriptive task names\n\nBeing proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully\nRemember: If you only need to make a few tool calls to complete a task, and it is clear what you need to do, it is better to just do the task directly and NOT call this tool at all.`;\n\nexport 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.`;\n\nconst TodoStatus = z\n  .enum([\"pending\", \"in_progress\", \"completed\"])\n  .describe(\"Status of the todo\");\nconst TodoSchema = z.object({\n  content: z.string().describe(\"Content of the todo item\"),\n  status: TodoStatus,\n});\nconst stateSchema = z.object({\n  todos: z.array(TodoSchema).default([]),\n});\nexport type TodoMiddlewareState = z.infer<typeof stateSchema>;\n\nexport interface TodoListMiddlewareOptions {\n  /**\n   * Custom system prompt to guide the agent on using the todo tool.\n   * If not provided, uses the default {@link PLANNING_MIDDLEWARE_SYSTEM_PROMPT}.\n   */\n  systemPrompt?: string;\n  /**\n   * Custom description for the {@link writeTodos} tool.\n   * If not provided, uses the default {@link WRITE_TODOS_DESCRIPTION}.\n   */\n  toolDescription?: string;\n}\n\n/**\n * Creates a middleware that provides todo list management capabilities to agents.\n *\n * This middleware adds a `write_todos` tool that allows agents to create and manage\n * structured task lists for complex multi-step operations. It's designed to help\n * agents track progress, organize complex tasks, and provide users with visibility\n * into task completion status.\n *\n * The middleware automatically injects system prompts that guide the agent on when\n * and how to use the todo functionality effectively.\n *\n * @example\n * ```typescript\n * import { todoListMiddleware, createAgent } from 'langchain';\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [todoListMiddleware()],\n * });\n *\n * // Agent now has access to write_todos tool and todo state tracking\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Help me refactor my codebase\")]\n * });\n *\n * console.log(result.todos); // Array of todo items with status tracking\n * ```\n *\n * @returns A configured middleware instance that provides todo management capabilities\n *\n * @see {@link TodoMiddlewareState} for the state schema\n * @see {@link writeTodos} for the tool implementation\n */\nexport function todoListMiddleware(options?: TodoListMiddlewareOptions) {\n  /**\n   * Write todos tool - manages todo list with Command return\n   */\n  const writeTodos = tool(\n    ({ todos }, config) => {\n      return new Command({\n        update: {\n          todos,\n          messages: [\n            new ToolMessage({\n              content: `Updated todo list to ${JSON.stringify(todos)}`,\n              tool_call_id: config.toolCall?.id as string,\n            }),\n          ],\n        },\n      });\n    },\n    {\n      name: \"write_todos\",\n      description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,\n      schema: z.object({\n        todos: z.array(TodoSchema).describe(\"List of todo items to update\"),\n      }),\n    }\n  );\n\n  return createMiddleware({\n    name: \"todoListMiddleware\",\n    stateSchema,\n    tools: [writeTodos],\n    wrapModelCall: (request, handler) =>\n      handler({\n        ...request,\n        systemPrompt:\n          (request.systemPrompt ? `${request.systemPrompt}\\n\\n` : \"\") +\n          (options?.systemPrompt ?? TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT),\n      }),\n  });\n}\n"],"mappings":";;;;;;;;;;;;AAWA,MAAM,0BAA0B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qLAoNoJ,CAAC;AAEtL,MAAa,qCAAqC,CAAC;;;;;;;;;;;;kJAY+F,CAAC;AAEnJ,MAAM,aAAa,EAChB,KAAK;CAAC;CAAW;CAAe;AAAY,EAAC,CAC7C,SAAS,qBAAqB;AACjC,MAAM,aAAa,EAAE,OAAO;CAC1B,SAAS,EAAE,QAAQ,CAAC,SAAS,2BAA2B;CACxD,QAAQ;AACT,EAAC;AACF,MAAM,cAAc,EAAE,OAAO,EAC3B,OAAO,EAAE,MAAM,WAAW,CAAC,QAAQ,CAAE,EAAC,CACvC,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDF,SAAgB,mBAAmBA,SAAqC;;;;CAItE,MAAM,aAAa,KACjB,CAAC,EAAE,OAAO,EAAE,WAAW;AACrB,SAAO,IAAI,QAAQ,EACjB,QAAQ;GACN;GACA,UAAU,CACR,IAAI,YAAY;IACd,SAAS,CAAC,qBAAqB,EAAE,KAAK,UAAU,MAAM,EAAE;IACxD,cAAc,OAAO,UAAU;GAChC,EACF;EACF,EACF;CACF,GACD;EACE,MAAM;EACN,aAAa,SAAS,mBAAmB;EACzC,QAAQ,EAAE,OAAO,EACf,OAAO,EAAE,MAAM,WAAW,CAAC,SAAS,+BAA+B,CACpE,EAAC;CACH,EACF;AAED,QAAO,iBAAiB;EACtB,MAAM;EACN;EACA,OAAO,CAAC,UAAW;EACnB,eAAe,CAAC,SAAS,YACvB,QAAQ;GACN,GAAG;GACH,eACG,QAAQ,eAAe,GAAG,QAAQ,aAAa,IAAI,CAAC,GAAG,OACvD,SAAS,gBAAgB;EAC7B,EAAC;CACL,EAAC;AACH"}
+{"version":3,"file":"todoListMiddleware.js","names":["options?: TodoListMiddlewareOptions"],"sources":["../../../src/agents/middleware/todoListMiddleware.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { Command } from \"@langchain/langgraph\";\nimport { tool } from \"@langchain/core/tools\";\nimport { ToolMessage } from \"@langchain/core/messages\";\n\nimport { createMiddleware } from \"../index.js\";\n\n/**\n * Description for the write_todos tool\n * Ported exactly from Python WRITE_TODOS_DESCRIPTION\n */\nconst WRITE_TODOS_DESCRIPTION = `Use this tool to create and manage a structured task list for your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.\nIt also helps the user understand the progress of the task and overall progress of their requests.\nOnly use this tool if you think it will be helpful in staying organized. If the user's request is trivial and takes less than 3 steps, it is better to NOT use this tool and just do the taks directly.\n\n## When to Use This Tool\nUse this tool in these scenarios:\n\n1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions\n2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations\n3. User explicitly requests todo list - When the user directly asks you to use the todo list\n4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)\n5. The plan may need future revisions or updates based on results from the first few steps. Keeping track of this in a list is helpful.\n\n## How to Use This Tool\n1. When you start working on a task - Mark it as in_progress BEFORE beginning work.\n2. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation.\n3. You can also update future tasks, such as deleting them if they are no longer necessary, or adding new tasks that are necessary. Don't change previously completed tasks.\n4. You can make several updates to the todo list at once. For example, when you complete a task, you can mark the next task you need to start as in_progress.\n\n## When NOT to Use This Tool\nIt is important to skip using this tool when:\n1. There is only a single, straightforward task\n2. The task is trivial and tracking it provides no benefit\n3. The task can be completed in less than 3 trivial steps\n4. The task is purely conversational or informational\n\n## Examples of When to Use the Todo List\n\n<example>\nUser: I want to add a dark mode toggle to the application settings. Make sure you run the tests and build when you're done!\nAssistant: I'll help add a dark mode toggle to your application settings. Let me create a todo list to track this implementation.\n*Creates todo list with the following items:*\n1. Create dark mode toggle component in Settings page\n2. Add dark mode state management (context/store)\n3. Implement CSS-in-JS styles for dark theme\n4. Update existing components to support theme switching\n5. Run tests and build process, addressing any failures or errors that occur\n*Begins working on the first task*\n\n<reasoning>\nThe assistant used the todo list because:\n1. Adding dark mode in it of itself is a multi-step feature requiring UI, state management, and styling changes\n2. The assistant inferred that tests and build need to pass by adding \"Ensure tests and build succeed\" as the final task\n3. Both of the user's requests are complex and require multiple steps to complete.\n</reasoning>\n</example>\n\n<example>\nUser: Help me plan a comprehensive marketing campaign for our new product launch, including social media, email marketing, and press releases.\nAssistant: I'll help you plan a comprehensive marketing campaign for your product launch. Let me create a todo list to organize all the components.\n*Creates todo list with the following items:*\n1. Define target audience and key messaging\n2. Create social media content calendar and posting schedule\n3. Design email marketing sequence and automation flows\n4. Draft press release and identify media contacts\n5. Set up tracking and analytics for campaign performance\n6. Create visual assets and brand materials\n7. Coordinate launch timeline and deliverables\n*Begins working on the first task*\n\n<reasoning>\nThe assistant used the todo list because:\n1. Marketing campaign planning involves multiple distinct channels and activities\n2. Each component requires careful coordination and planning\n3. The systematic approach ensures all aspects of the launch are covered\n</reasoning>\n</example>\n\n<example>\nUser: Help me rename the function getCwd to getCurrentWorkingDirectory across my project\nAssistant: Let me first search through your codebase to find all occurrences of 'getCwd'.\n*Uses search tools to locate all instances of getCwd in the codebase*\nAssistant: I've found 15 instances of 'getCwd' across 8 different files. Let me create a todo list to track these changes.\n*Creates todo list with specific items for each file that needs updating*\n\n<reasoning>\nThe assistant used the todo list because:\n1. The assistant searched to understand the scope of the task\n2. Upon finding multiple occurrences across different files, it determined this was a complex task with multiple steps (>3)\n3. The todo list helps ensure every instance is tracked and updated systematically\n4. This approach prevents missing any occurrences and maintains consistency.\n</reasoning>\n</example>\n\n<example>\nUser: I need help organizing my home office: decluttering the desk, setting up a filing system, organizing digital files, and creating a daily workflow.\nAssistant: I'll help you organize your home office systematically. Let me create a todo list to track each area of organization.\n*Creates todo list with items like: 1) Sort and declutter desk items, 2) Set up physical filing system for documents, 3) Organize digital files and folders, 4) Create daily workflow and productivity systems, 5) Establish maintenance routines*\nLet's start with decluttering your desk space to create a clean foundation for the other organizational systems.\n\n<reasoning>\nThe assistant used the todo list because:\n1. The user provided multiple distinct organizational tasks\n2. Each area requires different approaches and careful planning\n3. Home organization benefits from systematic, step-by-step completion\n4. Progress tracking ensures all areas are addressed thoroughly\n</reasoning>\n</example>\n\n## Examples of When NOT to Use the Todo List\n\n<example>\nUser: How do I print 'Hello World' in Python?\nAssistant: In Python, you can print \"Hello World\" with this simple code:\n\n\\`\\`\\`python\nprint(\"Hello World\")\n\\`\\`\\`\n\nThis will output the text \"Hello World\" to the console when executed.</assistant>\n\n<reasoning>\nThe assistant did not use the todo list because this is a single, trivial task that can be completed in one step. There's no need to track multiple tasks or steps for such a straightforward request.\n</reasoning>\n</example>\n\n<example>\nUser: What's the best way to water houseplants?\nAssistant: The best way to water houseplants depends on the specific plant type, but here are some general guidelines:\n\n- Check soil moisture by inserting your finger about 1-2 inches into the soil\n- Water thoroughly when the top inch feels dry, allowing water to drain from the bottom\n- Use room temperature water and water in the morning when possible\n- Avoid overwatering, which is more harmful than underwatering for most plants\n\nDifferent plants have different needs, so it's important to research your specific varieties for optimal care.\n\n<reasoning>\nThe assistant did not use the todo list because this is an informational request with no actual tasks to complete. The user is simply asking for advice and explanation, not for the assistant to perform multiple steps or activities.\n</reasoning>\n</example>\n\n<example>\nUser: Can you add a comment to the calculateTotal function to explain what it does?\nAssistant: Sure, let me add a comment to the calculateTotal function to explain what it does.\n* Uses the Edit tool to add a comment to the calculateTotal function *\n\n<reasoning>\nThe assistant did not use the todo list because this is a single, straightforward task confined to one location. Adding a comment doesn't require tracking multiple steps or systematic organization.\n</reasoning>\n</example>\n\n<example>\nUser: What time is it in Tokyo right now?\nAssistant: I'll check the current time in Tokyo for you.\n\n*Searches for current time in Tokyo*\n\nThe current time in Tokyo, Japan is [current time]. Tokyo is in the Japan Standard Time (JST) zone, which is UTC+9.\n\n<reasoning>\nThe assistant did not use the todo list because this is a single information lookup with immediate results. There are no multiple steps to track or organize, making the todo list unnecessary for this straightforward request.\n</reasoning>\n</example>\n\n<example>\nUser: I need to write a function that checks if a number is prime and then test it out.\nAssistant: I'll help you write a function that checks if a number is prime and then test it out.\n*Writes function that checks if a number is prime*\n*Tests the function*\n\n<reasoning>\nEven though this is a multi-step task, it is very straightforward and can be completed in two trivial steps (which is less than 3 steps!). Using the todo list here is overkill and wastes time and tokens.\n</reasoning>\n</example>\n\n<example>\nUser: I want you to order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway.\nAssistant: I'll help you order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway.\n*Orders a pizza from Dominos*\n*Orders a burger from McDonald's*\n*Orders a salad from Subway*\n\n<reasoning>\nEven though this is a multi-step task, assuming the assistant has the ability to order from these restaurants, it is very straightforward and can be completed in three trivial tool calls. \nUsing the todo list here is overkill and wastes time and tokens. These three tool calls should be made in parallel, in fact.\n</reasoning>\n</example>\n\n\n## Task States and Management\n\n1. **Task States**: Use these states to track progress:\n   - pending: Task not yet started\n   - in_progress: Currently working on (you can have multiple tasks in_progress at a time if they are not related to each other and can be run in parallel)\n   - completed: Task finished successfully\n\n2. **Task Management**:\n   - Update task status in real-time as you work\n   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)\n   - Complete current tasks before starting new ones\n   - Remove tasks that are no longer relevant from the list entirely\n   - IMPORTANT: When you write this todo list, you should mark your first task (or tasks) as in_progress immediately!.\n   - IMPORTANT: Unless all tasks are completed, you should always have at least one task in_progress to show the user that you are working on something.\n\n3. **Task Completion Requirements**:\n   - ONLY mark a task as completed when you have FULLY accomplished it\n   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress\n   - When blocked, create a new task describing what needs to be resolved\n   - Never mark a task as completed if:\n     - There are unresolved issues or errors\n     - Work is partial or incomplete\n     - You encountered blockers that prevent completion\n     - You couldn't find necessary resources or dependencies\n     - Quality standards haven't been met\n\n4. **Task Breakdown**:\n   - Create specific, actionable items\n   - Break complex tasks into smaller, manageable steps\n   - Use clear, descriptive task names\n\nBeing proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully\nRemember: If you only need to make a few tool calls to complete a task, and it is clear what you need to do, it is better to just do the task directly and NOT call this tool at all.`;\n\nexport 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.`;\n\nconst TodoStatus = z\n  .enum([\"pending\", \"in_progress\", \"completed\"])\n  .describe(\"Status of the todo\");\nconst TodoSchema = z.object({\n  content: z.string().describe(\"Content of the todo item\"),\n  status: TodoStatus,\n});\nconst stateSchema = z.object({\n  todos: z.array(TodoSchema).default([]),\n});\nexport type TodoMiddlewareState = z.infer<typeof stateSchema>;\n\nexport interface TodoListMiddlewareOptions {\n  /**\n   * Custom system prompt to guide the agent on using the todo tool.\n   * If not provided, uses the default {@link PLANNING_MIDDLEWARE_SYSTEM_PROMPT}.\n   */\n  systemPrompt?: string;\n  /**\n   * Custom description for the {@link writeTodos} tool.\n   * If not provided, uses the default {@link WRITE_TODOS_DESCRIPTION}.\n   */\n  toolDescription?: string;\n}\n\n/**\n * Creates a middleware that provides todo list management capabilities to agents.\n *\n * This middleware adds a `write_todos` tool that allows agents to create and manage\n * structured task lists for complex multi-step operations. It's designed to help\n * agents track progress, organize complex tasks, and provide users with visibility\n * into task completion status.\n *\n * The middleware automatically injects system prompts that guide the agent on when\n * and how to use the todo functionality effectively.\n *\n * @example\n * ```typescript\n * import { todoListMiddleware, createAgent } from 'langchain';\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   middleware: [todoListMiddleware()],\n * });\n *\n * // Agent now has access to write_todos tool and todo state tracking\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Help me refactor my codebase\")]\n * });\n *\n * console.log(result.todos); // Array of todo items with status tracking\n * ```\n *\n * @returns A configured middleware instance that provides todo management capabilities\n *\n * @see {@link TodoMiddlewareState} for the state schema\n * @see {@link writeTodos} for the tool implementation\n */\nexport function todoListMiddleware(options?: TodoListMiddlewareOptions) {\n  /**\n   * Write todos tool - manages todo list with Command return\n   */\n  const writeTodos = tool(\n    ({ todos }, config) => {\n      return new Command({\n        update: {\n          todos,\n          messages: [\n            new ToolMessage({\n              content: `Updated todo list to ${JSON.stringify(todos)}`,\n              tool_call_id: config.toolCall?.id as string,\n            }),\n          ],\n        },\n      });\n    },\n    {\n      name: \"write_todos\",\n      description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,\n      schema: z.object({\n        todos: z.array(TodoSchema).describe(\"List of todo items to update\"),\n      }),\n    }\n  );\n\n  return createMiddleware({\n    name: \"todoListMiddleware\",\n    stateSchema,\n    tools: [writeTodos],\n    wrapModelCall: (request, handler) =>\n      handler({\n        ...request,\n        systemMessage: request.systemMessage.concat(\n          `\\n\\n${options?.systemPrompt ?? TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT}`\n        ),\n      }),\n  });\n}\n"],"mappings":";;;;;;;;;;;;AAWA,MAAM,0BAA0B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qLAoNoJ,CAAC;AAEtL,MAAa,qCAAqC,CAAC;;;;;;;;;;;;kJAY+F,CAAC;AAEnJ,MAAM,aAAa,EAChB,KAAK;CAAC;CAAW;CAAe;AAAY,EAAC,CAC7C,SAAS,qBAAqB;AACjC,MAAM,aAAa,EAAE,OAAO;CAC1B,SAAS,EAAE,QAAQ,CAAC,SAAS,2BAA2B;CACxD,QAAQ;AACT,EAAC;AACF,MAAM,cAAc,EAAE,OAAO,EAC3B,OAAO,EAAE,MAAM,WAAW,CAAC,QAAQ,CAAE,EAAC,CACvC,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDF,SAAgB,mBAAmBA,SAAqC;;;;CAItE,MAAM,aAAa,KACjB,CAAC,EAAE,OAAO,EAAE,WAAW;AACrB,SAAO,IAAI,QAAQ,EACjB,QAAQ;GACN;GACA,UAAU,CACR,IAAI,YAAY;IACd,SAAS,CAAC,qBAAqB,EAAE,KAAK,UAAU,MAAM,EAAE;IACxD,cAAc,OAAO,UAAU;GAChC,EACF;EACF,EACF;CACF,GACD;EACE,MAAM;EACN,aAAa,SAAS,mBAAmB;EACzC,QAAQ,EAAE,OAAO,EACf,OAAO,EAAE,MAAM,WAAW,CAAC,SAAS,+BAA+B,CACpE,EAAC;CACH,EACF;AAED,QAAO,iBAAiB;EACtB,MAAM;EACN;EACA,OAAO,CAAC,UAAW;EACnB,eAAe,CAAC,SAAS,YACvB,QAAQ;GACN,GAAG;GACH,eAAe,QAAQ,cAAc,OACnC,CAAC,IAAI,EAAE,SAAS,gBAAgB,oCAAoC,CACrE;EACF,EAAC;CACL,EAAC;AACH"}

package/dist/agents/middleware/toolRetry.cjs

@@ -1,53 +1,29 @@
 const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
 const require_utils = require('./utils.cjs');
 const require_middleware = require('../middleware.cjs');
+const require_constants = require('./constants.cjs');
+const require_error = require('./error.cjs');
 const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
 const zod_v3 = require_rolldown_runtime.__toESM(require("zod/v3"));
 
 //#region src/agents/middleware/toolRetry.ts
 /**
-* Calculate delay for a retry attempt with exponential backoff and jitter.
-*
-* @param retryNumber - The retry attempt number (0-indexed)
-* @param config - Configuration for backoff calculation
-* @returns Delay in milliseconds before next retry
-*
-* @internal Exported for testing purposes
-*/
-function calculateRetryDelay(config, retryNumber) {
-	const { backoffFactor, initialDelayMs, maxDelayMs, jitter } = config;
-	let delay;
-	if (backoffFactor === 0) delay = initialDelayMs;
-	else delay = initialDelayMs * backoffFactor ** retryNumber;
-	delay = Math.min(delay, maxDelayMs);
-	if (jitter && delay > 0) {
-		const jitterAmount = delay * .25;
-		delay = delay + (Math.random() * 2 - 1) * jitterAmount;
-		delay = Math.max(0, delay);
-	}
-	return delay;
-}
-/**
 * Configuration options for the Tool Retry Middleware.
 */
 const ToolRetryMiddlewareOptionsSchema = zod_v3.z.object({
-	maxRetries: zod_v3.z.number().min(0).default(2),
 	tools: zod_v3.z.array(zod_v3.z.union([
 		zod_v3.z.custom(),
 		zod_v3.z.custom(),
 		zod_v3.z.string()
 	])).optional(),
-	retryOn: zod_v3.z.union([zod_v3.z.function().args(zod_v3.z.instanceof(Error)).returns(zod_v3.z.boolean()), zod_v3.z.array(zod_v3.z.custom())]).default(() => () => true),
 	onFailure: zod_v3.z.union([
+		zod_v3.z.literal("error"),
+		zod_v3.z.literal("continue"),
 		zod_v3.z.literal("raise"),
 		zod_v3.z.literal("return_message"),
 		zod_v3.z.function().args(zod_v3.z.instanceof(Error)).returns(zod_v3.z.string())
-	]).default("return_message"),
-	backoffFactor: zod_v3.z.number().min(0).default(2),
-	initialDelayMs: zod_v3.z.number().min(0).default(1e3),
-	maxDelayMs: zod_v3.z.number().min(0).default(6e4),
-	jitter: zod_v3.z.boolean().default(true)
-});
+	]).default("continue")
+}).merge(require_constants.RetrySchema);
 /**
 * Middleware that automatically retries failed tool calls with configurable backoff.
 *
@@ -148,7 +124,17 @@ const ToolRetryMiddlewareOptionsSchema = zod_v3.z.object({
 * @returns A middleware instance that handles tool failures with retries
 */
 function toolRetryMiddleware(config = {}) {
-	const { maxRetries, tools, retryOn, onFailure, backoffFactor, initialDelayMs, maxDelayMs, jitter } = ToolRetryMiddlewareOptionsSchema.parse(config);
+	const { success, error, data } = ToolRetryMiddlewareOptionsSchema.safeParse(config);
+	if (!success) throw new require_error.InvalidRetryConfigError(error);
+	const { maxRetries, tools, retryOn, onFailure: onFailureConfig, backoffFactor, initialDelayMs, maxDelayMs, jitter } = data;
+	let onFailure = onFailureConfig;
+	if (onFailureConfig === "raise") {
+		console.warn("⚠️ `onFailure: 'raise'` is deprecated. Use `onFailure: 'error'` instead.");
+		onFailure = "error";
+	} else if (onFailureConfig === "return_message") {
+		console.warn("⚠️ `onFailure: 'return_message'` is deprecated. Use `onFailure: 'continue'` instead.");
+		onFailure = "continue";
+	}
 	const toolFilter = [];
 	for (const tool of tools ?? []) if (typeof tool === "string") toolFilter.push(tool);
 	else if ("name" in tool && typeof tool.name === "string") toolFilter.push(tool.name);
@@ -163,9 +149,11 @@ function toolRetryMiddleware(config = {}) {
 	/**
 	* Check if the exception should trigger a retry.
 	*/
-	const shouldRetryException = (error) => {
-		if (typeof retryOn === "function") return retryOn(error);
-		return retryOn.some((ErrorConstructor) => error.constructor === ErrorConstructor);
+	const shouldRetryException = (error$1) => {
+		if (typeof retryOn === "function") return retryOn(error$1);
+		return retryOn.some((ErrorConstructor) => {
+			return error$1 instanceof ErrorConstructor;
+		});
 	};
 	const delayConfig = {
 		backoffFactor,
@@ -176,19 +164,19 @@ function toolRetryMiddleware(config = {}) {
 	/**
 	* Format the failure message when retries are exhausted.
 	*/
-	const formatFailureMessage = (toolName, error, attemptsMade) => {
-		const errorType = error.constructor.name;
+	const formatFailureMessage = (toolName, error$1, attemptsMade) => {
+		const errorType = error$1.constructor.name;
 		const attemptWord = attemptsMade === 1 ? "attempt" : "attempts";
 		return `Tool '${toolName}' failed after ${attemptsMade} ${attemptWord} with ${errorType}`;
 	};
 	/**
 	* Handle failure when all retries are exhausted.
 	*/
-	const handleFailure = (toolName, toolCallId, error, attemptsMade) => {
-		if (onFailure === "raise") throw error;
+	const handleFailure = (toolName, toolCallId, error$1, attemptsMade) => {
+		if (onFailure === "error") throw error$1;
 		let content;
-		if (typeof onFailure === "function") content = onFailure(error);
-		else content = formatFailureMessage(toolName, error, attemptsMade);
+		if (typeof onFailure === "function") content = onFailure(error$1);
+		else content = formatFailureMessage(toolName, error$1, attemptsMade);
 		return new __langchain_core_messages.ToolMessage({
 			content,
 			tool_call_id: toolCallId,
@@ -200,17 +188,17 @@ function toolRetryMiddleware(config = {}) {
 		name: "toolRetryMiddleware",
 		contextSchema: ToolRetryMiddlewareOptionsSchema,
 		wrapToolCall: async (request, handler) => {
-			const toolName = request.tool.name;
+			const toolName = request.tool?.name ?? request.toolCall.name;
 			if (!shouldRetryTool(toolName)) return handler(request);
 			const toolCallId = request.toolCall.id ?? "";
 			for (let attempt = 0; attempt <= maxRetries; attempt++) try {
 				return await handler(request);
-			} catch (error) {
+			} catch (error$1) {
 				const attemptsMade = attempt + 1;
-				const err = error && typeof error === "object" && "message" in error ? error : new Error(String(error));
+				const err = error$1 && typeof error$1 === "object" && "message" in error$1 ? error$1 : new Error(String(error$1));
 				if (!shouldRetryException(err)) return handleFailure(toolName, toolCallId, err, attemptsMade);
 				if (attempt < maxRetries) {
-					const delay = calculateRetryDelay(delayConfig, attempt);
+					const delay = require_utils.calculateRetryDelay(delayConfig, attempt);
 					if (delay > 0) await require_utils.sleep(delay);
 				} else return handleFailure(toolName, toolCallId, err, attemptsMade);
 			}

package/dist/agents/middleware/toolRetry.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"toolRetry.cjs","names":["config: {\n    backoffFactor: number;\n    initialDelayMs: number;\n    maxDelayMs: number;\n    jitter: boolean;\n  }","retryNumber: number","delay: number","z","config: ToolRetryMiddlewareConfig","toolFilter: string[]","toolName: string","error: Error","attemptsMade: number","toolCallId: string","content: string","ToolMessage","createMiddleware","sleep"],"sources":["../../../src/agents/middleware/toolRetry.ts"],"sourcesContent":["/**\n * Tool retry middleware for agents.\n */\nimport { z } from \"zod/v3\";\nimport { ToolMessage } from \"@langchain/core/messages\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\n\nimport { createMiddleware } from \"../middleware.js\";\nimport type { AgentMiddleware } from \"./types.js\";\nimport { sleep } from \"./utils.js\";\n\n/**\n * Calculate delay for a retry attempt with exponential backoff and jitter.\n *\n * @param retryNumber - The retry attempt number (0-indexed)\n * @param config - Configuration for backoff calculation\n * @returns Delay in milliseconds before next retry\n *\n * @internal Exported for testing purposes\n */\nexport function calculateRetryDelay(\n  config: {\n    backoffFactor: number;\n    initialDelayMs: number;\n    maxDelayMs: number;\n    jitter: boolean;\n  },\n  retryNumber: number\n): number {\n  const { backoffFactor, initialDelayMs, maxDelayMs, jitter } = config;\n\n  let delay: number;\n  if (backoffFactor === 0.0) {\n    delay = initialDelayMs;\n  } else {\n    delay = initialDelayMs * backoffFactor ** retryNumber;\n  }\n\n  // Cap at maxDelayMs\n  delay = Math.min(delay, maxDelayMs);\n\n  if (jitter && delay > 0) {\n    const jitterAmount = delay * 0.25;\n    delay = delay + (Math.random() * 2 - 1) * jitterAmount;\n    // Ensure delay is not negative after jitter\n    delay = Math.max(0, delay);\n  }\n\n  return delay;\n}\n\n/**\n * Configuration options for the Tool Retry Middleware.\n */\nexport const ToolRetryMiddlewareOptionsSchema = z.object({\n  /**\n   * Maximum number of retry attempts after the initial call.\n   * Default is 2 retries (3 total attempts). Must be >= 0.\n   */\n  maxRetries: z.number().min(0).default(2),\n\n  /**\n   * Optional list of tools or tool names to apply retry logic to.\n   * Can be a list of `BaseTool` instances or tool name strings.\n   * If `undefined`, applies to all tools. Default is `undefined`.\n   */\n  tools: z\n    .array(\n      z.union([z.custom<ClientTool>(), z.custom<ServerTool>(), z.string()])\n    )\n    .optional(),\n\n  /**\n   * Either an array of error constructors to retry on, or a function\n   * that takes an error and returns `true` if it should be retried.\n   * Default is to retry on all errors.\n   */\n  retryOn: z\n    .union([\n      z.function().args(z.instanceof(Error)).returns(z.boolean()),\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      z.array(z.custom<new (...args: any[]) => Error>()),\n    ])\n    .default(() => () => true),\n\n  /**\n   * Behavior when all retries are exhausted. Options:\n   * - `\"return_message\"` (default): Return a ToolMessage with error details,\n   *   allowing the LLM to handle the failure and potentially recover.\n   * - `\"raise\"`: Re-raise the exception, stopping agent execution.\n   * - Custom function: Function that takes the exception and returns a string\n   *   for the ToolMessage content, allowing custom error formatting.\n   */\n  onFailure: z\n    .union([\n      z.literal(\"raise\"),\n      z.literal(\"return_message\"),\n      z.function().args(z.instanceof(Error)).returns(z.string()),\n    ])\n    .default(\"return_message\"),\n\n  /**\n   * Multiplier for exponential backoff. Each retry waits\n   * `initialDelayMs * (backoffFactor ** retryNumber)` milliseconds.\n   * Set to 0.0 for constant delay. Default is 2.0.\n   */\n  backoffFactor: z.number().min(0).default(2.0),\n\n  /**\n   * Initial delay in milliseconds before first retry. Default is 1000 (1 second).\n   */\n  initialDelayMs: z.number().min(0).default(1000),\n\n  /**\n   * Maximum delay in milliseconds between retries. Caps exponential\n   * backoff growth. Default is 60000 (60 seconds).\n   */\n  maxDelayMs: z.number().min(0).default(60000),\n\n  /**\n   * Whether to add random jitter (±25%) to delay to avoid thundering herd.\n   * Default is `true`.\n   */\n  jitter: z.boolean().default(true),\n});\n\nexport type ToolRetryMiddlewareConfig = z.input<\n  typeof ToolRetryMiddlewareOptionsSchema\n>;\n\n/**\n * Middleware that automatically retries failed tool calls with configurable backoff.\n *\n * Supports retrying on specific exceptions and exponential backoff.\n *\n * @example Basic usage with default settings (2 retries, exponential backoff)\n * ```ts\n * import { createAgent, toolRetryMiddleware } from \"langchain\";\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [searchTool],\n *   middleware: [toolRetryMiddleware()],\n * });\n * ```\n *\n * @example Retry specific exceptions only\n * ```ts\n * import { toolRetryMiddleware } from \"langchain\";\n *\n * const retry = toolRetryMiddleware({\n *   maxRetries: 4,\n *   retryOn: [TimeoutError, NetworkError],\n *   backoffFactor: 1.5,\n * });\n * ```\n *\n * @example Custom exception filtering\n * ```ts\n * function shouldRetry(error: Error): boolean {\n *   // Only retry on 5xx errors\n *   if (error.name === \"HTTPError\" && \"statusCode\" in error) {\n *     const statusCode = (error as any).statusCode;\n *     return 500 <= statusCode && statusCode < 600;\n *   }\n *   return false;\n * }\n *\n * const retry = toolRetryMiddleware({\n *   maxRetries: 3,\n *   retryOn: shouldRetry,\n * });\n * ```\n *\n * @example Apply to specific tools with custom error handling\n * ```ts\n * const formatError = (error: Error) =>\n *   \"Database temporarily unavailable. Please try again later.\";\n *\n * const retry = toolRetryMiddleware({\n *   maxRetries: 4,\n *   tools: [\"search_database\"],\n *   onFailure: formatError,\n * });\n * ```\n *\n * @example Apply to specific tools using BaseTool instances\n * ```ts\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n *\n * const searchDatabase = tool(\n *   async ({ query }) => {\n *     // Search implementation\n *     return results;\n *   },\n *   {\n *     name: \"search_database\",\n *     description: \"Search the database\",\n *     schema: z.object({ query: z.string() }),\n *   }\n * );\n *\n * const retry = toolRetryMiddleware({\n *   maxRetries: 4,\n *   tools: [searchDatabase], // Pass BaseTool instance\n * });\n * ```\n *\n * @example Constant backoff (no exponential growth)\n * ```ts\n * const retry = toolRetryMiddleware({\n *   maxRetries: 5,\n *   backoffFactor: 0.0, // No exponential growth\n *   initialDelayMs: 2000, // Always wait 2 seconds\n * });\n * ```\n *\n * @example Raise exception on failure\n * ```ts\n * const retry = toolRetryMiddleware({\n *   maxRetries: 2,\n *   onFailure: \"raise\", // Re-raise exception instead of returning message\n * });\n * ```\n *\n * @param config - Configuration options for the retry middleware\n * @returns A middleware instance that handles tool failures with retries\n */\nexport function toolRetryMiddleware(\n  config: ToolRetryMiddlewareConfig = {}\n): AgentMiddleware {\n  const {\n    maxRetries,\n    tools,\n    retryOn,\n    onFailure,\n    backoffFactor,\n    initialDelayMs,\n    maxDelayMs,\n    jitter,\n  } = ToolRetryMiddlewareOptionsSchema.parse(config);\n\n  // Extract tool names from BaseTool instances or strings\n  const toolFilter: string[] = [];\n  for (const tool of tools ?? []) {\n    if (typeof tool === \"string\") {\n      toolFilter.push(tool);\n    } else if (\"name\" in tool && typeof tool.name === \"string\") {\n      toolFilter.push(tool.name);\n    } else {\n      throw new TypeError(\n        \"Expected a tool name string or tool instance to be passed to toolRetryMiddleware\"\n      );\n    }\n  }\n\n  /**\n   * Check if retry logic should apply to this tool.\n   */\n  const shouldRetryTool = (toolName: string): boolean => {\n    if (toolFilter.length === 0) {\n      return true;\n    }\n    return toolFilter.includes(toolName);\n  };\n\n  /**\n   * Check if the exception should trigger a retry.\n   */\n  const shouldRetryException = (error: Error): boolean => {\n    if (typeof retryOn === \"function\") {\n      return retryOn(error);\n    }\n    // retryOn is an array of error constructors\n    return retryOn.some(\n      (ErrorConstructor) => error.constructor === ErrorConstructor\n    );\n  };\n\n  // Use the exported calculateRetryDelay function with our config\n  const delayConfig = { backoffFactor, initialDelayMs, maxDelayMs, jitter };\n\n  /**\n   * Format the failure message when retries are exhausted.\n   */\n  const formatFailureMessage = (\n    toolName: string,\n    error: Error,\n    attemptsMade: number\n  ): string => {\n    const errorType = error.constructor.name;\n    const attemptWord = attemptsMade === 1 ? \"attempt\" : \"attempts\";\n    return `Tool '${toolName}' failed after ${attemptsMade} ${attemptWord} with ${errorType}`;\n  };\n\n  /**\n   * Handle failure when all retries are exhausted.\n   */\n  const handleFailure = (\n    toolName: string,\n    toolCallId: string,\n    error: Error,\n    attemptsMade: number\n  ): ToolMessage => {\n    if (onFailure === \"raise\") {\n      throw error;\n    }\n\n    let content: string;\n    if (typeof onFailure === \"function\") {\n      content = onFailure(error);\n    } else {\n      content = formatFailureMessage(toolName, error, attemptsMade);\n    }\n\n    return new ToolMessage({\n      content,\n      tool_call_id: toolCallId,\n      name: toolName,\n      status: \"error\",\n    });\n  };\n\n  return createMiddleware({\n    name: \"toolRetryMiddleware\",\n    contextSchema: ToolRetryMiddlewareOptionsSchema,\n    wrapToolCall: async (request, handler) => {\n      const toolName = request.tool.name as string;\n\n      // Check if retry should apply to this tool\n      if (!shouldRetryTool(toolName)) {\n        return handler(request);\n      }\n\n      const toolCallId = request.toolCall.id ?? \"\";\n\n      // Initial attempt + retries\n      for (let attempt = 0; attempt <= maxRetries; attempt++) {\n        try {\n          return await handler(request);\n        } catch (error) {\n          const attemptsMade = attempt + 1; // attempt is 0-indexed\n\n          // Ensure error is an Error instance\n          const err =\n            error && typeof error === \"object\" && \"message\" in error\n              ? (error as Error)\n              : new Error(String(error));\n\n          // Check if we should retry this exception\n          if (!shouldRetryException(err)) {\n            // Exception is not retryable, handle failure immediately\n            return handleFailure(toolName, toolCallId, err, attemptsMade);\n          }\n\n          // Check if we have more retries left\n          if (attempt < maxRetries) {\n            // Calculate and apply backoff delay\n            const delay = calculateRetryDelay(delayConfig, attempt);\n            if (delay > 0) {\n              await sleep(delay);\n            }\n            // Continue to next retry\n          } else {\n            // No more retries, handle failure\n            return handleFailure(toolName, toolCallId, err, attemptsMade);\n          }\n        }\n      }\n\n      // Unreachable: loop always returns via handler success or handleFailure\n      throw new Error(\"Unexpected: retry loop completed without returning\");\n    },\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"toolRetry.cjs","names":["z","RetrySchema","config: ToolRetryMiddlewareConfig","InvalidRetryConfigError","toolFilter: string[]","toolName: string","error: Error","error","attemptsMade: number","toolCallId: string","content: string","ToolMessage","createMiddleware","calculateRetryDelay","sleep"],"sources":["../../../src/agents/middleware/toolRetry.ts"],"sourcesContent":["/**\n * Tool retry middleware for agents.\n */\nimport { z } from \"zod/v3\";\nimport { ToolMessage } from \"@langchain/core/messages\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\n\nimport { createMiddleware } from \"../middleware.js\";\nimport type { AgentMiddleware } from \"./types.js\";\nimport { sleep, calculateRetryDelay } from \"./utils.js\";\nimport { RetrySchema } from \"./constants.js\";\nimport { InvalidRetryConfigError } from \"./error.js\";\n\n/**\n * Configuration options for the Tool Retry Middleware.\n */\nexport const ToolRetryMiddlewareOptionsSchema = z\n  .object({\n    /**\n     * Optional list of tools or tool names to apply retry logic to.\n     * Can be a list of `BaseTool` instances or tool name strings.\n     * If `undefined`, applies to all tools. Default is `undefined`.\n     */\n    tools: z\n      .array(\n        z.union([z.custom<ClientTool>(), z.custom<ServerTool>(), z.string()])\n      )\n      .optional(),\n\n    /**\n     * Behavior when all retries are exhausted. Options:\n     * - `\"continue\"` (default): Return an AIMessage with error details, allowing\n     *   the agent to potentially handle the failure gracefully.\n     * - `\"error\"`: Re-raise the exception, stopping agent execution.\n     * - Custom function: Function that takes the exception and returns a string\n     *   for the AIMessage content, allowing custom error formatting.\n     *\n     * Deprecated values:\n     * - `\"raise\"`: use `\"error\"` instead.\n     * - `\"return_message\"`: use `\"continue\"` instead.\n     */\n    onFailure: z\n      .union([\n        z.literal(\"error\"),\n        z.literal(\"continue\"),\n        /**\n         * @deprecated Use `\"error\"` instead.\n         */\n        z.literal(\"raise\"),\n        /**\n         * @deprecated Use `\"continue\"` instead.\n         */\n        z.literal(\"return_message\"),\n        z.function().args(z.instanceof(Error)).returns(z.string()),\n      ])\n      .default(\"continue\"),\n  })\n  .merge(RetrySchema);\n\nexport type ToolRetryMiddlewareConfig = z.input<\n  typeof ToolRetryMiddlewareOptionsSchema\n>;\n\n/**\n * Middleware that automatically retries failed tool calls with configurable backoff.\n *\n * Supports retrying on specific exceptions and exponential backoff.\n *\n * @example Basic usage with default settings (2 retries, exponential backoff)\n * ```ts\n * import { createAgent, toolRetryMiddleware } from \"langchain\";\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [searchTool],\n *   middleware: [toolRetryMiddleware()],\n * });\n * ```\n *\n * @example Retry specific exceptions only\n * ```ts\n * import { toolRetryMiddleware } from \"langchain\";\n *\n * const retry = toolRetryMiddleware({\n *   maxRetries: 4,\n *   retryOn: [TimeoutError, NetworkError],\n *   backoffFactor: 1.5,\n * });\n * ```\n *\n * @example Custom exception filtering\n * ```ts\n * function shouldRetry(error: Error): boolean {\n *   // Only retry on 5xx errors\n *   if (error.name === \"HTTPError\" && \"statusCode\" in error) {\n *     const statusCode = (error as any).statusCode;\n *     return 500 <= statusCode && statusCode < 600;\n *   }\n *   return false;\n * }\n *\n * const retry = toolRetryMiddleware({\n *   maxRetries: 3,\n *   retryOn: shouldRetry,\n * });\n * ```\n *\n * @example Apply to specific tools with custom error handling\n * ```ts\n * const formatError = (error: Error) =>\n *   \"Database temporarily unavailable. Please try again later.\";\n *\n * const retry = toolRetryMiddleware({\n *   maxRetries: 4,\n *   tools: [\"search_database\"],\n *   onFailure: formatError,\n * });\n * ```\n *\n * @example Apply to specific tools using BaseTool instances\n * ```ts\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n *\n * const searchDatabase = tool(\n *   async ({ query }) => {\n *     // Search implementation\n *     return results;\n *   },\n *   {\n *     name: \"search_database\",\n *     description: \"Search the database\",\n *     schema: z.object({ query: z.string() }),\n *   }\n * );\n *\n * const retry = toolRetryMiddleware({\n *   maxRetries: 4,\n *   tools: [searchDatabase], // Pass BaseTool instance\n * });\n * ```\n *\n * @example Constant backoff (no exponential growth)\n * ```ts\n * const retry = toolRetryMiddleware({\n *   maxRetries: 5,\n *   backoffFactor: 0.0, // No exponential growth\n *   initialDelayMs: 2000, // Always wait 2 seconds\n * });\n * ```\n *\n * @example Raise exception on failure\n * ```ts\n * const retry = toolRetryMiddleware({\n *   maxRetries: 2,\n *   onFailure: \"raise\", // Re-raise exception instead of returning message\n * });\n * ```\n *\n * @param config - Configuration options for the retry middleware\n * @returns A middleware instance that handles tool failures with retries\n */\nexport function toolRetryMiddleware(\n  config: ToolRetryMiddlewareConfig = {}\n): AgentMiddleware {\n  const { success, error, data } =\n    ToolRetryMiddlewareOptionsSchema.safeParse(config);\n  if (!success) {\n    throw new InvalidRetryConfigError(error);\n  }\n  const {\n    maxRetries,\n    tools,\n    retryOn,\n    onFailure: onFailureConfig,\n    backoffFactor,\n    initialDelayMs,\n    maxDelayMs,\n    jitter,\n  } = data;\n\n  let onFailure = onFailureConfig;\n  if (onFailureConfig === \"raise\") {\n    console.warn(\n      \"⚠️ `onFailure: 'raise'` is deprecated. Use `onFailure: 'error'` instead.\"\n    );\n    onFailure = \"error\";\n  } else if (onFailureConfig === \"return_message\") {\n    console.warn(\n      \"⚠️ `onFailure: 'return_message'` is deprecated. Use `onFailure: 'continue'` instead.\"\n    );\n    onFailure = \"continue\";\n  }\n\n  // Extract tool names from BaseTool instances or strings\n  const toolFilter: string[] = [];\n  for (const tool of tools ?? []) {\n    if (typeof tool === \"string\") {\n      toolFilter.push(tool);\n    } else if (\"name\" in tool && typeof tool.name === \"string\") {\n      toolFilter.push(tool.name);\n    } else {\n      throw new TypeError(\n        \"Expected a tool name string or tool instance to be passed to toolRetryMiddleware\"\n      );\n    }\n  }\n\n  /**\n   * Check if retry logic should apply to this tool.\n   */\n  const shouldRetryTool = (toolName: string): boolean => {\n    if (toolFilter.length === 0) {\n      return true;\n    }\n    return toolFilter.includes(toolName);\n  };\n\n  /**\n   * Check if the exception should trigger a retry.\n   */\n  const shouldRetryException = (error: Error): boolean => {\n    if (typeof retryOn === \"function\") {\n      return retryOn(error);\n    }\n    // retryOn is an array of error constructors\n    return retryOn.some((ErrorConstructor) => {\n      // eslint-disable-next-line no-instanceof/no-instanceof\n      return error instanceof ErrorConstructor;\n    });\n  };\n\n  // Use the exported calculateRetryDelay function with our config\n  const delayConfig = { backoffFactor, initialDelayMs, maxDelayMs, jitter };\n\n  /**\n   * Format the failure message when retries are exhausted.\n   */\n  const formatFailureMessage = (\n    toolName: string,\n    error: Error,\n    attemptsMade: number\n  ): string => {\n    const errorType = error.constructor.name;\n    const attemptWord = attemptsMade === 1 ? \"attempt\" : \"attempts\";\n    return `Tool '${toolName}' failed after ${attemptsMade} ${attemptWord} with ${errorType}`;\n  };\n\n  /**\n   * Handle failure when all retries are exhausted.\n   */\n  const handleFailure = (\n    toolName: string,\n    toolCallId: string,\n    error: Error,\n    attemptsMade: number\n  ): ToolMessage => {\n    if (onFailure === \"error\") {\n      throw error;\n    }\n\n    let content: string;\n    if (typeof onFailure === \"function\") {\n      content = onFailure(error);\n    } else {\n      content = formatFailureMessage(toolName, error, attemptsMade);\n    }\n\n    return new ToolMessage({\n      content,\n      tool_call_id: toolCallId,\n      name: toolName,\n      status: \"error\",\n    });\n  };\n\n  return createMiddleware({\n    name: \"toolRetryMiddleware\",\n    contextSchema: ToolRetryMiddlewareOptionsSchema,\n    wrapToolCall: async (request, handler) => {\n      const toolName = (request.tool?.name ?? request.toolCall.name) as string;\n\n      // Check if retry should apply to this tool\n      if (!shouldRetryTool(toolName)) {\n        return handler(request);\n      }\n\n      const toolCallId = request.toolCall.id ?? \"\";\n\n      // Initial attempt + retries\n      for (let attempt = 0; attempt <= maxRetries; attempt++) {\n        try {\n          return await handler(request);\n        } catch (error) {\n          const attemptsMade = attempt + 1; // attempt is 0-indexed\n\n          // Ensure error is an Error instance\n          const err =\n            error && typeof error === \"object\" && \"message\" in error\n              ? (error as Error)\n              : new Error(String(error));\n\n          // Check if we should retry this exception\n          if (!shouldRetryException(err)) {\n            // Exception is not retryable, handle failure immediately\n            return handleFailure(toolName, toolCallId, err, attemptsMade);\n          }\n\n          // Check if we have more retries left\n          if (attempt < maxRetries) {\n            // Calculate and apply backoff delay\n            const delay = calculateRetryDelay(delayConfig, attempt);\n            if (delay > 0) {\n              await sleep(delay);\n            }\n            // Continue to next retry\n          } else {\n            // No more retries, handle failure\n            return handleFailure(toolName, toolCallId, err, attemptsMade);\n          }\n        }\n      }\n\n      // Unreachable: loop always returns via handler success or handleFailure\n      throw new Error(\"Unexpected: retry loop completed without returning\");\n    },\n  });\n}\n"],"mappings":"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"}

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

@@ -8,70 +8,50 @@ import { z } from "zod/v3";
  * Configuration options for the Tool Retry Middleware.
  */
 declare const ToolRetryMiddlewareOptionsSchema: z.ZodObject<{
-  /**
-   * Maximum number of retry attempts after the initial call.
-   * Default is 2 retries (3 total attempts). Must be >= 0.
-   */
-  maxRetries: z.ZodDefault<z.ZodNumber>;
   /**
    * Optional list of tools or tool names to apply retry logic to.
    * Can be a list of `BaseTool` instances or tool name strings.
    * If `undefined`, applies to all tools. Default is `undefined`.
    */
   tools: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodType<ClientTool, z.ZodTypeDef, ClientTool>, z.ZodType<ServerTool, z.ZodTypeDef, ServerTool>, z.ZodString]>, "many">>;
-  /**
-   * Either an array of error constructors to retry on, or a function
-   * that takes an error and returns `true` if it should be retried.
-   * Default is to retry on all errors.
-   */
-  retryOn: z.ZodDefault<z.ZodUnion<[z.ZodFunction<z.ZodTuple<[z.ZodType<Error, z.ZodTypeDef, Error>], z.ZodUnknown>, z.ZodBoolean>, z.ZodArray<z.ZodType<new (...args: any[]) => Error, z.ZodTypeDef, new (...args: any[]) => Error>, "many">]>>;
   /**
    * Behavior when all retries are exhausted. Options:
-   * - `"return_message"` (default): Return a ToolMessage with error details,
-   *   allowing the LLM to handle the failure and potentially recover.
-   * - `"raise"`: Re-raise the exception, stopping agent execution.
+   * - `"continue"` (default): Return an AIMessage with error details, allowing
+   *   the agent to potentially handle the failure gracefully.
+   * - `"error"`: Re-raise the exception, stopping agent execution.
    * - Custom function: Function that takes the exception and returns a string
-   *   for the ToolMessage content, allowing custom error formatting.
-   */
-  onFailure: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"raise">, z.ZodLiteral<"return_message">, z.ZodFunction<z.ZodTuple<[z.ZodType<Error, z.ZodTypeDef, Error>], z.ZodUnknown>, z.ZodString>]>>;
-  /**
-   * Multiplier for exponential backoff. Each retry waits
-   * `initialDelayMs * (backoffFactor ** retryNumber)` milliseconds.
-   * Set to 0.0 for constant delay. Default is 2.0.
+   *   for the AIMessage content, allowing custom error formatting.
+   *
+   * Deprecated values:
+   * - `"raise"`: use `"error"` instead.
+   * - `"return_message"`: use `"continue"` instead.
    */
+  onFailure: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"continue">, z.ZodLiteral<"raise">, z.ZodLiteral<"return_message">, z.ZodFunction<z.ZodTuple<[z.ZodType<Error, z.ZodTypeDef, Error>], z.ZodUnknown>, z.ZodString>]>>;
+} & {
+  maxRetries: z.ZodDefault<z.ZodNumber>;
+  retryOn: z.ZodDefault<z.ZodUnion<[z.ZodFunction<z.ZodTuple<[z.ZodType<Error, z.ZodTypeDef, Error>], z.ZodUnknown>, z.ZodBoolean>, z.ZodArray<z.ZodType<new (...args: any[]) => Error, z.ZodTypeDef, new (...args: any[]) => Error>, "many">]>>;
   backoffFactor: z.ZodDefault<z.ZodNumber>;
-  /**
-   * Initial delay in milliseconds before first retry. Default is 1000 (1 second).
-   */
   initialDelayMs: z.ZodDefault<z.ZodNumber>;
-  /**
-   * Maximum delay in milliseconds between retries. Caps exponential
-   * backoff growth. Default is 60000 (60 seconds).
-   */
   maxDelayMs: z.ZodDefault<z.ZodNumber>;
-  /**
-   * Whether to add random jitter (±25%) to delay to avoid thundering herd.
-   * Default is `true`.
-   */
   jitter: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
   maxRetries: number;
-  tools?: (string | ServerTool | ClientTool)[] | undefined;
   retryOn: (new (...args: any[]) => Error)[] | ((args_0: Error, ...args: unknown[]) => boolean);
-  onFailure: "raise" | "return_message" | ((args_0: Error, ...args: unknown[]) => string);
   backoffFactor: number;
   initialDelayMs: number;
   maxDelayMs: number;
   jitter: boolean;
+  tools?: (string | ServerTool | ClientTool)[] | undefined;
+  onFailure: "continue" | "error" | "raise" | "return_message" | ((args_0: Error, ...args: unknown[]) => string);
 }, {
   maxRetries?: number | undefined;
-  tools?: (string | ServerTool | ClientTool)[] | undefined;
   retryOn?: (new (...args: any[]) => Error)[] | ((args_0: Error, ...args: unknown[]) => boolean) | undefined;
-  onFailure?: "raise" | "return_message" | ((args_0: Error, ...args: unknown[]) => string) | undefined;
   backoffFactor?: number | undefined;
   initialDelayMs?: number | undefined;
   maxDelayMs?: number | undefined;
   jitter?: boolean | undefined;
+  tools?: (string | ServerTool | ClientTool)[] | undefined;
+  onFailure?: "continue" | "error" | "raise" | "return_message" | ((args_0: Error, ...args: unknown[]) => string) | undefined;
 }>;
 type ToolRetryMiddlewareConfig = z.input<typeof ToolRetryMiddlewareOptionsSchema>;
 /**

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

@@ -8,70 +8,50 @@ import { z } from "zod/v3";
  * Configuration options for the Tool Retry Middleware.
  */
 declare const ToolRetryMiddlewareOptionsSchema: z.ZodObject<{
-  /**
-   * Maximum number of retry attempts after the initial call.
-   * Default is 2 retries (3 total attempts). Must be >= 0.
-   */
-  maxRetries: z.ZodDefault<z.ZodNumber>;
   /**
    * Optional list of tools or tool names to apply retry logic to.
    * Can be a list of `BaseTool` instances or tool name strings.
    * If `undefined`, applies to all tools. Default is `undefined`.
    */
   tools: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodType<ClientTool, z.ZodTypeDef, ClientTool>, z.ZodType<ServerTool, z.ZodTypeDef, ServerTool>, z.ZodString]>, "many">>;
-  /**
-   * Either an array of error constructors to retry on, or a function
-   * that takes an error and returns `true` if it should be retried.
-   * Default is to retry on all errors.
-   */
-  retryOn: z.ZodDefault<z.ZodUnion<[z.ZodFunction<z.ZodTuple<[z.ZodType<Error, z.ZodTypeDef, Error>], z.ZodUnknown>, z.ZodBoolean>, z.ZodArray<z.ZodType<new (...args: any[]) => Error, z.ZodTypeDef, new (...args: any[]) => Error>, "many">]>>;
   /**
    * Behavior when all retries are exhausted. Options:
-   * - `"return_message"` (default): Return a ToolMessage with error details,
-   *   allowing the LLM to handle the failure and potentially recover.
-   * - `"raise"`: Re-raise the exception, stopping agent execution.
+   * - `"continue"` (default): Return an AIMessage with error details, allowing
+   *   the agent to potentially handle the failure gracefully.
+   * - `"error"`: Re-raise the exception, stopping agent execution.
    * - Custom function: Function that takes the exception and returns a string
-   *   for the ToolMessage content, allowing custom error formatting.
-   */
-  onFailure: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"raise">, z.ZodLiteral<"return_message">, z.ZodFunction<z.ZodTuple<[z.ZodType<Error, z.ZodTypeDef, Error>], z.ZodUnknown>, z.ZodString>]>>;
-  /**
-   * Multiplier for exponential backoff. Each retry waits
-   * `initialDelayMs * (backoffFactor ** retryNumber)` milliseconds.
-   * Set to 0.0 for constant delay. Default is 2.0.
+   *   for the AIMessage content, allowing custom error formatting.
+   *
+   * Deprecated values:
+   * - `"raise"`: use `"error"` instead.
+   * - `"return_message"`: use `"continue"` instead.
    */
+  onFailure: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"continue">, z.ZodLiteral<"raise">, z.ZodLiteral<"return_message">, z.ZodFunction<z.ZodTuple<[z.ZodType<Error, z.ZodTypeDef, Error>], z.ZodUnknown>, z.ZodString>]>>;
+} & {
+  maxRetries: z.ZodDefault<z.ZodNumber>;
+  retryOn: z.ZodDefault<z.ZodUnion<[z.ZodFunction<z.ZodTuple<[z.ZodType<Error, z.ZodTypeDef, Error>], z.ZodUnknown>, z.ZodBoolean>, z.ZodArray<z.ZodType<new (...args: any[]) => Error, z.ZodTypeDef, new (...args: any[]) => Error>, "many">]>>;
   backoffFactor: z.ZodDefault<z.ZodNumber>;
-  /**
-   * Initial delay in milliseconds before first retry. Default is 1000 (1 second).
-   */
   initialDelayMs: z.ZodDefault<z.ZodNumber>;
-  /**
-   * Maximum delay in milliseconds between retries. Caps exponential
-   * backoff growth. Default is 60000 (60 seconds).
-   */
   maxDelayMs: z.ZodDefault<z.ZodNumber>;
-  /**
-   * Whether to add random jitter (±25%) to delay to avoid thundering herd.
-   * Default is `true`.
-   */
   jitter: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
   maxRetries: number;
-  tools?: (string | ServerTool | ClientTool)[] | undefined;
   retryOn: (new (...args: any[]) => Error)[] | ((args_0: Error, ...args: unknown[]) => boolean);
-  onFailure: "raise" | "return_message" | ((args_0: Error, ...args: unknown[]) => string);
   backoffFactor: number;
   initialDelayMs: number;
   maxDelayMs: number;
   jitter: boolean;
+  tools?: (string | ServerTool | ClientTool)[] | undefined;
+  onFailure: "continue" | "error" | "raise" | "return_message" | ((args_0: Error, ...args: unknown[]) => string);
 }, {
   maxRetries?: number | undefined;
-  tools?: (string | ServerTool | ClientTool)[] | undefined;
   retryOn?: (new (...args: any[]) => Error)[] | ((args_0: Error, ...args: unknown[]) => boolean) | undefined;
-  onFailure?: "raise" | "return_message" | ((args_0: Error, ...args: unknown[]) => string) | undefined;
   backoffFactor?: number | undefined;
   initialDelayMs?: number | undefined;
   maxDelayMs?: number | undefined;
   jitter?: boolean | undefined;
+  tools?: (string | ServerTool | ClientTool)[] | undefined;
+  onFailure?: "continue" | "error" | "raise" | "return_message" | ((args_0: Error, ...args: unknown[]) => string) | undefined;
 }>;
 type ToolRetryMiddlewareConfig = z.input<typeof ToolRetryMiddlewareOptionsSchema>;
 /**

package/dist/agents/middleware/toolRetry.js

@@ -1,52 +1,28 @@
-import { sleep } from "./utils.js";
+import { calculateRetryDelay, sleep } from "./utils.js";
 import { createMiddleware } from "../middleware.js";
+import { RetrySchema } from "./constants.js";
+import { InvalidRetryConfigError } from "./error.js";
 import { ToolMessage } from "@langchain/core/messages";
 import { z } from "zod/v3";
 
 //#region src/agents/middleware/toolRetry.ts
 /**
-* Calculate delay for a retry attempt with exponential backoff and jitter.
-*
-* @param retryNumber - The retry attempt number (0-indexed)
-* @param config - Configuration for backoff calculation
-* @returns Delay in milliseconds before next retry
-*
-* @internal Exported for testing purposes
-*/
-function calculateRetryDelay(config, retryNumber) {
-	const { backoffFactor, initialDelayMs, maxDelayMs, jitter } = config;
-	let delay;
-	if (backoffFactor === 0) delay = initialDelayMs;
-	else delay = initialDelayMs * backoffFactor ** retryNumber;
-	delay = Math.min(delay, maxDelayMs);
-	if (jitter && delay > 0) {
-		const jitterAmount = delay * .25;
-		delay = delay + (Math.random() * 2 - 1) * jitterAmount;
-		delay = Math.max(0, delay);
-	}
-	return delay;
-}
-/**
 * Configuration options for the Tool Retry Middleware.
 */
 const ToolRetryMiddlewareOptionsSchema = z.object({
-	maxRetries: z.number().min(0).default(2),
 	tools: z.array(z.union([
 		z.custom(),
 		z.custom(),
 		z.string()
 	])).optional(),
-	retryOn: z.union([z.function().args(z.instanceof(Error)).returns(z.boolean()), z.array(z.custom())]).default(() => () => true),
 	onFailure: z.union([
+		z.literal("error"),
+		z.literal("continue"),
 		z.literal("raise"),
 		z.literal("return_message"),
 		z.function().args(z.instanceof(Error)).returns(z.string())
-	]).default("return_message"),
-	backoffFactor: z.number().min(0).default(2),
-	initialDelayMs: z.number().min(0).default(1e3),
-	maxDelayMs: z.number().min(0).default(6e4),
-	jitter: z.boolean().default(true)
-});
+	]).default("continue")
+}).merge(RetrySchema);
 /**
 * Middleware that automatically retries failed tool calls with configurable backoff.
 *
@@ -147,7 +123,17 @@ const ToolRetryMiddlewareOptionsSchema = z.object({
 * @returns A middleware instance that handles tool failures with retries
 */
 function toolRetryMiddleware(config = {}) {
-	const { maxRetries, tools, retryOn, onFailure, backoffFactor, initialDelayMs, maxDelayMs, jitter } = ToolRetryMiddlewareOptionsSchema.parse(config);
+	const { success, error, data } = ToolRetryMiddlewareOptionsSchema.safeParse(config);
+	if (!success) throw new InvalidRetryConfigError(error);
+	const { maxRetries, tools, retryOn, onFailure: onFailureConfig, backoffFactor, initialDelayMs, maxDelayMs, jitter } = data;
+	let onFailure = onFailureConfig;
+	if (onFailureConfig === "raise") {
+		console.warn("⚠️ `onFailure: 'raise'` is deprecated. Use `onFailure: 'error'` instead.");
+		onFailure = "error";
+	} else if (onFailureConfig === "return_message") {
+		console.warn("⚠️ `onFailure: 'return_message'` is deprecated. Use `onFailure: 'continue'` instead.");
+		onFailure = "continue";
+	}
 	const toolFilter = [];
 	for (const tool of tools ?? []) if (typeof tool === "string") toolFilter.push(tool);
 	else if ("name" in tool && typeof tool.name === "string") toolFilter.push(tool.name);
@@ -162,9 +148,11 @@ function toolRetryMiddleware(config = {}) {
 	/**
 	* Check if the exception should trigger a retry.
 	*/
-	const shouldRetryException = (error) => {
-		if (typeof retryOn === "function") return retryOn(error);
-		return retryOn.some((ErrorConstructor) => error.constructor === ErrorConstructor);
+	const shouldRetryException = (error$1) => {
+		if (typeof retryOn === "function") return retryOn(error$1);
+		return retryOn.some((ErrorConstructor) => {
+			return error$1 instanceof ErrorConstructor;
+		});
 	};
 	const delayConfig = {
 		backoffFactor,
@@ -175,19 +163,19 @@ function toolRetryMiddleware(config = {}) {
 	/**
 	* Format the failure message when retries are exhausted.
 	*/
-	const formatFailureMessage = (toolName, error, attemptsMade) => {
-		const errorType = error.constructor.name;
+	const formatFailureMessage = (toolName, error$1, attemptsMade) => {
+		const errorType = error$1.constructor.name;
 		const attemptWord = attemptsMade === 1 ? "attempt" : "attempts";
 		return `Tool '${toolName}' failed after ${attemptsMade} ${attemptWord} with ${errorType}`;
 	};
 	/**
 	* Handle failure when all retries are exhausted.
 	*/
-	const handleFailure = (toolName, toolCallId, error, attemptsMade) => {
-		if (onFailure === "raise") throw error;
+	const handleFailure = (toolName, toolCallId, error$1, attemptsMade) => {
+		if (onFailure === "error") throw error$1;
 		let content;
-		if (typeof onFailure === "function") content = onFailure(error);
-		else content = formatFailureMessage(toolName, error, attemptsMade);
+		if (typeof onFailure === "function") content = onFailure(error$1);
+		else content = formatFailureMessage(toolName, error$1, attemptsMade);
 		return new ToolMessage({
 			content,
 			tool_call_id: toolCallId,
@@ -199,14 +187,14 @@ function toolRetryMiddleware(config = {}) {
 		name: "toolRetryMiddleware",
 		contextSchema: ToolRetryMiddlewareOptionsSchema,
 		wrapToolCall: async (request, handler) => {
-			const toolName = request.tool.name;
+			const toolName = request.tool?.name ?? request.toolCall.name;
 			if (!shouldRetryTool(toolName)) return handler(request);
 			const toolCallId = request.toolCall.id ?? "";
 			for (let attempt = 0; attempt <= maxRetries; attempt++) try {
 				return await handler(request);
-			} catch (error) {
+			} catch (error$1) {
 				const attemptsMade = attempt + 1;
-				const err = error && typeof error === "object" && "message" in error ? error : new Error(String(error));
+				const err = error$1 && typeof error$1 === "object" && "message" in error$1 ? error$1 : new Error(String(error$1));
 				if (!shouldRetryException(err)) return handleFailure(toolName, toolCallId, err, attemptsMade);
 				if (attempt < maxRetries) {
 					const delay = calculateRetryDelay(delayConfig, attempt);