{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# How to handle tool calling errors\n",
        "\n",
        "LLMs aren't perfect at calling tools. The model may try to call a tool that doesn't exist or fail to return arguments that match the requested schema. Strategies like keeping schemas simple, reducing the number of tools you pass at once, and having good names and descriptions can help mitigate this risk, but aren't foolproof.\n",
        "\n",
        "This guide covers some ways to build error handling into your graphs to mitigate these failure modes.\n",
        "\n",
        "<div class=\"admonition tip\">\n",
        "    <p class=\"admonition-title\">Compatibility</p>\n",
        "    <p>\n",
        "        This guide requires <code>@langchain/langgraph>=0.0.28</code>, <code>@langchain/anthropic>=0.2.6</code>, and <code>@langchain/core>=0.2.17</code>. For help upgrading, see <a href=\"/langgraphjs/how-tos/manage-ecosystem-dependencies/\">this guide</a>.\n",
        "    </p>\n",
        "</div>\n",
        "\n",
        "## Using the prebuilt `ToolNode`\n",
        "\n",
        "To start, define a mock weather tool that has some hidden restrictions on input queries. The intent here is to simulate a real-world case where a model fails to call a tool correctly:\n",
        "\n",
        "```bash\n",
        "$ npm install @langchain/langgraph @langchain/anthropic @langchain/core\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [],
      "source": [
        "import { z } from \"zod\";\n",
        "import { tool } from \"@langchain/core/tools\";\n",
        "\n",
        "const getWeather = tool(async ({ location }) => {\n",
        "  if (location === \"SAN FRANCISCO\") {\n",
        "    return \"It's 60 degrees and foggy\";\n",
        "  } else if (location.toLowerCase() === \"san francisco\") {\n",
        "    throw new Error(\"Input queries must be all capitals\");\n",
        "  } else {\n",
        "    throw new Error(\"Invalid input.\");\n",
        "  }\n",
        "}, {\n",
        "  name: \"get_weather\",\n",
        "  description: \"Call to get the current weather\",\n",
        "  schema: z.object({\n",
        "    location: z.string(),\n",
        "  }),\n",
        "});"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Next, set up a graph implementation of the [ReAct agent](/langgraphjs/concepts/). This agent takes some query as input, then repeatedly call tools until it has enough information to resolve the query. We'll use the prebuilt [`ToolNode`](/langgraphjs/reference/classes/langgraph_prebuilt.ToolNode.html) to execute called tools, and a small, fast model powered by Anthropic:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {},
      "outputs": [],
      "source": [
        "import { StateGraph, MessagesAnnotation } from \"@langchain/langgraph\";\n",
        "import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n",
        "import { ChatAnthropic } from \"@langchain/anthropic\";\n",
        "import { BaseMessage, isAIMessage } from \"@langchain/core/messages\";\n",
        "\n",
        "const toolNode = new ToolNode([getWeather]);\n",
        "\n",
        "const modelWithTools = new ChatAnthropic({\n",
        "  model: \"claude-3-haiku-20240307\",\n",
        "  temperature: 0,\n",
        "}).bindTools([getWeather]);\n",
        "\n",
        "const shouldContinue = async (state: typeof MessagesAnnotation.State) => {\n",
        "  const { messages } = state;\n",
        "  const lastMessage = messages[messages.length - 1];\n",
        "  if (isAIMessage(lastMessage) && lastMessage.tool_calls?.length) {\n",
        "    return \"tools\";\n",
        "  }\n",
        "  return \"__end__\";\n",
        "}\n",
        "\n",
        "const callModel = async (state: typeof MessagesAnnotation.State) => {\n",
        "  const { messages } = state;\n",
        "  const response = await modelWithTools.invoke(messages);\n",
        "  return { messages: [response] };\n",
        "}\n",
        "\n",
        "const app = new StateGraph(MessagesAnnotation)\n",
        "  .addNode(\"agent\", callModel)\n",
        "  .addNode(\"tools\", toolNode)\n",
        "  .addEdge(\"__start__\", \"agent\")\n",
        "  .addEdge(\"tools\", \"agent\")\n",
        "  .addConditionalEdges(\"agent\", shouldContinue, {\n",
        "    // Explicitly list possible destinations so that\n",
        "    // we can automatically draw the graph below.\n",
        "    tools: \"tools\",\n",
        "    __end__: \"__end__\",\n",
        "  })\n",
        "  .compile();"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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"
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import * as tslab from \"tslab\";\n",
        "\n",
        "const graph = app.getGraph();\n",
        "const image = await graph.drawMermaidPng();\n",
        "const arrayBuffer = await image.arrayBuffer();\n",
        "\n",
        "await tslab.display.png(new Uint8Array(arrayBuffer));"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "When you try to call the tool, you can see that the model calls the tool with a bad input, causing the tool to throw an error. The prebuilt `ToolNode` that executes the tool has some built-in error handling that captures the error and passes it back to the model so that it can try again:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "HUMAN: \"what is the weather in san francisco?\"\n",
            "AI: [\n",
            "  {\n",
            "    \"type\": \"text\",\n",
            "    \"text\": \"Okay, let's check the weather in San Francisco:\"\n",
            "  },\n",
            "  {\n",
            "    \"type\": \"tool_use\",\n",
            "    \"id\": \"toolu_015dywEMjSJsjkgP91VDbm52\",\n",
            "    \"name\": \"get_weather\",\n",
            "    \"input\": {\n",
            "      \"location\": \"San Francisco\"\n",
            "    }\n",
            "  }\n",
            "]\n",
            "TOOL: \"Error: Input queries must be all capitals\\n Please fix your mistakes.\"\n",
            "AI: [\n",
            "  {\n",
            "    \"type\": \"text\",\n",
            "    \"text\": \"Apologies, let me try that again with the location in all capital letters:\"\n",
            "  },\n",
            "  {\n",
            "    \"type\": \"tool_use\",\n",
            "    \"id\": \"toolu_01Qw6t7p9UGk8aHQh7qtLJZT\",\n",
            "    \"name\": \"get_weather\",\n",
            "    \"input\": {\n",
            "      \"location\": \"SAN FRANCISCO\"\n",
            "    }\n",
            "  }\n",
            "]\n",
            "TOOL: \"It's 60 degrees and foggy\"\n",
            "AI: \"The weather in San Francisco is 60 degrees and foggy.\"\n"
          ]
        }
      ],
      "source": [
        "const response = await app.invoke({\n",
        "  messages: [\n",
        "    { role: \"user\", content: \"what is the weather in san francisco?\"},\n",
        "  ]\n",
        "});\n",
        "\n",
        "for (const message of response.messages) {\n",
        "  // Anthropic returns tool calls in content as well as in `AIMessage.tool_calls`\n",
        "  const content = JSON.stringify(message.content, null, 2);\n",
        "  console.log(`${message._getType().toUpperCase()}: ${content}`);\n",
        "}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Custom strategies\n",
        "\n",
        "This is a fine default in many cases, but there are cases where custom fallbacks may be better.\n",
        "\n",
        "For example, the below tool requires as input a list of elements of a specific length - tricky for a small model! We'll also intentionally avoid pluralizing `topic` to trick the model into thinking it should pass a string:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "HUMAN: \"Write me an incredible haiku about water.\"\n",
            "AI: [\n",
            "  {\n",
            "    \"type\": \"text\",\n",
            "    \"text\": \"Okay, let's generate a haiku about water using the master haiku generator tool:\"\n",
            "  },\n",
            "  {\n",
            "    \"type\": \"tool_use\",\n",
            "    \"id\": \"toolu_01CMvVu3MhPeCk5X7F8GBv8f\",\n",
            "    \"name\": \"master_haiku_generator\",\n",
            "    \"input\": {\n",
            "      \"topic\": [\n",
            "        \"water\"\n",
            "      ]\n",
            "    }\n",
            "  }\n",
            "]\n",
            "TOOL: \"Error: Received tool input did not match expected schema\\n Please fix your mistakes.\"\n",
            "AI: [\n",
            "  {\n",
            "    \"type\": \"text\",\n",
            "    \"text\": \"Oops, looks like I need to provide 3 topics for the haiku generator. Let me try again with 3 water-related topics:\"\n",
            "  },\n",
            "  {\n",
            "    \"type\": \"tool_use\",\n",
            "    \"id\": \"toolu_0158Nz2scGSWvYor4vmJbSDZ\",\n",
            "    \"name\": \"master_haiku_generator\",\n",
            "    \"input\": {\n",
            "      \"topic\": [\n",
            "        \"ocean\",\n",
            "        \"waves\",\n",
            "        \"rain\"\n",
            "      ]\n",
            "    }\n",
            "  }\n",
            "]\n",
            "TOOL: \"Here is a haiku about the ocean, waves, and rain:\\n\\nWaves crash on the shore,\\nRhythmic dance of water's song,\\nRain falls from the sky.\"\n",
            "AI: \"The haiku generator has produced a beautiful and evocative poem about the different aspects of water - the ocean, waves, and rain. I hope you enjoy this creative take on a water-themed haiku!\"\n"
          ]
        }
      ],
      "source": [
        "import { StringOutputParser } from \"@langchain/core/output_parsers\";\n",
        "\n",
        "const haikuRequestSchema = z.object({\n",
        "  topic: z.array(z.string()).length(3),\n",
        "});\n",
        "\n",
        "const masterHaikuGenerator = tool(async ({ topic }) => {\n",
        "  const model = new ChatAnthropic({\n",
        "    model: \"claude-3-haiku-20240307\",\n",
        "    temperature: 0,\n",
        "  });\n",
        "  const chain = model.pipe(new StringOutputParser());\n",
        "  const topics = topic.join(\", \");\n",
        "  const haiku = await chain.invoke(`Write a haiku about ${topics}`);\n",
        "  return haiku;\n",
        "}, {\n",
        "  name: \"master_haiku_generator\",\n",
        "  description: \"Generates a haiku based on the provided topics.\",\n",
        "  schema: haikuRequestSchema,\n",
        "});\n",
        "\n",
        "const customStrategyToolNode = new ToolNode([masterHaikuGenerator]);\n",
        "\n",
        "const customStrategyModel = new ChatAnthropic({\n",
        "  model: \"claude-3-haiku-20240307\",\n",
        "  temperature: 0,\n",
        "});\n",
        "const customStrategyModelWithTools = customStrategyModel.bindTools([masterHaikuGenerator]);\n",
        "\n",
        "const customStrategyShouldContinue = async (state: typeof MessagesAnnotation.State) => {\n",
        "  const { messages } = state;\n",
        "  const lastMessage = messages[messages.length - 1];\n",
        "  if (isAIMessage(lastMessage) && lastMessage.tool_calls?.length) {\n",
        "    return \"tools\";\n",
        "  }\n",
        "  return \"__end__\";\n",
        "}\n",
        "\n",
        "const customStrategyCallModel = async (state: typeof MessagesAnnotation.State) => {\n",
        "  const { messages } = state;\n",
        "  const response = await customStrategyModelWithTools.invoke(messages);\n",
        "  return { messages: [response] };\n",
        "}\n",
        "\n",
        "const customStrategyApp = new StateGraph(MessagesAnnotation)\n",
        "  .addNode(\"tools\", customStrategyToolNode)\n",
        "  .addNode(\"agent\", customStrategyCallModel)\n",
        "  .addEdge(\"__start__\", \"agent\")\n",
        "  .addEdge(\"tools\", \"agent\")\n",
        "  .addConditionalEdges(\"agent\", customStrategyShouldContinue, {\n",
        "    // Explicitly list possible destinations so that\n",
        "    // we can automatically draw the graph below.\n",
        "    tools: \"tools\",\n",
        "    __end__: \"__end__\",\n",
        "  })\n",
        "  .compile();\n",
        "\n",
        "const response2 = await customStrategyApp.invoke(\n",
        "  {\n",
        "    messages: [{ role: \"user\", content: \"Write me an incredible haiku about water.\" }],\n",
        "  },\n",
        "  { recursionLimit: 10 }\n",
        ");\n",
        "\n",
        "for (const message of response2.messages) {\n",
        "  // Anthropic returns tool calls in content as well as in `AIMessage.tool_calls`\n",
        "  const content = JSON.stringify(message.content, null, 2);\n",
        "  console.log(`${message._getType().toUpperCase()}: ${content}`);\n",
        "}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We can see that the model takes two attempts.\n",
        "\n",
        "A better strategy might be to trim the failed attempt to reduce distraction, then fall back to a more advanced model. Here's an example - note the custom-built tool calling node instead of the prebuilt `ToolNode`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [],
      "source": [
        "import { AIMessage, ToolMessage, RemoveMessage } from \"@langchain/core/messages\";\n",
        "\n",
        "const haikuRequestSchema2 = z.object({\n",
        "  topic: z.array(z.string()).length(3),\n",
        "});\n",
        "\n",
        "const masterHaikuGenerator2 = tool(async ({ topic }) => {\n",
        "  const model = new ChatAnthropic({\n",
        "    model: \"claude-3-haiku-20240307\",\n",
        "    temperature: 0,\n",
        "  });\n",
        "  const chain = model.pipe(new StringOutputParser());\n",
        "  const topics = topic.join(\", \");\n",
        "  const haiku = await chain.invoke(`Write a haiku about ${topics}`);\n",
        "  return haiku;\n",
        "}, {\n",
        "  name: \"master_haiku_generator\",\n",
        "  description: \"Generates a haiku based on the provided topics.\",\n",
        "  schema: haikuRequestSchema2,\n",
        "});\n",
        "\n",
        "const callTool2 = async (state: typeof MessagesAnnotation.State) => {\n",
        "  const { messages } = state;\n",
        "  const toolsByName = { master_haiku_generator: masterHaikuGenerator };\n",
        "  const lastMessage = messages[messages.length - 1] as AIMessage;\n",
        "  const outputMessages: ToolMessage[] = [];\n",
        "  for (const toolCall of lastMessage.tool_calls) {\n",
        "    try {\n",
        "      const toolResult = await toolsByName[toolCall.name].invoke(toolCall);\n",
        "      outputMessages.push(toolResult);\n",
        "    } catch (error: any) {\n",
        "      // Return the error if the tool call fails\n",
        "      outputMessages.push(\n",
        "        new ToolMessage({\n",
        "          content: error.message,\n",
        "          name: toolCall.name,\n",
        "          tool_call_id: toolCall.id!,\n",
        "          additional_kwargs: { error }\n",
        "        })\n",
        "      );\n",
        "    }\n",
        "  }\n",
        "  return { messages: outputMessages };\n",
        "};\n",
        "\n",
        "const model = new ChatAnthropic({\n",
        "  model: \"claude-3-haiku-20240307\",\n",
        "  temperature: 0,\n",
        "});\n",
        "const modelWithTools2 = model.bindTools([masterHaikuGenerator2]);\n",
        "\n",
        "const betterModel = new ChatAnthropic({\n",
        "  model: \"claude-3-5-sonnet-20240620\",\n",
        "  temperature: 0,\n",
        "});\n",
        "const betterModelWithTools = betterModel.bindTools([masterHaikuGenerator2]);\n",
        "\n",
        "const shouldContinue2 = async (state: typeof MessagesAnnotation.State) => {\n",
        "  const { messages } = state;\n",
        "  const lastMessage = messages[messages.length - 1];\n",
        "  if (isAIMessage(lastMessage) && lastMessage.tool_calls?.length) {\n",
        "    return \"tools\";\n",
        "  }\n",
        "  return \"__end__\";\n",
        "}\n",
        "\n",
        "const shouldFallback = async (state: typeof MessagesAnnotation.State) => {\n",
        "  const { messages } = state;\n",
        "  const failedToolMessages = messages.find((message) => {\n",
        "    return message._getType() === \"tool\" && message.additional_kwargs.error !== undefined;\n",
        "  });\n",
        "  if (failedToolMessages) {\n",
        "    return \"remove_failed_tool_call_attempt\";\n",
        "  }\n",
        "  return \"agent\";\n",
        "}\n",
        "\n",
        "const callModel2 = async (state: typeof MessagesAnnotation.State) => {\n",
        "  const { messages } = state;\n",
        "  const response = await modelWithTools2.invoke(messages);\n",
        "  return { messages: [response] };\n",
        "}\n",
        "\n",
        "const removeFailedToolCallAttempt = async (state: typeof MessagesAnnotation.State) => {\n",
        "  const { messages } = state;\n",
        "  // Remove all messages from the most recent\n",
        "  // instance of AIMessage onwards.\n",
        "  const lastAIMessageIndex = messages\n",
        "    .map((msg, index) => ({ msg, index }))\n",
        "    .reverse()\n",
        "    .findIndex(({ msg }) => isAIMessage(msg));\n",
        "  const messagesToRemove = messages.slice(lastAIMessageIndex);\n",
        "  return { messages: messagesToRemove.map(m => new RemoveMessage({ id: m.id })) };\n",
        "}\n",
        "\n",
        "const callFallbackModel = async (state: typeof MessagesAnnotation.State) => {\n",
        "  const { messages } = state;\n",
        "  const response = await betterModelWithTools.invoke(messages);\n",
        "  return { messages: [response] };\n",
        "}\n",
        "\n",
        "const app2 = new StateGraph(MessagesAnnotation)\n",
        "  .addNode(\"tools\", callTool2)\n",
        "  .addNode(\"agent\", callModel2)\n",
        "  .addNode(\"remove_failed_tool_call_attempt\", removeFailedToolCallAttempt)\n",
        "  .addNode(\"fallback_agent\", callFallbackModel)\n",
        "  .addEdge(\"__start__\", \"agent\")\n",
        "  .addConditionalEdges(\"agent\", shouldContinue2, {\n",
        "    // Explicitly list possible destinations so that\n",
        "    // we can automatically draw the graph below.\n",
        "    tools: \"tools\",\n",
        "    __end__: \"__end__\",\n",
        "  })\n",
        "  .addConditionalEdges(\"tools\", shouldFallback, {\n",
        "    remove_failed_tool_call_attempt: \"remove_failed_tool_call_attempt\",\n",
        "    agent: \"agent\",\n",
        "  })\n",
        "  .addEdge(\"remove_failed_tool_call_attempt\", \"fallback_agent\")\n",
        "  .addEdge(\"fallback_agent\", \"tools\")\n",
        "  .compile();"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The `tools` node will now return `ToolMessage`s with an `error` field in `additional_kwargs` if a tool call fails. If that happens, it will go to another node that removes the failed tool messages, and has a better model retry the tool call generation. We also add a trimming step via returning the special message modifier `RemoveMessage` to remove previous messages from the state.\n",
        "\n",
        "The diagram below shows this visually:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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"
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import * as tslab from \"tslab\";\n",
        "\n",
        "const graph2 = app2.getGraph();\n",
        "const image2 = await graph2.drawMermaidPng();\n",
        "const arrayBuffer2 = await image2.arrayBuffer();\n",
        "\n",
        "await tslab.display.png(new Uint8Array(arrayBuffer2));"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Let's try it out. To emphasize the removal steps, let's `stream` the responses from the model so that we can see each executed node:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{\n",
            "  agent: {\n",
            "    messages: [\n",
            "      AIMessage {\n",
            "        \"id\": \"msg_01HqvhPuubXqerWgYRNFqPrd\",\n",
            "        \"content\": [\n",
            "          {\n",
            "            \"type\": \"text\",\n",
            "            \"text\": \"Okay, let's generate a haiku about water using the master haiku generator tool:\"\n",
            "          },\n",
            "          {\n",
            "            \"type\": \"tool_use\",\n",
            "            \"id\": \"toolu_01QFmyc5vhQBFfzF7hCGTRc1\",\n",
            "            \"name\": \"master_haiku_generator\",\n",
            "            \"input\": {\n",
            "              \"topic\": \"[Array]\"\n",
            "            }\n",
            "          }\n",
            "        ],\n",
            "        \"additional_kwargs\": {\n",
            "          \"id\": \"msg_01HqvhPuubXqerWgYRNFqPrd\",\n",
            "          \"type\": \"message\",\n",
            "          \"role\": \"assistant\",\n",
            "          \"model\": \"claude-3-haiku-20240307\",\n",
            "          \"stop_reason\": \"tool_use\",\n",
            "          \"stop_sequence\": null,\n",
            "          \"usage\": {\n",
            "            \"input_tokens\": 392,\n",
            "            \"output_tokens\": 77\n",
            "          }\n",
            "        },\n",
            "        \"response_metadata\": {\n",
            "          \"id\": \"msg_01HqvhPuubXqerWgYRNFqPrd\",\n",
            "          \"model\": \"claude-3-haiku-20240307\",\n",
            "          \"stop_reason\": \"tool_use\",\n",
            "          \"stop_sequence\": null,\n",
            "          \"usage\": {\n",
            "            \"input_tokens\": 392,\n",
            "            \"output_tokens\": 77\n",
            "          },\n",
            "          \"type\": \"message\",\n",
            "          \"role\": \"assistant\"\n",
            "        },\n",
            "        \"tool_calls\": [\n",
            "          {\n",
            "            \"name\": \"master_haiku_generator\",\n",
            "            \"args\": {\n",
            "              \"topic\": \"[Array]\"\n",
            "            },\n",
            "            \"id\": \"toolu_01QFmyc5vhQBFfzF7hCGTRc1\",\n",
            "            \"type\": \"tool_call\"\n",
            "          }\n",
            "        ],\n",
            "        \"invalid_tool_calls\": [],\n",
            "        \"usage_metadata\": {\n",
            "          \"input_tokens\": 392,\n",
            "          \"output_tokens\": 77,\n",
            "          \"total_tokens\": 469\n",
            "        }\n",
            "      }\n",
            "    ]\n",
            "  }\n",
            "}\n",
            "{\n",
            "  tools: {\n",
            "    messages: [\n",
            "      ToolMessage {\n",
            "        \"id\": \"502c7399-4d95-4afd-8a86-ece864d2bc7f\",\n",
            "        \"content\": \"Received tool input did not match expected schema\",\n",
            "        \"name\": \"master_haiku_generator\",\n",
            "        \"additional_kwargs\": {\n",
            "          \"error\": {\n",
            "            \"output\": \"{\\\"topic\\\":[\\\"water\\\"]}\"\n",
            "          }\n",
            "        },\n",
            "        \"response_metadata\": {},\n",
            "        \"tool_call_id\": \"toolu_01QFmyc5vhQBFfzF7hCGTRc1\"\n",
            "      }\n",
            "    ]\n",
            "  }\n",
            "}\n",
            "{\n",
            "  remove_failed_tool_call_attempt: {\n",
            "    messages: [\n",
            "      BaseMessage {\n",
            "        \"id\": \"msg_01HqvhPuubXqerWgYRNFqPrd\",\n",
            "        \"content\": \"\",\n",
            "        \"additional_kwargs\": {},\n",
            "        \"response_metadata\": {}\n",
            "      },\n",
            "      BaseMessage {\n",
            "        \"id\": \"502c7399-4d95-4afd-8a86-ece864d2bc7f\",\n",
            "        \"content\": \"\",\n",
            "        \"additional_kwargs\": {},\n",
            "        \"response_metadata\": {}\n",
            "      }\n",
            "    ]\n",
            "  }\n",
            "}\n",
            "{\n",
            "  fallback_agent: {\n",
            "    messages: [\n",
            "      AIMessage {\n",
            "        \"id\": \"msg_01EQSawL2oxNhph9be99k7Yp\",\n",
            "        \"content\": [\n",
            "          {\n",
            "            \"type\": \"text\",\n",
            "            \"text\": \"Certainly! I'd be happy to help you create an incredible haiku about water. To do this, we'll use the master_haiku_generator function, which requires three topics as input. Since you've specified water as the main theme, I'll add two related concepts to create a more vivid and interesting haiku. Let's use \\\"water,\\\" \\\"flow,\\\" and \\\"reflection\\\" as our three topics.\\n\\nHere's the function call to generate your haiku:\"\n",
            "          },\n",
            "          {\n",
            "            \"type\": \"tool_use\",\n",
            "            \"id\": \"toolu_017hrp13SsgfdJTdhkJDMaQy\",\n",
            "            \"name\": \"master_haiku_generator\",\n",
            "            \"input\": {\n",
            "              \"topic\": \"[Array]\"\n",
            "            }\n",
            "          }\n",
            "        ],\n",
            "        \"additional_kwargs\": {\n",
            "          \"id\": \"msg_01EQSawL2oxNhph9be99k7Yp\",\n",
            "          \"type\": \"message\",\n",
            "          \"role\": \"assistant\",\n",
            "          \"model\": \"claude-3-5-sonnet-20240620\",\n",
            "          \"stop_reason\": \"tool_use\",\n",
            "          \"stop_sequence\": null,\n",
            "          \"usage\": {\n",
            "            \"input_tokens\": 422,\n",
            "            \"output_tokens\": 162\n",
            "          }\n",
            "        },\n",
            "        \"response_metadata\": {\n",
            "          \"id\": \"msg_01EQSawL2oxNhph9be99k7Yp\",\n",
            "          \"model\": \"claude-3-5-sonnet-20240620\",\n",
            "          \"stop_reason\": \"tool_use\",\n",
            "          \"stop_sequence\": null,\n",
            "          \"usage\": {\n",
            "            \"input_tokens\": 422,\n",
            "            \"output_tokens\": 162\n",
            "          },\n",
            "          \"type\": \"message\",\n",
            "          \"role\": \"assistant\"\n",
            "        },\n",
            "        \"tool_calls\": [\n",
            "          {\n",
            "            \"name\": \"master_haiku_generator\",\n",
            "            \"args\": {\n",
            "              \"topic\": \"[Array]\"\n",
            "            },\n",
            "            \"id\": \"toolu_017hrp13SsgfdJTdhkJDMaQy\",\n",
            "            \"type\": \"tool_call\"\n",
            "          }\n",
            "        ],\n",
            "        \"invalid_tool_calls\": [],\n",
            "        \"usage_metadata\": {\n",
            "          \"input_tokens\": 422,\n",
            "          \"output_tokens\": 162,\n",
            "          \"total_tokens\": 584\n",
            "        }\n",
            "      }\n",
            "    ]\n",
            "  }\n",
            "}\n",
            "{\n",
            "  tools: {\n",
            "    messages: [\n",
            "      ToolMessage {\n",
            "        \"id\": \"3d24d291-7501-4a65-9286-10dc47239b5b\",\n",
            "        \"content\": \"Here is a haiku about water, flow, and reflection:\\n\\nRippling waters flow,\\nMirroring the sky above,\\nTranquil reflection.\",\n",
            "        \"name\": \"master_haiku_generator\",\n",
            "        \"additional_kwargs\": {},\n",
            "        \"response_metadata\": {},\n",
            "        \"tool_call_id\": \"toolu_017hrp13SsgfdJTdhkJDMaQy\"\n",
            "      }\n",
            "    ]\n",
            "  }\n",
            "}\n",
            "{\n",
            "  agent: {\n",
            "    messages: [\n",
            "      AIMessage {\n",
            "        \"id\": \"msg_01Jy7Vw8DN77sjVWcB4TcJR6\",\n",
            "        \"content\": \"I hope you enjoy this haiku about the beauty and serenity of water. Please let me know if you would like me to generate another one.\",\n",
            "        \"additional_kwargs\": {\n",
            "          \"id\": \"msg_01Jy7Vw8DN77sjVWcB4TcJR6\",\n",
            "          \"type\": \"message\",\n",
            "          \"role\": \"assistant\",\n",
            "          \"model\": \"claude-3-haiku-20240307\",\n",
            "          \"stop_reason\": \"end_turn\",\n",
            "          \"stop_sequence\": null,\n",
            "          \"usage\": {\n",
            "            \"input_tokens\": 601,\n",
            "            \"output_tokens\": 35\n",
            "          }\n",
            "        },\n",
            "        \"response_metadata\": {\n",
            "          \"id\": \"msg_01Jy7Vw8DN77sjVWcB4TcJR6\",\n",
            "          \"model\": \"claude-3-haiku-20240307\",\n",
            "          \"stop_reason\": \"end_turn\",\n",
            "          \"stop_sequence\": null,\n",
            "          \"usage\": {\n",
            "            \"input_tokens\": 601,\n",
            "            \"output_tokens\": 35\n",
            "          },\n",
            "          \"type\": \"message\",\n",
            "          \"role\": \"assistant\"\n",
            "        },\n",
            "        \"tool_calls\": [],\n",
            "        \"invalid_tool_calls\": [],\n",
            "        \"usage_metadata\": {\n",
            "          \"input_tokens\": 601,\n",
            "          \"output_tokens\": 35,\n",
            "          \"total_tokens\": 636\n",
            "        }\n",
            "      }\n",
            "    ]\n",
            "  }\n",
            "}\n"
          ]
        }
      ],
      "source": [
        "const stream = await app2.stream(\n",
        "  { messages: [{ role: \"user\", content: \"Write me an incredible haiku about water.\" }] },\n",
        "  { recursionLimit: 10 },\n",
        ")\n",
        "\n",
        "for await (const chunk of stream) {\n",
        "  console.log(chunk);\n",
        "}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "You can see that you get a cleaner response - the more powerful model gets it right on the first try, and the smaller model's failure gets wiped from the graph state. This shorter message history also avoid overpopulating the graph state with attempts.\n",
        "\n",
        "You can also inspect this [LangSmith trace](https://smith.langchain.com/public/c94f95d0-97fc-4d4d-a59a-b5161c2f4a90/r), which shows the failed initial call to the smaller model.\n",
        "\n",
        "## Next steps\n",
        "\n",
        "You've now seen how to implement some strategies to handle tool calling errors.\n",
        "\n",
        "Next, check out some of the [other LangGraph how-to guides here](/langgraphjs/how-tos/)."
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "TypeScript",
      "language": "typescript",
      "name": "tslab"
    },
    "language_info": {
      "codemirror_mode": {
        "mode": "typescript",
        "name": "javascript",
        "typescript": true
      },
      "file_extension": ".ts",
      "mimetype": "text/typescript",
      "name": "typescript",
      "version": "3.7.2"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}