langchain 1.5.2 → 1.5.4

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # langchain
 
+## 1.5.4
+
+### Patch Changes
+
+- [#11201](https://github.com/langchain-ai/langchainjs/pull/11201) [`a8cd4d9`](https://github.com/langchain-ai/langchainjs/commit/a8cd4d9ae35ae8ae05e011115a351d976560ade9) Thanks [@hntrl](https://github.com/hntrl)! - feat(langchain): add middleware for handling tool execution errors
+
+## 1.5.3
+
+### Patch Changes
+
+- [#11167](https://github.com/langchain-ai/langchainjs/pull/11167) [`4c7a06e`](https://github.com/langchain-ai/langchainjs/commit/4c7a06ec3e4728bb036a28f678dd8ec2521e1c82) Thanks [@colifran](https://github.com/colifran)! - fix(langchain): malformed tool input schemas are unrecoverable
+
 ## 1.5.2
 
 ### Patch Changes

package/dist/agents/errors.cjs

@@ -32,6 +32,7 @@ var StructuredOutputParsingError = class extends Error {
 * Raised when a tool call is throwing an error.
 */
 var ToolInvocationError = class extends Error {
+	"~brand" = "ToolInvocationError";
 	toolCall;
 	toolError;
 	constructor(toolError, toolCall) {
@@ -41,6 +42,14 @@ var ToolInvocationError = class extends Error {
 		this.toolCall = toolCall;
 		this.toolError = error;
 	}
+	/**
+	* Check if the error is a ToolInvocationError.
+	* @param error - The error to check
+	* @returns Whether the error is a ToolInvocationError
+	*/
+	static isInstance(error) {
+		return error instanceof Error && "~brand" in error && error["~brand"] === "ToolInvocationError";
+	}
 };
 /**
 * Error thrown when a middleware fails.
@@ -49,7 +58,7 @@ var ToolInvocationError = class extends Error {
 * to ensure that GraphBubbleUp errors (like GraphInterrupt) are never wrapped.
 */
 var MiddlewareError = class MiddlewareError extends Error {
-	static "~brand" = "MiddlewareError";
+	"~brand" = "MiddlewareError";
 	constructor(error, middlewareName) {
 		const errorMessage = error instanceof Error ? error.message : String(error);
 		super(errorMessage);

package/dist/agents/errors.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"errors.cjs","names":[],"sources":["../../src/agents/errors.ts"],"sourcesContent":["/* oxlint-disable no-instanceof/no-instanceof */\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport { isGraphBubbleUp } from \"@langchain/langgraph\";\n\nexport class MultipleToolsBoundError extends Error {\n  constructor() {\n    super(\n      \"The provided LLM already has bound tools. \" +\n        \"Please provide an LLM without bound tools to createAgent. \" +\n        \"The agent will bind the tools provided in the 'tools' parameter.\"\n    );\n  }\n}\n\n/**\n * Raised when model returns multiple structured output tool calls when only one is expected.\n */\nexport class MultipleStructuredOutputsError extends Error {\n  public readonly toolNames: string[];\n\n  constructor(toolNames: string[]) {\n    super(\n      `The model has called multiple tools: ${toolNames.join(\n        \", \"\n      )} to return a structured output. ` +\n        \"This is not supported. Please provide a single structured output.\"\n    );\n    this.toolNames = toolNames;\n  }\n}\n\n/**\n * Raised when structured output tool call arguments fail to parse according to the schema.\n */\nexport class StructuredOutputParsingError extends Error {\n  public readonly toolName: string;\n\n  public readonly errors: string[];\n\n  constructor(toolName: string, errors: string[]) {\n    super(\n      `Failed to parse structured output for tool '${toolName}':${errors\n        .map((e) => `\\n  - ${e}`)\n        .join(\"\")}.`\n    );\n    this.toolName = toolName;\n    this.errors = errors;\n  }\n}\n\n/**\n * Raised when a tool call is throwing an error.\n */\nexport class ToolInvocationError extends Error {\n  public readonly toolCall: ToolCall;\n\n  public readonly toolError: Error;\n\n  constructor(toolError: unknown, toolCall: ToolCall) {\n    const error =\n      toolError instanceof Error ? toolError : new Error(String(toolError));\n    const toolArgs = JSON.stringify(toolCall.args);\n    super(\n      `Error invoking tool '${toolCall.name}' with kwargs ${toolArgs} with error: ${error.stack}\\n Please fix the error and try again.`\n    );\n\n    this.toolCall = toolCall;\n    this.toolError = error;\n  }\n}\n\n/**\n * Error thrown when a middleware fails.\n *\n * Use `MiddlewareError.wrap()` to create instances. The constructor is private\n * to ensure that GraphBubbleUp errors (like GraphInterrupt) are never wrapped.\n */\nexport class MiddlewareError extends Error {\n  static readonly \"~brand\" = \"MiddlewareError\";\n\n  private constructor(error: unknown, middlewareName: string) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    super(errorMessage);\n    this.name =\n      error instanceof Error\n        ? error.name\n        : `${middlewareName[0].toUpperCase() + middlewareName.slice(1)}Error`;\n\n    if (error instanceof Error) {\n      this.cause = error;\n    }\n  }\n\n  /**\n   * Wrap an error in a MiddlewareError, unless it's a GraphBubbleUp error\n   * (like GraphInterrupt) which should propagate unchanged.\n   *\n   * @param error - The error to wrap\n   * @param middlewareName - The name of the middleware that threw the error\n   * @returns The original error if it's a GraphBubbleUp, otherwise a new MiddlewareError\n   */\n  static wrap(error: unknown, middlewareName: string): Error {\n    // Don't wrap GraphBubbleUp errors (GraphInterrupt, NodeInterrupt, etc.)\n    // These are control flow mechanisms that need to bubble up unchanged\n    if (isGraphBubbleUp(error)) {\n      return error;\n    }\n    return new MiddlewareError(error, middlewareName);\n  }\n\n  /**\n   * Check if the error is a MiddlewareError.\n   * @param error - The error to check\n   * @returns Whether the error is a MiddlewareError\n   */\n  static isInstance(error: unknown): error is MiddlewareError {\n    return (\n      error instanceof Error &&\n      \"~brand\" in error &&\n      error[\"~brand\"] === \"MiddlewareError\"\n    );\n  }\n}\n"],"mappings":";;;AAIA,IAAa,0BAAb,cAA6C,MAAM;CACjD,cAAc;AACZ,QACE,uKAGD;;;;;;AAOL,IAAa,iCAAb,cAAoD,MAAM;CACxD;CAEA,YAAY,WAAqB;AAC/B,QACE,wCAAwC,UAAU,KAChD,KACD,CAAC,mGAEH;AACD,OAAK,YAAY;;;;;;AAOrB,IAAa,+BAAb,cAAkD,MAAM;CACtD;CAEA;CAEA,YAAY,UAAkB,QAAkB;AAC9C,QACE,+CAA+C,SAAS,IAAI,OACzD,KAAK,MAAM,SAAS,IAAI,CACxB,KAAK,GAAG,CAAC,GACb;AACD,OAAK,WAAW;AAChB,OAAK,SAAS;;;;;;AAOlB,IAAa,sBAAb,cAAyC,MAAM;CAC7C;CAEA;CAEA,YAAY,WAAoB,UAAoB;EAClD,MAAM,QACJ,qBAAqB,QAAQ,YAAY,IAAI,MAAM,OAAO,UAAU,CAAC;EACvE,MAAM,WAAW,KAAK,UAAU,SAAS,KAAK;AAC9C,QACE,wBAAwB,SAAS,KAAK,gBAAgB,SAAS,eAAe,MAAM,MAAM,wCAC3F;AAED,OAAK,WAAW;AAChB,OAAK,YAAY;;;;;;;;;AAUrB,IAAa,kBAAb,MAAa,wBAAwB,MAAM;CACzC,OAAgB,WAAW;CAE3B,YAAoB,OAAgB,gBAAwB;EAC1D,MAAM,eAAe,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;AAC3E,QAAM,aAAa;AACnB,OAAK,OACH,iBAAiB,QACb,MAAM,OACN,GAAG,eAAe,GAAG,aAAa,GAAG,eAAe,MAAM,EAAE,CAAC;AAEnE,MAAI,iBAAiB,MACnB,MAAK,QAAQ;;;;;;;;;;CAYjB,OAAO,KAAK,OAAgB,gBAA+B;AAGzD,OAAA,GAAA,qBAAA,iBAAoB,MAAM,CACxB,QAAO;AAET,SAAO,IAAI,gBAAgB,OAAO,eAAe;;;;;;;CAQnD,OAAO,WAAW,OAA0C;AAC1D,SACE,iBAAiB,SACjB,YAAY,SACZ,MAAM,cAAc"}
+{"version":3,"file":"errors.cjs","names":[],"sources":["../../src/agents/errors.ts"],"sourcesContent":["/* oxlint-disable no-instanceof/no-instanceof */\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport { isGraphBubbleUp } from \"@langchain/langgraph\";\n\nexport class MultipleToolsBoundError extends Error {\n  constructor() {\n    super(\n      \"The provided LLM already has bound tools. \" +\n        \"Please provide an LLM without bound tools to createAgent. \" +\n        \"The agent will bind the tools provided in the 'tools' parameter.\"\n    );\n  }\n}\n\n/**\n * Raised when model returns multiple structured output tool calls when only one is expected.\n */\nexport class MultipleStructuredOutputsError extends Error {\n  public readonly toolNames: string[];\n\n  constructor(toolNames: string[]) {\n    super(\n      `The model has called multiple tools: ${toolNames.join(\n        \", \"\n      )} to return a structured output. ` +\n        \"This is not supported. Please provide a single structured output.\"\n    );\n    this.toolNames = toolNames;\n  }\n}\n\n/**\n * Raised when structured output tool call arguments fail to parse according to the schema.\n */\nexport class StructuredOutputParsingError extends Error {\n  public readonly toolName: string;\n\n  public readonly errors: string[];\n\n  constructor(toolName: string, errors: string[]) {\n    super(\n      `Failed to parse structured output for tool '${toolName}':${errors\n        .map((e) => `\\n  - ${e}`)\n        .join(\"\")}.`\n    );\n    this.toolName = toolName;\n    this.errors = errors;\n  }\n}\n\n/**\n * Raised when a tool call is throwing an error.\n */\nexport class ToolInvocationError extends Error {\n  readonly \"~brand\" = \"ToolInvocationError\";\n\n  public readonly toolCall: ToolCall;\n\n  public readonly toolError: Error;\n\n  constructor(toolError: unknown, toolCall: ToolCall) {\n    const error =\n      toolError instanceof Error ? toolError : new Error(String(toolError));\n    const toolArgs = JSON.stringify(toolCall.args);\n    super(\n      `Error invoking tool '${toolCall.name}' with kwargs ${toolArgs} with error: ${error.stack}\\n Please fix the error and try again.`\n    );\n\n    this.toolCall = toolCall;\n    this.toolError = error;\n  }\n\n  /**\n   * Check if the error is a ToolInvocationError.\n   * @param error - The error to check\n   * @returns Whether the error is a ToolInvocationError\n   */\n  static isInstance(error: unknown): error is ToolInvocationError {\n    return (\n      error instanceof Error &&\n      \"~brand\" in error &&\n      error[\"~brand\"] === \"ToolInvocationError\"\n    );\n  }\n}\n\n/**\n * Error thrown when a middleware fails.\n *\n * Use `MiddlewareError.wrap()` to create instances. The constructor is private\n * to ensure that GraphBubbleUp errors (like GraphInterrupt) are never wrapped.\n */\nexport class MiddlewareError extends Error {\n  readonly \"~brand\" = \"MiddlewareError\";\n\n  private constructor(error: unknown, middlewareName: string) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    super(errorMessage);\n    this.name =\n      error instanceof Error\n        ? error.name\n        : `${middlewareName[0].toUpperCase() + middlewareName.slice(1)}Error`;\n\n    if (error instanceof Error) {\n      this.cause = error;\n    }\n  }\n\n  /**\n   * Wrap an error in a MiddlewareError, unless it's a GraphBubbleUp error\n   * (like GraphInterrupt) which should propagate unchanged.\n   *\n   * @param error - The error to wrap\n   * @param middlewareName - The name of the middleware that threw the error\n   * @returns The original error if it's a GraphBubbleUp, otherwise a new MiddlewareError\n   */\n  static wrap(error: unknown, middlewareName: string): Error {\n    // Don't wrap GraphBubbleUp errors (GraphInterrupt, NodeInterrupt, etc.)\n    // These are control flow mechanisms that need to bubble up unchanged\n    if (isGraphBubbleUp(error)) {\n      return error;\n    }\n    return new MiddlewareError(error, middlewareName);\n  }\n\n  /**\n   * Check if the error is a MiddlewareError.\n   * @param error - The error to check\n   * @returns Whether the error is a MiddlewareError\n   */\n  static isInstance(error: unknown): error is MiddlewareError {\n    return (\n      error instanceof Error &&\n      \"~brand\" in error &&\n      error[\"~brand\"] === \"MiddlewareError\"\n    );\n  }\n}\n"],"mappings":";;;AAIA,IAAa,0BAAb,cAA6C,MAAM;CACjD,cAAc;AACZ,QACE,uKAGD;;;;;;AAOL,IAAa,iCAAb,cAAoD,MAAM;CACxD;CAEA,YAAY,WAAqB;AAC/B,QACE,wCAAwC,UAAU,KAChD,KACD,CAAC,mGAEH;AACD,OAAK,YAAY;;;;;;AAOrB,IAAa,+BAAb,cAAkD,MAAM;CACtD;CAEA;CAEA,YAAY,UAAkB,QAAkB;AAC9C,QACE,+CAA+C,SAAS,IAAI,OACzD,KAAK,MAAM,SAAS,IAAI,CACxB,KAAK,GAAG,CAAC,GACb;AACD,OAAK,WAAW;AAChB,OAAK,SAAS;;;;;;AAOlB,IAAa,sBAAb,cAAyC,MAAM;CAC7C,WAAoB;CAEpB;CAEA;CAEA,YAAY,WAAoB,UAAoB;EAClD,MAAM,QACJ,qBAAqB,QAAQ,YAAY,IAAI,MAAM,OAAO,UAAU,CAAC;EACvE,MAAM,WAAW,KAAK,UAAU,SAAS,KAAK;AAC9C,QACE,wBAAwB,SAAS,KAAK,gBAAgB,SAAS,eAAe,MAAM,MAAM,wCAC3F;AAED,OAAK,WAAW;AAChB,OAAK,YAAY;;;;;;;CAQnB,OAAO,WAAW,OAA8C;AAC9D,SACE,iBAAiB,SACjB,YAAY,SACZ,MAAM,cAAc;;;;;;;;;AAW1B,IAAa,kBAAb,MAAa,wBAAwB,MAAM;CACzC,WAAoB;CAEpB,YAAoB,OAAgB,gBAAwB;EAC1D,MAAM,eAAe,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;AAC3E,QAAM,aAAa;AACnB,OAAK,OACH,iBAAiB,QACb,MAAM,OACN,GAAG,eAAe,GAAG,aAAa,GAAG,eAAe,MAAM,EAAE,CAAC;AAEnE,MAAI,iBAAiB,MACnB,MAAK,QAAQ;;;;;;;;;;CAYjB,OAAO,KAAK,OAAgB,gBAA+B;AAGzD,OAAA,GAAA,qBAAA,iBAAoB,MAAM,CACxB,QAAO;AAET,SAAO,IAAI,gBAAgB,OAAO,eAAe;;;;;;;CAQnD,OAAO,WAAW,OAA0C;AAC1D,SACE,iBAAiB,SACjB,YAAY,SACZ,MAAM,cAAc"}

package/dist/agents/errors.d.cts

@@ -23,9 +23,16 @@ declare class StructuredOutputParsingError extends Error {
  * Raised when a tool call is throwing an error.
  */
 declare class ToolInvocationError extends Error {
+  readonly "~brand" = "ToolInvocationError";
   readonly toolCall: ToolCall;
   readonly toolError: Error;
   constructor(toolError: unknown, toolCall: ToolCall);
+  /**
+   * Check if the error is a ToolInvocationError.
+   * @param error - The error to check
+   * @returns Whether the error is a ToolInvocationError
+   */
+  static isInstance(error: unknown): error is ToolInvocationError;
 }
 /**
  * Error thrown when a middleware fails.
@@ -34,7 +41,7 @@ declare class ToolInvocationError extends Error {
  * to ensure that GraphBubbleUp errors (like GraphInterrupt) are never wrapped.
  */
 declare class MiddlewareError extends Error {
-  static readonly "~brand" = "MiddlewareError";
+  readonly "~brand" = "MiddlewareError";
   private constructor();
   /**
    * Wrap an error in a MiddlewareError, unless it's a GraphBubbleUp error

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

@@ -1 +1 @@
-{"version":3,"file":"errors.d.cts","names":[],"sources":["../../src/agents/errors.ts"],"mappings":";;;cAIa,uBAAA,SAAgC,KAAA;EAC3C,WAAA,CAAA;AAAA;;;;cAYW,8BAAA,SAAuC,KAAA;EAAA,SAClC,SAAA;EAEhB,WAAA,CAAY,SAAA;AAAA;;;;cAcD,4BAAA,SAAqC,KAAA;EAAA,SAChC,QAAA;EAAA,SAEA,MAAA;EAEhB,WAAA,CAAY,QAAA,UAAkB,MAAA;AAAA;;;;cAcnB,mBAAA,SAA4B,KAAA;EAAA,SACvB,QAAA,EAAU,QAAA;EAAA,SAEV,SAAA,EAAW,KAAA;EAE3B,WAAA,CAAY,SAAA,WAAoB,QAAA,EAAU,QAAA;AAAA;;;;AAL5C;;;cAwBa,eAAA,SAAwB,KAAA;EAAA;EAAA,QAG5B,WAAA,CAAA;EA3BgC;;;;;;;;EAAA,OAgDhC,IAAA,CAAK,KAAA,WAAgB,cAAA,WAAyB,KAAA;EA3CzC;;;;;EAAA,OAyDL,UAAA,CAAW,KAAA,YAAiB,KAAA,IAAS,eAAA;AAAA"}
+{"version":3,"file":"errors.d.cts","names":[],"sources":["../../src/agents/errors.ts"],"mappings":";;;cAIa,uBAAA,SAAgC,KAAA;EAC3C,WAAA,CAAA;AAAA;;;;cAYW,8BAAA,SAAuC,KAAA;EAAA,SAClC,SAAA;EAEhB,WAAA,CAAY,SAAA;AAAA;;;;cAcD,4BAAA,SAAqC,KAAA;EAAA,SAChC,QAAA;EAAA,SAEA,MAAA;EAEhB,WAAA,CAAY,QAAA,UAAkB,MAAA;AAAA;;;;cAcnB,mBAAA,SAA4B,KAAA;EAAA;EAAA,SAGvB,QAAA,EAAU,QAAA;EAAA,SAEV,SAAA,EAAW,KAAA;EAE3B,WAAA,CAAY,SAAA,WAAoB,QAAA,EAAU,QAAA;EArBZ;;;AAchC;;EAdgC,OAsCvB,UAAA,CAAW,KAAA,YAAiB,KAAA,IAAS,mBAAA;AAAA;;;;;;;cAejC,eAAA,SAAwB,KAAA;EAAA;EAAA,QAG5B,WAAA,CAAA;EArCS;;;;;;;;EAAA,OA0DT,IAAA,CAAK,KAAA,WAAgB,cAAA,WAAyB,KAAA;EAvCT;;;AAe9C;;EAf8C,OAqDrC,UAAA,CAAW,KAAA,YAAiB,KAAA,IAAS,eAAA;AAAA"}

package/dist/agents/errors.d.ts

@@ -23,9 +23,16 @@ declare class StructuredOutputParsingError extends Error {
  * Raised when a tool call is throwing an error.
  */
 declare class ToolInvocationError extends Error {
+  readonly "~brand" = "ToolInvocationError";
   readonly toolCall: ToolCall;
   readonly toolError: Error;
   constructor(toolError: unknown, toolCall: ToolCall);
+  /**
+   * Check if the error is a ToolInvocationError.
+   * @param error - The error to check
+   * @returns Whether the error is a ToolInvocationError
+   */
+  static isInstance(error: unknown): error is ToolInvocationError;
 }
 /**
  * Error thrown when a middleware fails.
@@ -34,7 +41,7 @@ declare class ToolInvocationError extends Error {
  * to ensure that GraphBubbleUp errors (like GraphInterrupt) are never wrapped.
  */
 declare class MiddlewareError extends Error {
-  static readonly "~brand" = "MiddlewareError";
+  readonly "~brand" = "MiddlewareError";
   private constructor();
   /**
    * Wrap an error in a MiddlewareError, unless it's a GraphBubbleUp error

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

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","names":[],"sources":["../../src/agents/errors.ts"],"mappings":";;;cAIa,uBAAA,SAAgC,KAAA;EAC3C,WAAA,CAAA;AAAA;;;;cAYW,8BAAA,SAAuC,KAAA;EAAA,SAClC,SAAA;EAEhB,WAAA,CAAY,SAAA;AAAA;;;;cAcD,4BAAA,SAAqC,KAAA;EAAA,SAChC,QAAA;EAAA,SAEA,MAAA;EAEhB,WAAA,CAAY,QAAA,UAAkB,MAAA;AAAA;;;;cAcnB,mBAAA,SAA4B,KAAA;EAAA,SACvB,QAAA,EAAU,QAAA;EAAA,SAEV,SAAA,EAAW,KAAA;EAE3B,WAAA,CAAY,SAAA,WAAoB,QAAA,EAAU,QAAA;AAAA;;;;AAL5C;;;cAwBa,eAAA,SAAwB,KAAA;EAAA;EAAA,QAG5B,WAAA,CAAA;EA3BgC;;;;;;;;EAAA,OAgDhC,IAAA,CAAK,KAAA,WAAgB,cAAA,WAAyB,KAAA;EA3CzC;;;;;EAAA,OAyDL,UAAA,CAAW,KAAA,YAAiB,KAAA,IAAS,eAAA;AAAA"}
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../../src/agents/errors.ts"],"mappings":";;;cAIa,uBAAA,SAAgC,KAAA;EAC3C,WAAA,CAAA;AAAA;;;;cAYW,8BAAA,SAAuC,KAAA;EAAA,SAClC,SAAA;EAEhB,WAAA,CAAY,SAAA;AAAA;;;;cAcD,4BAAA,SAAqC,KAAA;EAAA,SAChC,QAAA;EAAA,SAEA,MAAA;EAEhB,WAAA,CAAY,QAAA,UAAkB,MAAA;AAAA;;;;cAcnB,mBAAA,SAA4B,KAAA;EAAA;EAAA,SAGvB,QAAA,EAAU,QAAA;EAAA,SAEV,SAAA,EAAW,KAAA;EAE3B,WAAA,CAAY,SAAA,WAAoB,QAAA,EAAU,QAAA;EArBZ;;;AAchC;;EAdgC,OAsCvB,UAAA,CAAW,KAAA,YAAiB,KAAA,IAAS,mBAAA;AAAA;;;;;;;cAejC,eAAA,SAAwB,KAAA;EAAA;EAAA,QAG5B,WAAA,CAAA;EArCS;;;;;;;;EAAA,OA0DT,IAAA,CAAK,KAAA,WAAgB,cAAA,WAAyB,KAAA;EAvCT;;;AAe9C;;EAf8C,OAqDrC,UAAA,CAAW,KAAA,YAAiB,KAAA,IAAS,eAAA;AAAA"}

package/dist/agents/errors.js

@@ -31,6 +31,7 @@ var StructuredOutputParsingError = class extends Error {
 * Raised when a tool call is throwing an error.
 */
 var ToolInvocationError = class extends Error {
+	"~brand" = "ToolInvocationError";
 	toolCall;
 	toolError;
 	constructor(toolError, toolCall) {
@@ -40,6 +41,14 @@ var ToolInvocationError = class extends Error {
 		this.toolCall = toolCall;
 		this.toolError = error;
 	}
+	/**
+	* Check if the error is a ToolInvocationError.
+	* @param error - The error to check
+	* @returns Whether the error is a ToolInvocationError
+	*/
+	static isInstance(error) {
+		return error instanceof Error && "~brand" in error && error["~brand"] === "ToolInvocationError";
+	}
 };
 /**
 * Error thrown when a middleware fails.
@@ -48,7 +57,7 @@ var ToolInvocationError = class extends Error {
 * to ensure that GraphBubbleUp errors (like GraphInterrupt) are never wrapped.
 */
 var MiddlewareError = class MiddlewareError extends Error {
-	static "~brand" = "MiddlewareError";
+	"~brand" = "MiddlewareError";
 	constructor(error, middlewareName) {
 		const errorMessage = error instanceof Error ? error.message : String(error);
 		super(errorMessage);

package/dist/agents/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","names":[],"sources":["../../src/agents/errors.ts"],"sourcesContent":["/* oxlint-disable no-instanceof/no-instanceof */\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport { isGraphBubbleUp } from \"@langchain/langgraph\";\n\nexport class MultipleToolsBoundError extends Error {\n  constructor() {\n    super(\n      \"The provided LLM already has bound tools. \" +\n        \"Please provide an LLM without bound tools to createAgent. \" +\n        \"The agent will bind the tools provided in the 'tools' parameter.\"\n    );\n  }\n}\n\n/**\n * Raised when model returns multiple structured output tool calls when only one is expected.\n */\nexport class MultipleStructuredOutputsError extends Error {\n  public readonly toolNames: string[];\n\n  constructor(toolNames: string[]) {\n    super(\n      `The model has called multiple tools: ${toolNames.join(\n        \", \"\n      )} to return a structured output. ` +\n        \"This is not supported. Please provide a single structured output.\"\n    );\n    this.toolNames = toolNames;\n  }\n}\n\n/**\n * Raised when structured output tool call arguments fail to parse according to the schema.\n */\nexport class StructuredOutputParsingError extends Error {\n  public readonly toolName: string;\n\n  public readonly errors: string[];\n\n  constructor(toolName: string, errors: string[]) {\n    super(\n      `Failed to parse structured output for tool '${toolName}':${errors\n        .map((e) => `\\n  - ${e}`)\n        .join(\"\")}.`\n    );\n    this.toolName = toolName;\n    this.errors = errors;\n  }\n}\n\n/**\n * Raised when a tool call is throwing an error.\n */\nexport class ToolInvocationError extends Error {\n  public readonly toolCall: ToolCall;\n\n  public readonly toolError: Error;\n\n  constructor(toolError: unknown, toolCall: ToolCall) {\n    const error =\n      toolError instanceof Error ? toolError : new Error(String(toolError));\n    const toolArgs = JSON.stringify(toolCall.args);\n    super(\n      `Error invoking tool '${toolCall.name}' with kwargs ${toolArgs} with error: ${error.stack}\\n Please fix the error and try again.`\n    );\n\n    this.toolCall = toolCall;\n    this.toolError = error;\n  }\n}\n\n/**\n * Error thrown when a middleware fails.\n *\n * Use `MiddlewareError.wrap()` to create instances. The constructor is private\n * to ensure that GraphBubbleUp errors (like GraphInterrupt) are never wrapped.\n */\nexport class MiddlewareError extends Error {\n  static readonly \"~brand\" = \"MiddlewareError\";\n\n  private constructor(error: unknown, middlewareName: string) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    super(errorMessage);\n    this.name =\n      error instanceof Error\n        ? error.name\n        : `${middlewareName[0].toUpperCase() + middlewareName.slice(1)}Error`;\n\n    if (error instanceof Error) {\n      this.cause = error;\n    }\n  }\n\n  /**\n   * Wrap an error in a MiddlewareError, unless it's a GraphBubbleUp error\n   * (like GraphInterrupt) which should propagate unchanged.\n   *\n   * @param error - The error to wrap\n   * @param middlewareName - The name of the middleware that threw the error\n   * @returns The original error if it's a GraphBubbleUp, otherwise a new MiddlewareError\n   */\n  static wrap(error: unknown, middlewareName: string): Error {\n    // Don't wrap GraphBubbleUp errors (GraphInterrupt, NodeInterrupt, etc.)\n    // These are control flow mechanisms that need to bubble up unchanged\n    if (isGraphBubbleUp(error)) {\n      return error;\n    }\n    return new MiddlewareError(error, middlewareName);\n  }\n\n  /**\n   * Check if the error is a MiddlewareError.\n   * @param error - The error to check\n   * @returns Whether the error is a MiddlewareError\n   */\n  static isInstance(error: unknown): error is MiddlewareError {\n    return (\n      error instanceof Error &&\n      \"~brand\" in error &&\n      error[\"~brand\"] === \"MiddlewareError\"\n    );\n  }\n}\n"],"mappings":";;AAIA,IAAa,0BAAb,cAA6C,MAAM;CACjD,cAAc;AACZ,QACE,uKAGD;;;;;;AAOL,IAAa,iCAAb,cAAoD,MAAM;CACxD;CAEA,YAAY,WAAqB;AAC/B,QACE,wCAAwC,UAAU,KAChD,KACD,CAAC,mGAEH;AACD,OAAK,YAAY;;;;;;AAOrB,IAAa,+BAAb,cAAkD,MAAM;CACtD;CAEA;CAEA,YAAY,UAAkB,QAAkB;AAC9C,QACE,+CAA+C,SAAS,IAAI,OACzD,KAAK,MAAM,SAAS,IAAI,CACxB,KAAK,GAAG,CAAC,GACb;AACD,OAAK,WAAW;AAChB,OAAK,SAAS;;;;;;AAOlB,IAAa,sBAAb,cAAyC,MAAM;CAC7C;CAEA;CAEA,YAAY,WAAoB,UAAoB;EAClD,MAAM,QACJ,qBAAqB,QAAQ,YAAY,IAAI,MAAM,OAAO,UAAU,CAAC;EACvE,MAAM,WAAW,KAAK,UAAU,SAAS,KAAK;AAC9C,QACE,wBAAwB,SAAS,KAAK,gBAAgB,SAAS,eAAe,MAAM,MAAM,wCAC3F;AAED,OAAK,WAAW;AAChB,OAAK,YAAY;;;;;;;;;AAUrB,IAAa,kBAAb,MAAa,wBAAwB,MAAM;CACzC,OAAgB,WAAW;CAE3B,YAAoB,OAAgB,gBAAwB;EAC1D,MAAM,eAAe,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;AAC3E,QAAM,aAAa;AACnB,OAAK,OACH,iBAAiB,QACb,MAAM,OACN,GAAG,eAAe,GAAG,aAAa,GAAG,eAAe,MAAM,EAAE,CAAC;AAEnE,MAAI,iBAAiB,MACnB,MAAK,QAAQ;;;;;;;;;;CAYjB,OAAO,KAAK,OAAgB,gBAA+B;AAGzD,MAAI,gBAAgB,MAAM,CACxB,QAAO;AAET,SAAO,IAAI,gBAAgB,OAAO,eAAe;;;;;;;CAQnD,OAAO,WAAW,OAA0C;AAC1D,SACE,iBAAiB,SACjB,YAAY,SACZ,MAAM,cAAc"}
+{"version":3,"file":"errors.js","names":[],"sources":["../../src/agents/errors.ts"],"sourcesContent":["/* oxlint-disable no-instanceof/no-instanceof */\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport { isGraphBubbleUp } from \"@langchain/langgraph\";\n\nexport class MultipleToolsBoundError extends Error {\n  constructor() {\n    super(\n      \"The provided LLM already has bound tools. \" +\n        \"Please provide an LLM without bound tools to createAgent. \" +\n        \"The agent will bind the tools provided in the 'tools' parameter.\"\n    );\n  }\n}\n\n/**\n * Raised when model returns multiple structured output tool calls when only one is expected.\n */\nexport class MultipleStructuredOutputsError extends Error {\n  public readonly toolNames: string[];\n\n  constructor(toolNames: string[]) {\n    super(\n      `The model has called multiple tools: ${toolNames.join(\n        \", \"\n      )} to return a structured output. ` +\n        \"This is not supported. Please provide a single structured output.\"\n    );\n    this.toolNames = toolNames;\n  }\n}\n\n/**\n * Raised when structured output tool call arguments fail to parse according to the schema.\n */\nexport class StructuredOutputParsingError extends Error {\n  public readonly toolName: string;\n\n  public readonly errors: string[];\n\n  constructor(toolName: string, errors: string[]) {\n    super(\n      `Failed to parse structured output for tool '${toolName}':${errors\n        .map((e) => `\\n  - ${e}`)\n        .join(\"\")}.`\n    );\n    this.toolName = toolName;\n    this.errors = errors;\n  }\n}\n\n/**\n * Raised when a tool call is throwing an error.\n */\nexport class ToolInvocationError extends Error {\n  readonly \"~brand\" = \"ToolInvocationError\";\n\n  public readonly toolCall: ToolCall;\n\n  public readonly toolError: Error;\n\n  constructor(toolError: unknown, toolCall: ToolCall) {\n    const error =\n      toolError instanceof Error ? toolError : new Error(String(toolError));\n    const toolArgs = JSON.stringify(toolCall.args);\n    super(\n      `Error invoking tool '${toolCall.name}' with kwargs ${toolArgs} with error: ${error.stack}\\n Please fix the error and try again.`\n    );\n\n    this.toolCall = toolCall;\n    this.toolError = error;\n  }\n\n  /**\n   * Check if the error is a ToolInvocationError.\n   * @param error - The error to check\n   * @returns Whether the error is a ToolInvocationError\n   */\n  static isInstance(error: unknown): error is ToolInvocationError {\n    return (\n      error instanceof Error &&\n      \"~brand\" in error &&\n      error[\"~brand\"] === \"ToolInvocationError\"\n    );\n  }\n}\n\n/**\n * Error thrown when a middleware fails.\n *\n * Use `MiddlewareError.wrap()` to create instances. The constructor is private\n * to ensure that GraphBubbleUp errors (like GraphInterrupt) are never wrapped.\n */\nexport class MiddlewareError extends Error {\n  readonly \"~brand\" = \"MiddlewareError\";\n\n  private constructor(error: unknown, middlewareName: string) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    super(errorMessage);\n    this.name =\n      error instanceof Error\n        ? error.name\n        : `${middlewareName[0].toUpperCase() + middlewareName.slice(1)}Error`;\n\n    if (error instanceof Error) {\n      this.cause = error;\n    }\n  }\n\n  /**\n   * Wrap an error in a MiddlewareError, unless it's a GraphBubbleUp error\n   * (like GraphInterrupt) which should propagate unchanged.\n   *\n   * @param error - The error to wrap\n   * @param middlewareName - The name of the middleware that threw the error\n   * @returns The original error if it's a GraphBubbleUp, otherwise a new MiddlewareError\n   */\n  static wrap(error: unknown, middlewareName: string): Error {\n    // Don't wrap GraphBubbleUp errors (GraphInterrupt, NodeInterrupt, etc.)\n    // These are control flow mechanisms that need to bubble up unchanged\n    if (isGraphBubbleUp(error)) {\n      return error;\n    }\n    return new MiddlewareError(error, middlewareName);\n  }\n\n  /**\n   * Check if the error is a MiddlewareError.\n   * @param error - The error to check\n   * @returns Whether the error is a MiddlewareError\n   */\n  static isInstance(error: unknown): error is MiddlewareError {\n    return (\n      error instanceof Error &&\n      \"~brand\" in error &&\n      error[\"~brand\"] === \"MiddlewareError\"\n    );\n  }\n}\n"],"mappings":";;AAIA,IAAa,0BAAb,cAA6C,MAAM;CACjD,cAAc;AACZ,QACE,uKAGD;;;;;;AAOL,IAAa,iCAAb,cAAoD,MAAM;CACxD;CAEA,YAAY,WAAqB;AAC/B,QACE,wCAAwC,UAAU,KAChD,KACD,CAAC,mGAEH;AACD,OAAK,YAAY;;;;;;AAOrB,IAAa,+BAAb,cAAkD,MAAM;CACtD;CAEA;CAEA,YAAY,UAAkB,QAAkB;AAC9C,QACE,+CAA+C,SAAS,IAAI,OACzD,KAAK,MAAM,SAAS,IAAI,CACxB,KAAK,GAAG,CAAC,GACb;AACD,OAAK,WAAW;AAChB,OAAK,SAAS;;;;;;AAOlB,IAAa,sBAAb,cAAyC,MAAM;CAC7C,WAAoB;CAEpB;CAEA;CAEA,YAAY,WAAoB,UAAoB;EAClD,MAAM,QACJ,qBAAqB,QAAQ,YAAY,IAAI,MAAM,OAAO,UAAU,CAAC;EACvE,MAAM,WAAW,KAAK,UAAU,SAAS,KAAK;AAC9C,QACE,wBAAwB,SAAS,KAAK,gBAAgB,SAAS,eAAe,MAAM,MAAM,wCAC3F;AAED,OAAK,WAAW;AAChB,OAAK,YAAY;;;;;;;CAQnB,OAAO,WAAW,OAA8C;AAC9D,SACE,iBAAiB,SACjB,YAAY,SACZ,MAAM,cAAc;;;;;;;;;AAW1B,IAAa,kBAAb,MAAa,wBAAwB,MAAM;CACzC,WAAoB;CAEpB,YAAoB,OAAgB,gBAAwB;EAC1D,MAAM,eAAe,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;AAC3E,QAAM,aAAa;AACnB,OAAK,OACH,iBAAiB,QACb,MAAM,OACN,GAAG,eAAe,GAAG,aAAa,GAAG,eAAe,MAAM,EAAE,CAAC;AAEnE,MAAI,iBAAiB,MACnB,MAAK,QAAQ;;;;;;;;;;CAYjB,OAAO,KAAK,OAAgB,gBAA+B;AAGzD,MAAI,gBAAgB,MAAM,CACxB,QAAO;AAET,SAAO,IAAI,gBAAgB,OAAO,eAAe;;;;;;;CAQnD,OAAO,WAAW,OAA0C;AAC1D,SACE,iBAAiB,SACjB,YAAY,SACZ,MAAM,cAAc"}

package/dist/agents/middleware/index.cjs

@@ -12,6 +12,7 @@ require("./modelCallLimit.cjs");
 require("./modelFallback.cjs");
 require("./modelRetry.cjs");
 require("./toolRetry.cjs");
+require("./toolError.cjs");
 require("./toolEmulator.cjs");
 require("./providerToolSearch.cjs");
 require("./provider/openai/moderation.cjs");

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

@@ -12,6 +12,7 @@ import { ModelCallLimitMiddlewareConfig, modelCallLimitMiddleware } from "./mode
 import { modelFallbackMiddleware } from "./modelFallback.cjs";
 import { ModelRetryMiddlewareConfig, modelRetryMiddleware } from "./modelRetry.cjs";
 import { ToolRetryMiddlewareConfig, toolRetryMiddleware } from "./toolRetry.cjs";
+import { ToolErrorHandler, ToolErrorMiddlewareConfig, toolErrorMiddleware } from "./toolError.cjs";
 import { ToolEmulatorOptions, toolEmulatorMiddleware } from "./toolEmulator.cjs";
 import { ProviderToolSearchMiddlewareConfig, providerToolSearchMiddleware } from "./providerToolSearch.cjs";
 import { OpenAIModerationMiddlewareOptions, openAIModerationMiddleware } from "./provider/openai/moderation.cjs";

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

@@ -12,6 +12,7 @@ import { ModelCallLimitMiddlewareConfig, modelCallLimitMiddleware } from "./mode
 import { modelFallbackMiddleware } from "./modelFallback.js";
 import { ModelRetryMiddlewareConfig, modelRetryMiddleware } from "./modelRetry.js";
 import { ToolRetryMiddlewareConfig, toolRetryMiddleware } from "./toolRetry.js";
+import { ToolErrorHandler, ToolErrorMiddlewareConfig, toolErrorMiddleware } from "./toolError.js";
 import { ToolEmulatorOptions, toolEmulatorMiddleware } from "./toolEmulator.js";
 import { ProviderToolSearchMiddlewareConfig, providerToolSearchMiddleware } from "./providerToolSearch.js";
 import { OpenAIModerationMiddlewareOptions, openAIModerationMiddleware } from "./provider/openai/moderation.js";

package/dist/agents/middleware/index.js

@@ -12,6 +12,7 @@ import "./modelCallLimit.js";
 import "./modelFallback.js";
 import "./modelRetry.js";
 import "./toolRetry.js";
+import "./toolError.js";
 import "./toolEmulator.js";
 import "./providerToolSearch.js";
 import "./provider/openai/moderation.js";

package/dist/agents/middleware/toolError.cjs

@@ -0,0 +1,68 @@
+require("../../_virtual/_rolldown/runtime.cjs");
+const require_middleware = require("../middleware.cjs");
+let _langchain_core_messages = require("@langchain/core/messages");
+let _langchain_langgraph = require("@langchain/langgraph");
+//#region src/agents/middleware/toolError.ts
+/**
+* Tool error middleware for agents.
+*/
+/**
+* Converts selected tool execution errors into error `ToolMessage`s.
+*
+* Handling is opt-in: {@link ToolErrorMiddlewareConfig.onError} must return
+* content for an error to be sent to the model. Returning nothing propagates
+* the original error unchanged. LangGraph control-flow signals always
+* propagate and are never passed to `onError`.
+*
+* Prefer returning content that identifies the error type without including
+* the raw error message, which may contain sensitive or internal details.
+*
+* This middleware does not retry. To retry before handling an error, place
+* `toolRetryMiddleware({ onFailure: "error" })` after this middleware.
+*
+* @example
+* ```ts
+* import { createAgent, toolErrorMiddleware } from "langchain";
+*
+* const agent = createAgent({
+*   model,
+*   tools: [searchTool],
+*   middleware: [
+*     toolErrorMiddleware({
+*       onError: (error, request) => {
+*         if (error instanceof TypeError) {
+*           return `Tool '${request.toolCall.name}' failed with TypeError.`;
+*         }
+*       },
+*     }),
+*   ],
+* });
+* ```
+*/
+function toolErrorMiddleware(config) {
+	const toolFilter = config.tools?.map((tool) => typeof tool === "string" ? tool : tool.name);
+	return require_middleware.createMiddleware({
+		name: "toolErrorMiddleware",
+		wrapToolCall: async (request, handler) => {
+			const toolName = request.tool?.name ?? request.toolCall.name;
+			if (toolFilter !== void 0 && !toolFilter.includes(toolName)) return handler(request);
+			try {
+				return await handler(request);
+			} catch (error) {
+				if ((0, _langchain_langgraph.isGraphBubbleUp)(error)) throw error;
+				const content = await config.onError(error, request);
+				if (content === void 0) throw error;
+				return new _langchain_core_messages.ToolMessage({
+					content,
+					tool_call_id: request.toolCall.id ?? "",
+					...typeof toolName === "string" ? { name: toolName } : {},
+					status: "error"
+				});
+			}
+		}
+	});
+}
+//#endregion
+exports.toolErrorMiddleware = toolErrorMiddleware;
+
+//# sourceMappingURL=toolError.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolError.cjs","names":["createMiddleware","ToolMessage"],"sources":["../../../src/agents/middleware/toolError.ts"],"sourcesContent":["/**\n * Tool error middleware for agents.\n */\nimport { ToolMessage, type MessageContent } from \"@langchain/core/messages\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\nimport { isGraphBubbleUp } from \"@langchain/langgraph\";\n\nimport { createMiddleware } from \"../middleware.js\";\nimport type { ToolCallRequest } from \"./types.js\";\n\n/**\n * Handler called when tool execution throws.\n *\n * Return content to surface the error to the model as an error `ToolMessage`.\n * Return nothing to propagate the original error.\n */\nexport type ToolErrorHandler = (\n  error: unknown,\n  request: ToolCallRequest\n) => MessageContent | void | Promise<MessageContent | void>;\n\n/**\n * Configuration for {@link toolErrorMiddleware}.\n */\nexport interface ToolErrorMiddlewareConfig {\n  /**\n   * Handler called when tool execution throws. Return content to convert the\n   * error into an error `ToolMessage`, or return nothing to propagate it.\n   */\n  onError: ToolErrorHandler;\n\n  /**\n   * Optional tools or tool names to handle errors for. Handles all tools when\n   * omitted.\n   */\n  tools?: Array<ClientTool | ServerTool | string>;\n}\n\n/**\n * Converts selected tool execution errors into error `ToolMessage`s.\n *\n * Handling is opt-in: {@link ToolErrorMiddlewareConfig.onError} must return\n * content for an error to be sent to the model. Returning nothing propagates\n * the original error unchanged. LangGraph control-flow signals always\n * propagate and are never passed to `onError`.\n *\n * Prefer returning content that identifies the error type without including\n * the raw error message, which may contain sensitive or internal details.\n *\n * This middleware does not retry. To retry before handling an error, place\n * `toolRetryMiddleware({ onFailure: \"error\" })` after this middleware.\n *\n * @example\n * ```ts\n * import { createAgent, toolErrorMiddleware } from \"langchain\";\n *\n * const agent = createAgent({\n *   model,\n *   tools: [searchTool],\n *   middleware: [\n *     toolErrorMiddleware({\n *       onError: (error, request) => {\n *         if (error instanceof TypeError) {\n *           return `Tool '${request.toolCall.name}' failed with TypeError.`;\n *         }\n *       },\n *     }),\n *   ],\n * });\n * ```\n */\nexport function toolErrorMiddleware(config: ToolErrorMiddlewareConfig) {\n  const toolFilter = config.tools?.map((tool) =>\n    typeof tool === \"string\" ? tool : tool.name\n  );\n\n  return createMiddleware({\n    name: \"toolErrorMiddleware\",\n    wrapToolCall: async (request, handler) => {\n      const toolName = request.tool?.name ?? request.toolCall.name;\n\n      if (toolFilter !== undefined && !toolFilter.includes(toolName)) {\n        return handler(request);\n      }\n\n      try {\n        return await handler(request);\n      } catch (error: unknown) {\n        if (isGraphBubbleUp(error)) {\n          throw error;\n        }\n\n        const content = await config.onError(error, request);\n        if (content === undefined) {\n          throw error;\n        }\n\n        return new ToolMessage({\n          content,\n          tool_call_id: request.toolCall.id ?? \"\",\n          ...(typeof toolName === \"string\" ? { name: toolName } : {}),\n          status: \"error\",\n        });\n      }\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEA,SAAgB,oBAAoB,QAAmC;CACrE,MAAM,aAAa,OAAO,OAAO,KAAK,SACpC,OAAO,SAAS,WAAW,OAAO,KAAK,KACxC;AAED,QAAOA,mBAAAA,iBAAiB;EACtB,MAAM;EACN,cAAc,OAAO,SAAS,YAAY;GACxC,MAAM,WAAW,QAAQ,MAAM,QAAQ,QAAQ,SAAS;AAExD,OAAI,eAAe,KAAA,KAAa,CAAC,WAAW,SAAS,SAAS,CAC5D,QAAO,QAAQ,QAAQ;AAGzB,OAAI;AACF,WAAO,MAAM,QAAQ,QAAQ;YACtB,OAAgB;AACvB,SAAA,GAAA,qBAAA,iBAAoB,MAAM,CACxB,OAAM;IAGR,MAAM,UAAU,MAAM,OAAO,QAAQ,OAAO,QAAQ;AACpD,QAAI,YAAY,KAAA,EACd,OAAM;AAGR,WAAO,IAAIC,yBAAAA,YAAY;KACrB;KACA,cAAc,QAAQ,SAAS,MAAM;KACrC,GAAI,OAAO,aAAa,WAAW,EAAE,MAAM,UAAU,GAAG,EAAE;KAC1D,QAAQ;KACT,CAAC;;;EAGP,CAAC"}

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

@@ -0,0 +1,64 @@
+import { AgentMiddleware, ToolCallRequest } from "./types.cjs";
+import { MessageContent } from "@langchain/core/messages";
+import { ClientTool, ServerTool } from "@langchain/core/tools";
+
+//#region src/agents/middleware/toolError.d.ts
+/**
+ * Handler called when tool execution throws.
+ *
+ * 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>;
+/**
+ * Configuration for {@link toolErrorMiddleware}.
+ */
+interface ToolErrorMiddlewareConfig {
+  /**
+   * Handler called when tool execution throws. Return content to convert the
+   * error into an error `ToolMessage`, or return nothing to propagate it.
+   */
+  onError: ToolErrorHandler;
+  /**
+   * Optional tools or tool names to handle errors for. Handles all tools when
+   * omitted.
+   */
+  tools?: Array<ClientTool | ServerTool | string>;
+}
+/**
+ * Converts selected tool execution errors into error `ToolMessage`s.
+ *
+ * Handling is opt-in: {@link ToolErrorMiddlewareConfig.onError} must return
+ * content for an error to be sent to the model. Returning nothing propagates
+ * the original error unchanged. LangGraph control-flow signals always
+ * propagate and are never passed to `onError`.
+ *
+ * Prefer returning content that identifies the error type without including
+ * the raw error message, which may contain sensitive or internal details.
+ *
+ * This middleware does not retry. To retry before handling an error, place
+ * `toolRetryMiddleware({ onFailure: "error" })` after this middleware.
+ *
+ * @example
+ * ```ts
+ * import { createAgent, toolErrorMiddleware } from "langchain";
+ *
+ * const agent = createAgent({
+ *   model,
+ *   tools: [searchTool],
+ *   middleware: [
+ *     toolErrorMiddleware({
+ *       onError: (error, request) => {
+ *         if (error instanceof TypeError) {
+ *           return `Tool '${request.toolCall.name}' failed with TypeError.`;
+ *         }
+ *       },
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"toolError.d.cts","names":[],"sources":["../../../src/agents/middleware/toolError.ts"],"mappings":";;;;;;;;;;;KAgBY,gBAAA,IACV,KAAA,WACA,OAAA,EAAS,eAAA,KACN,cAAA,UAAwB,OAAA,CAAQ,cAAA;;;;UAKpB,yBAAA;EALZ;;;;EAUH,OAAA,EAAS,gBAAA;EALM;;;;EAWf,KAAA,GAAQ,KAAA,CAAM,UAAA,GAAa,UAAA;AAAA;;;;;;;;;;;;AAoC7B;;;;;;;;;;;;;;;;;;;;;;iBAAgB,mBAAA,CAAoB,MAAA,EAAQ,yBAAA,GAAyB,eAAA,0CAAA,UAAA,GAAA,UAAA"}

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

@@ -0,0 +1,64 @@
+import { AgentMiddleware, ToolCallRequest } from "./types.js";
+import { MessageContent } from "@langchain/core/messages";
+import { ClientTool, ServerTool } from "@langchain/core/tools";
+
+//#region src/agents/middleware/toolError.d.ts
+/**
+ * Handler called when tool execution throws.
+ *
+ * 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>;
+/**
+ * Configuration for {@link toolErrorMiddleware}.
+ */
+interface ToolErrorMiddlewareConfig {
+  /**
+   * Handler called when tool execution throws. Return content to convert the
+   * error into an error `ToolMessage`, or return nothing to propagate it.
+   */
+  onError: ToolErrorHandler;
+  /**
+   * Optional tools or tool names to handle errors for. Handles all tools when
+   * omitted.
+   */
+  tools?: Array<ClientTool | ServerTool | string>;
+}
+/**
+ * Converts selected tool execution errors into error `ToolMessage`s.
+ *
+ * Handling is opt-in: {@link ToolErrorMiddlewareConfig.onError} must return
+ * content for an error to be sent to the model. Returning nothing propagates
+ * the original error unchanged. LangGraph control-flow signals always
+ * propagate and are never passed to `onError`.
+ *
+ * Prefer returning content that identifies the error type without including
+ * the raw error message, which may contain sensitive or internal details.
+ *
+ * This middleware does not retry. To retry before handling an error, place
+ * `toolRetryMiddleware({ onFailure: "error" })` after this middleware.
+ *
+ * @example
+ * ```ts
+ * import { createAgent, toolErrorMiddleware } from "langchain";
+ *
+ * const agent = createAgent({
+ *   model,
+ *   tools: [searchTool],
+ *   middleware: [
+ *     toolErrorMiddleware({
+ *       onError: (error, request) => {
+ *         if (error instanceof TypeError) {
+ *           return `Tool '${request.toolCall.name}' failed with TypeError.`;
+ *         }
+ *       },
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"toolError.d.ts","names":[],"sources":["../../../src/agents/middleware/toolError.ts"],"mappings":";;;;;;;;;;;KAgBY,gBAAA,IACV,KAAA,WACA,OAAA,EAAS,eAAA,KACN,cAAA,UAAwB,OAAA,CAAQ,cAAA;;;;UAKpB,yBAAA;EALZ;;;;EAUH,OAAA,EAAS,gBAAA;EALM;;;;EAWf,KAAA,GAAQ,KAAA,CAAM,UAAA,GAAa,UAAA;AAAA;;;;;;;;;;;;AAoC7B;;;;;;;;;;;;;;;;;;;;;;iBAAgB,mBAAA,CAAoB,MAAA,EAAQ,yBAAA,GAAyB,eAAA,0CAAA,UAAA,GAAA,UAAA"}

package/dist/agents/middleware/toolError.js

@@ -0,0 +1,67 @@
+import { createMiddleware } from "../middleware.js";
+import { ToolMessage } from "@langchain/core/messages";
+import { isGraphBubbleUp } from "@langchain/langgraph";
+//#region src/agents/middleware/toolError.ts
+/**
+* Tool error middleware for agents.
+*/
+/**
+* Converts selected tool execution errors into error `ToolMessage`s.
+*
+* Handling is opt-in: {@link ToolErrorMiddlewareConfig.onError} must return
+* content for an error to be sent to the model. Returning nothing propagates
+* the original error unchanged. LangGraph control-flow signals always
+* propagate and are never passed to `onError`.
+*
+* Prefer returning content that identifies the error type without including
+* the raw error message, which may contain sensitive or internal details.
+*
+* This middleware does not retry. To retry before handling an error, place
+* `toolRetryMiddleware({ onFailure: "error" })` after this middleware.
+*
+* @example
+* ```ts
+* import { createAgent, toolErrorMiddleware } from "langchain";
+*
+* const agent = createAgent({
+*   model,
+*   tools: [searchTool],
+*   middleware: [
+*     toolErrorMiddleware({
+*       onError: (error, request) => {
+*         if (error instanceof TypeError) {
+*           return `Tool '${request.toolCall.name}' failed with TypeError.`;
+*         }
+*       },
+*     }),
+*   ],
+* });
+* ```
+*/
+function toolErrorMiddleware(config) {
+	const toolFilter = config.tools?.map((tool) => typeof tool === "string" ? tool : tool.name);
+	return createMiddleware({
+		name: "toolErrorMiddleware",
+		wrapToolCall: async (request, handler) => {
+			const toolName = request.tool?.name ?? request.toolCall.name;
+			if (toolFilter !== void 0 && !toolFilter.includes(toolName)) return handler(request);
+			try {
+				return await handler(request);
+			} catch (error) {
+				if (isGraphBubbleUp(error)) throw error;
+				const content = await config.onError(error, request);
+				if (content === void 0) throw error;
+				return new ToolMessage({
+					content,
+					tool_call_id: request.toolCall.id ?? "",
+					...typeof toolName === "string" ? { name: toolName } : {},
+					status: "error"
+				});
+			}
+		}
+	});
+}
+//#endregion
+export { toolErrorMiddleware };
+
+//# sourceMappingURL=toolError.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolError.js","names":[],"sources":["../../../src/agents/middleware/toolError.ts"],"sourcesContent":["/**\n * Tool error middleware for agents.\n */\nimport { ToolMessage, type MessageContent } from \"@langchain/core/messages\";\nimport type { ClientTool, ServerTool } from \"@langchain/core/tools\";\nimport { isGraphBubbleUp } from \"@langchain/langgraph\";\n\nimport { createMiddleware } from \"../middleware.js\";\nimport type { ToolCallRequest } from \"./types.js\";\n\n/**\n * Handler called when tool execution throws.\n *\n * Return content to surface the error to the model as an error `ToolMessage`.\n * Return nothing to propagate the original error.\n */\nexport type ToolErrorHandler = (\n  error: unknown,\n  request: ToolCallRequest\n) => MessageContent | void | Promise<MessageContent | void>;\n\n/**\n * Configuration for {@link toolErrorMiddleware}.\n */\nexport interface ToolErrorMiddlewareConfig {\n  /**\n   * Handler called when tool execution throws. Return content to convert the\n   * error into an error `ToolMessage`, or return nothing to propagate it.\n   */\n  onError: ToolErrorHandler;\n\n  /**\n   * Optional tools or tool names to handle errors for. Handles all tools when\n   * omitted.\n   */\n  tools?: Array<ClientTool | ServerTool | string>;\n}\n\n/**\n * Converts selected tool execution errors into error `ToolMessage`s.\n *\n * Handling is opt-in: {@link ToolErrorMiddlewareConfig.onError} must return\n * content for an error to be sent to the model. Returning nothing propagates\n * the original error unchanged. LangGraph control-flow signals always\n * propagate and are never passed to `onError`.\n *\n * Prefer returning content that identifies the error type without including\n * the raw error message, which may contain sensitive or internal details.\n *\n * This middleware does not retry. To retry before handling an error, place\n * `toolRetryMiddleware({ onFailure: \"error\" })` after this middleware.\n *\n * @example\n * ```ts\n * import { createAgent, toolErrorMiddleware } from \"langchain\";\n *\n * const agent = createAgent({\n *   model,\n *   tools: [searchTool],\n *   middleware: [\n *     toolErrorMiddleware({\n *       onError: (error, request) => {\n *         if (error instanceof TypeError) {\n *           return `Tool '${request.toolCall.name}' failed with TypeError.`;\n *         }\n *       },\n *     }),\n *   ],\n * });\n * ```\n */\nexport function toolErrorMiddleware(config: ToolErrorMiddlewareConfig) {\n  const toolFilter = config.tools?.map((tool) =>\n    typeof tool === \"string\" ? tool : tool.name\n  );\n\n  return createMiddleware({\n    name: \"toolErrorMiddleware\",\n    wrapToolCall: async (request, handler) => {\n      const toolName = request.tool?.name ?? request.toolCall.name;\n\n      if (toolFilter !== undefined && !toolFilter.includes(toolName)) {\n        return handler(request);\n      }\n\n      try {\n        return await handler(request);\n      } catch (error: unknown) {\n        if (isGraphBubbleUp(error)) {\n          throw error;\n        }\n\n        const content = await config.onError(error, request);\n        if (content === undefined) {\n          throw error;\n        }\n\n        return new ToolMessage({\n          content,\n          tool_call_id: request.toolCall.id ?? \"\",\n          ...(typeof toolName === \"string\" ? { name: toolName } : {}),\n          status: \"error\",\n        });\n      }\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEA,SAAgB,oBAAoB,QAAmC;CACrE,MAAM,aAAa,OAAO,OAAO,KAAK,SACpC,OAAO,SAAS,WAAW,OAAO,KAAK,KACxC;AAED,QAAO,iBAAiB;EACtB,MAAM;EACN,cAAc,OAAO,SAAS,YAAY;GACxC,MAAM,WAAW,QAAQ,MAAM,QAAQ,QAAQ,SAAS;AAExD,OAAI,eAAe,KAAA,KAAa,CAAC,WAAW,SAAS,SAAS,CAC5D,QAAO,QAAQ,QAAQ;AAGzB,OAAI;AACF,WAAO,MAAM,QAAQ,QAAQ;YACtB,OAAgB;AACvB,QAAI,gBAAgB,MAAM,CACxB,OAAM;IAGR,MAAM,UAAU,MAAM,OAAO,QAAQ,OAAO,QAAQ;AACpD,QAAI,YAAY,KAAA,EACd,OAAM;AAGR,WAAO,IAAI,YAAY;KACrB;KACA,cAAc,QAAQ,SAAS,MAAM;KACrC,GAAI,OAAO,aAAa,WAAW,EAAE,MAAM,UAAU,GAAG,EAAE;KAC1D,QAAQ;KACT,CAAC;;;EAGP,CAAC"}

package/dist/agents/nodes/ToolNode.cjs

@@ -30,7 +30,7 @@ const isSendInput = (input) => typeof input === "object" && input != null && "lg
 * This allows the LLM to see the error and potentially retry with different arguments.
 */
 function defaultHandleToolErrors(error, toolCall) {
-	if (error instanceof require_errors.ToolInvocationError) return new _langchain_core_messages.ToolMessage({
+	if (require_errors.ToolInvocationError.isInstance(error)) return new _langchain_core_messages.ToolMessage({
 		content: error.message,
 		tool_call_id: toolCall.id,
 		name: toolCall.name
@@ -126,33 +126,51 @@ var ToolNode = class extends require_RunnableCallable.RunnableCallable {
 		*/
 		if (this.signal?.aborted) throw error;
 		/**
+		* A recoverable tool error (e.g. tool-input schema validation) can be
+		* rewrapped as a {@link MiddlewareError} with the original error on `.cause`
+		* — once per `wrapToolCall` middleware, so it may be nested several layers
+		* deep. Walk the cause chain to the root; if it's a {@link ToolInvocationError},
+		* unwrap it so the intended `handleToolErrors` self-correction path still
+		* applies. Genuine middleware errors stay fatal by default.
+		*/
+		let effectiveError = error;
+		let errorFromMiddleware = isMiddlewareError;
+		if (isMiddlewareError) {
+			let unwrapped = error;
+			while (require_errors.MiddlewareError.isInstance(unwrapped)) unwrapped = unwrapped.cause;
+			if (require_errors.ToolInvocationError.isInstance(unwrapped)) {
+				effectiveError = unwrapped;
+				errorFromMiddleware = false;
+			}
+		}
+		/**
 		* If error is from middleware and handleToolErrors is not true, bubble up
 		* (default handler and false both re-raise middleware errors)
 		*/
-		if (isMiddlewareError && this.handleToolErrors !== true) throw error;
+		if (errorFromMiddleware && this.handleToolErrors !== true) throw effectiveError;
 		/**
 		* If handleToolErrors is false, throw all errors
 		*/
-		if (!this.handleToolErrors) throw error;
+		if (!this.handleToolErrors) throw effectiveError;
 		/**
 		* Apply handleToolErrors to the error
 		*/
 		if (typeof this.handleToolErrors === "function") {
-			const result = this.handleToolErrors(error, call);
+			const result = this.handleToolErrors(effectiveError, call);
 			if (result && _langchain_core_messages.ToolMessage.isInstance(result)) return result;
 			/**
 			* `handleToolErrors` returned undefined - re-raise
 			*/
-			throw error;
+			throw effectiveError;
 		} else if (this.handleToolErrors) return new _langchain_core_messages.ToolMessage({
 			name: call.name,
-			content: `${error}\n Please fix your mistakes.`,
+			content: `${effectiveError}\n Please fix your mistakes.`,
 			tool_call_id: call.id
 		});
 		/**
 		* Shouldn't reach here, but throw as fallback
 		*/
-		throw error;
+		throw effectiveError;
 	}
 	async runTool(call, config, state) {
 		/**