langchain 0.3.26__py3-none-any.whl → 0.3.27__py3-none-any.whl

langchain/agents/openai_functions_multi_agent/base.py

@@ -38,26 +38,29 @@ _FunctionsAgentAction = AgentActionMessageLog
 def _parse_ai_message(message: BaseMessage) -> Union[list[AgentAction], AgentFinish]:
     """Parse an AI message."""
     if not isinstance(message, AIMessage):
-        raise TypeError(f"Expected an AI message got {type(message)}")
+        msg = f"Expected an AI message got {type(message)}"
+        raise TypeError(msg)
 
     function_call = message.additional_kwargs.get("function_call", {})
 
     if function_call:
         try:
             arguments = json.loads(function_call["arguments"], strict=False)
-        except JSONDecodeError:
-            raise OutputParserException(
+        except JSONDecodeError as e:
+            msg = (
                 f"Could not parse tool input: {function_call} because "
                 f"the `arguments` is not valid JSON."
             )
+            raise OutputParserException(msg) from e
 
         try:
             tools = arguments["actions"]
-        except (TypeError, KeyError):
-            raise OutputParserException(
+        except (TypeError, KeyError) as e:
+            msg = (
                 f"Could not parse tool input: {function_call} because "
                 f"the `arguments` JSON does not contain `actions` key."
             )
+            raise OutputParserException(msg) from e
 
         final_tools: list[AgentAction] = []
         for tool_schema in tools:
@@ -92,10 +95,14 @@ def _parse_ai_message(message: BaseMessage) -> Union[list[AgentAction], AgentFin
         return final_tools
 
     return AgentFinish(
-        return_values={"output": message.content}, log=str(message.content)
+        return_values={"output": message.content},
+        log=str(message.content),
     )
 
 
+_NOT_SET = object()
+
+
 @deprecated("0.1.0", alternative="create_openai_tools_agent", removal="1.0")
 class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
     """Agent driven by OpenAIs function powered API.
@@ -121,10 +128,11 @@ class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
     def validate_prompt(self) -> Self:
         prompt: BasePromptTemplate = self.prompt
         if "agent_scratchpad" not in prompt.input_variables:
-            raise ValueError(
+            msg = (
                 "`agent_scratchpad` should be one of the variables in the prompt, "
                 f"got {prompt.input_variables}"
             )
+            raise ValueError(msg)
         return self
 
     @property
@@ -186,7 +194,7 @@ class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
                             },
                             "required": ["action_name", "action"],
                         },
-                    }
+                    },
                 },
                 "required": ["actions"],
             },
@@ -218,10 +226,11 @@ class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
         prompt = self.prompt.format_prompt(**full_inputs)
         messages = prompt.to_messages()
         predicted_message = self.llm.predict_messages(
-            messages, functions=self.functions, callbacks=callbacks
+            messages,
+            functions=self.functions,
+            callbacks=callbacks,
         )
-        agent_decision = _parse_ai_message(predicted_message)
-        return agent_decision
+        return _parse_ai_message(predicted_message)
 
     async def aplan(
         self,
@@ -248,17 +257,16 @@ class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
         prompt = self.prompt.format_prompt(**full_inputs)
         messages = prompt.to_messages()
         predicted_message = await self.llm.apredict_messages(
-            messages, functions=self.functions, callbacks=callbacks
+            messages,
+            functions=self.functions,
+            callbacks=callbacks,
         )
-        agent_decision = _parse_ai_message(predicted_message)
-        return agent_decision
+        return _parse_ai_message(predicted_message)
 
     @classmethod
     def create_prompt(
         cls,
-        system_message: Optional[SystemMessage] = SystemMessage(
-            content="You are a helpful AI assistant."
-        ),
+        system_message: Optional[SystemMessage] = _NOT_SET,  # type: ignore[assignment]
         extra_prompt_messages: Optional[list[BaseMessagePromptTemplate]] = None,
     ) -> BasePromptTemplate:
         """Create prompt for this agent.
@@ -273,18 +281,20 @@ class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
             A prompt template to pass into this agent.
         """
         _prompts = extra_prompt_messages or []
+        system_message_ = (
+            system_message
+            if system_message is not _NOT_SET
+            else SystemMessage(content="You are a helpful AI assistant.")
+        )
         messages: list[Union[BaseMessagePromptTemplate, BaseMessage]]
-        if system_message:
-            messages = [system_message]
-        else:
-            messages = []
+        messages = [system_message_] if system_message_ else []
 
         messages.extend(
             [
                 *_prompts,
                 HumanMessagePromptTemplate.from_template("{input}"),
                 MessagesPlaceholder(variable_name="agent_scratchpad"),
-            ]
+            ],
         )
         return ChatPromptTemplate(messages=messages)
 
@@ -295,9 +305,7 @@ class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
         tools: Sequence[BaseTool],
         callback_manager: Optional[BaseCallbackManager] = None,
         extra_prompt_messages: Optional[list[BaseMessagePromptTemplate]] = None,
-        system_message: Optional[SystemMessage] = SystemMessage(
-            content="You are a helpful AI assistant."
-        ),
+        system_message: Optional[SystemMessage] = _NOT_SET,  # type: ignore[assignment]
         **kwargs: Any,
     ) -> BaseMultiActionAgent:
         """Construct an agent from an LLM and tools.
@@ -311,9 +319,14 @@ class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
                 Default is a default system message.
             kwargs: Additional arguments.
         """
+        system_message_ = (
+            system_message
+            if system_message is not _NOT_SET
+            else SystemMessage(content="You are a helpful AI assistant.")
+        )
         prompt = cls.create_prompt(
             extra_prompt_messages=extra_prompt_messages,
-            system_message=system_message,
+            system_message=system_message_,
         )
         return cls(  # type: ignore[call-arg]
             llm=llm,

langchain/agents/openai_tools/base.py

@@ -17,7 +17,7 @@ def create_openai_tools_agent(
     llm: BaseLanguageModel,
     tools: Sequence[BaseTool],
     prompt: ChatPromptTemplate,
-    strict: Optional[bool] = None,
+    strict: Optional[bool] = None,  # noqa: FBT001
 ) -> Runnable:
     """Create an agent that uses OpenAI tools.
 
@@ -86,23 +86,23 @@ def create_openai_tools_agent(
             )
     """
     missing_vars = {"agent_scratchpad"}.difference(
-        prompt.input_variables + list(prompt.partial_variables)
+        prompt.input_variables + list(prompt.partial_variables),
     )
     if missing_vars:
-        raise ValueError(f"Prompt missing required variables: {missing_vars}")
+        msg = f"Prompt missing required variables: {missing_vars}"
+        raise ValueError(msg)
 
     llm_with_tools = llm.bind(
-        tools=[convert_to_openai_tool(tool, strict=strict) for tool in tools]
+        tools=[convert_to_openai_tool(tool, strict=strict) for tool in tools],
     )
 
-    agent = (
+    return (
         RunnablePassthrough.assign(
             agent_scratchpad=lambda x: format_to_openai_tool_messages(
-                x["intermediate_steps"]
-            )
+                x["intermediate_steps"],
+            ),
         )
         | prompt
         | llm_with_tools
         | OpenAIToolsAgentOutputParser()
     )
-    return agent

langchain/agents/output_parsers/__init__.py

@@ -25,11 +25,11 @@ from langchain.agents.output_parsers.tools import ToolsAgentOutputParser
 from langchain.agents.output_parsers.xml import XMLAgentOutputParser
 
 __all__ = [
+    "JSONAgentOutputParser",
+    "OpenAIFunctionsAgentOutputParser",
+    "ReActJsonSingleInputOutputParser",
     "ReActSingleInputOutputParser",
     "SelfAskOutputParser",
     "ToolsAgentOutputParser",
-    "ReActJsonSingleInputOutputParser",
-    "OpenAIFunctionsAgentOutputParser",
     "XMLAgentOutputParser",
-    "JSONAgentOutputParser",
 ]

langchain/agents/output_parsers/json.py

@@ -49,13 +49,13 @@ class JSONAgentOutputParser(AgentOutputParser):
                 response = response[0]
             if response["action"] == "Final Answer":
                 return AgentFinish({"output": response["action_input"]}, text)
-            else:
-                action_input = response.get("action_input", {})
-                if action_input is None:
-                    action_input = {}
-                return AgentAction(response["action"], action_input, text)
+            action_input = response.get("action_input", {})
+            if action_input is None:
+                action_input = {}
+            return AgentAction(response["action"], action_input, text)
         except Exception as e:
-            raise OutputParserException(f"Could not parse LLM output: {text}") from e
+            msg = f"Could not parse LLM output: {text}"
+            raise OutputParserException(msg) from e
 
     @property
     def _type(self) -> str:

langchain/agents/output_parsers/openai_functions.py

@@ -33,7 +33,8 @@ class OpenAIFunctionsAgentOutputParser(AgentOutputParser):
     def _parse_ai_message(message: BaseMessage) -> Union[AgentAction, AgentFinish]:
         """Parse an AI message."""
         if not isinstance(message, AIMessage):
-            raise TypeError(f"Expected an AI message got {type(message)}")
+            msg = f"Expected an AI message got {type(message)}"
+            raise TypeError(msg)
 
         function_call = message.additional_kwargs.get("function_call", {})
 
@@ -46,11 +47,12 @@ class OpenAIFunctionsAgentOutputParser(AgentOutputParser):
                 else:
                     # otherwise it returns a json object
                     _tool_input = json.loads(function_call["arguments"], strict=False)
-            except JSONDecodeError:
-                raise OutputParserException(
+            except JSONDecodeError as e:
+                msg = (
                     f"Could not parse tool input: {function_call} because "
                     f"the `arguments` is not valid JSON."
                 )
+                raise OutputParserException(msg) from e
 
             # HACK HACK HACK:
             # The code that encodes tool input into Open AI uses a special variable
@@ -73,16 +75,22 @@ class OpenAIFunctionsAgentOutputParser(AgentOutputParser):
             )
 
         return AgentFinish(
-            return_values={"output": message.content}, log=str(message.content)
+            return_values={"output": message.content},
+            log=str(message.content),
         )
 
     def parse_result(
-        self, result: list[Generation], *, partial: bool = False
+        self,
+        result: list[Generation],
+        *,
+        partial: bool = False,
     ) -> Union[AgentAction, AgentFinish]:
         if not isinstance(result[0], ChatGeneration):
-            raise ValueError("This output parser only works on ChatGeneration output")
+            msg = "This output parser only works on ChatGeneration output"
+            raise ValueError(msg)  # noqa: TRY004
         message = result[0].message
         return self._parse_ai_message(message)
 
     def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
-        raise ValueError("Can only parse messages")
+        msg = "Can only parse messages"
+        raise ValueError(msg)

langchain/agents/output_parsers/openai_tools.py

@@ -30,7 +30,7 @@ def parse_ai_message_to_openai_tool_action(
                     log=action.log,
                     message_log=action.message_log,
                     tool_call_id=action.tool_call_id,
-                )
+                ),
             )
         else:
             final_actions.append(action)
@@ -54,12 +54,17 @@ class OpenAIToolsAgentOutputParser(MultiActionAgentOutputParser):
         return "openai-tools-agent-output-parser"
 
     def parse_result(
-        self, result: list[Generation], *, partial: bool = False
+        self,
+        result: list[Generation],
+        *,
+        partial: bool = False,
     ) -> Union[list[AgentAction], AgentFinish]:
         if not isinstance(result[0], ChatGeneration):
-            raise ValueError("This output parser only works on ChatGeneration output")
+            msg = "This output parser only works on ChatGeneration output"
+            raise ValueError(msg)  # noqa: TRY004
         message = result[0].message
         return parse_ai_message_to_openai_tool_action(message)
 
     def parse(self, text: str) -> Union[list[AgentAction], AgentFinish]:
-        raise ValueError("Can only parse messages")
+        msg = "Can only parse messages"
+        raise ValueError(msg)

langchain/agents/output_parsers/react_json_single_input.py

@@ -55,22 +55,27 @@ class ReActJsonSingleInputOutputParser(AgentOutputParser):
             found = self.pattern.search(text)
             if not found:
                 # Fast fail to parse Final Answer.
-                raise ValueError("action not found")
+                msg = "action not found"
+                raise ValueError(msg)
             action = found.group(1)
             response = json.loads(action.strip())
             includes_action = "action" in response
             if includes_answer and includes_action:
-                raise OutputParserException(
+                msg = (
                     "Parsing LLM output produced a final answer "
                     f"and a parse-able action: {text}"
                 )
+                raise OutputParserException(msg)
             return AgentAction(
-                response["action"], response.get("action_input", {}), text
+                response["action"],
+                response.get("action_input", {}),
+                text,
             )
 
-        except Exception:
+        except Exception as e:
             if not includes_answer:
-                raise OutputParserException(f"Could not parse LLM output: {text}")
+                msg = f"Could not parse LLM output: {text}"
+                raise OutputParserException(msg) from e
             output = text.split(FINAL_ANSWER_ACTION)[-1].strip()
             return AgentFinish({"output": output}, text)
 

langchain/agents/output_parsers/react_single_input.py

@@ -56,9 +56,8 @@ class ReActSingleInputOutputParser(AgentOutputParser):
         action_match = re.search(regex, text, re.DOTALL)
         if action_match:
             if includes_answer:
-                raise OutputParserException(
-                    f"{FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE}: {text}"
-                )
+                msg = f"{FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE}: {text}"
+                raise OutputParserException(msg)
             action = action_match.group(1).strip()
             action_input = action_match.group(2)
             tool_input = action_input.strip(" ")
@@ -66,29 +65,34 @@ class ReActSingleInputOutputParser(AgentOutputParser):
 
             return AgentAction(action, tool_input, text)
 
-        elif includes_answer:
+        if includes_answer:
             return AgentFinish(
-                {"output": text.split(FINAL_ANSWER_ACTION)[-1].strip()}, text
+                {"output": text.split(FINAL_ANSWER_ACTION)[-1].strip()},
+                text,
             )
 
         if not re.search(r"Action\s*\d*\s*:[\s]*(.*?)", text, re.DOTALL):
+            msg = f"Could not parse LLM output: `{text}`"
             raise OutputParserException(
-                f"Could not parse LLM output: `{text}`",
+                msg,
                 observation=MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE,
                 llm_output=text,
                 send_to_llm=True,
             )
-        elif not re.search(
-            r"[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)", text, re.DOTALL
+        if not re.search(
+            r"[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)",
+            text,
+            re.DOTALL,
         ):
+            msg = f"Could not parse LLM output: `{text}`"
             raise OutputParserException(
-                f"Could not parse LLM output: `{text}`",
+                msg,
                 observation=MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE,
                 llm_output=text,
                 send_to_llm=True,
             )
-        else:
-            raise OutputParserException(f"Could not parse LLM output: `{text}`")
+        msg = f"Could not parse LLM output: `{text}`"
+        raise OutputParserException(msg)
 
     @property
     def _type(self) -> str:

langchain/agents/output_parsers/self_ask.py

@@ -37,9 +37,10 @@ class SelfAskOutputParser(AgentOutputParser):
 
     def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
         last_line = text.split("\n")[-1]
-        if not any([follow in last_line for follow in self.followups]):
+        if not any(follow in last_line for follow in self.followups):
             if self.finish_string not in last_line:
-                raise OutputParserException(f"Could not parse output: {text}")
+                msg = f"Could not parse output: {text}"
+                raise OutputParserException(msg)
             return AgentFinish({"output": last_line[len(self.finish_string) :]}, text)
 
         after_colon = text.split(":")[-1].strip()

langchain/agents/output_parsers/tools.py

@@ -24,7 +24,8 @@ def parse_ai_message_to_tool_action(
 ) -> Union[list[AgentAction], AgentFinish]:
     """Parse an AI message potentially containing tool_calls."""
     if not isinstance(message, AIMessage):
-        raise TypeError(f"Expected an AI message got {type(message)}")
+        msg = f"Expected an AI message got {type(message)}"
+        raise TypeError(msg)
 
     actions: list = []
     if message.tool_calls:
@@ -32,7 +33,8 @@ def parse_ai_message_to_tool_action(
     else:
         if not message.additional_kwargs.get("tool_calls"):
             return AgentFinish(
-                return_values={"output": message.content}, log=str(message.content)
+                return_values={"output": message.content},
+                log=str(message.content),
             )
         # Best-effort parsing
         tool_calls = []
@@ -42,13 +44,14 @@ def parse_ai_message_to_tool_action(
             try:
                 args = json.loads(function["arguments"] or "{}")
                 tool_calls.append(
-                    ToolCall(name=function_name, args=args, id=tool_call["id"])
+                    ToolCall(name=function_name, args=args, id=tool_call["id"]),
                 )
-            except JSONDecodeError:
-                raise OutputParserException(
+            except JSONDecodeError as e:
+                msg = (
                     f"Could not parse tool input: {function} because "
                     f"the `arguments` is not valid JSON."
                 )
+                raise OutputParserException(msg) from e
     for tool_call in tool_calls:
         # HACK HACK HACK:
         # The code that encodes tool input into Open AI uses a special variable
@@ -58,10 +61,7 @@ def parse_ai_message_to_tool_action(
         # Open AI does not support passing in a JSON array as an argument.
         function_name = tool_call["name"]
         _tool_input = tool_call["args"]
-        if "__arg1" in _tool_input:
-            tool_input = _tool_input["__arg1"]
-        else:
-            tool_input = _tool_input
+        tool_input = _tool_input.get("__arg1", _tool_input)
 
         content_msg = f"responded: {message.content}\n" if message.content else "\n"
         log = f"\nInvoking: `{function_name}` with `{tool_input}`\n{content_msg}\n"
@@ -72,7 +72,7 @@ def parse_ai_message_to_tool_action(
                 log=log,
                 message_log=[message],
                 tool_call_id=tool_call["id"],
-            )
+            ),
         )
     return actions
 
@@ -91,12 +91,17 @@ class ToolsAgentOutputParser(MultiActionAgentOutputParser):
         return "tools-agent-output-parser"
 
     def parse_result(
-        self, result: list[Generation], *, partial: bool = False
+        self,
+        result: list[Generation],
+        *,
+        partial: bool = False,
     ) -> Union[list[AgentAction], AgentFinish]:
         if not isinstance(result[0], ChatGeneration):
-            raise ValueError("This output parser only works on ChatGeneration output")
+            msg = "This output parser only works on ChatGeneration output"
+            raise ValueError(msg)  # noqa: TRY004
         message = result[0].message
         return parse_ai_message_to_tool_action(message)
 
     def parse(self, text: str) -> Union[list[AgentAction], AgentFinish]:
-        raise ValueError("Can only parse messages")
+        msg = "Can only parse messages"
+        raise ValueError(msg)

langchain/agents/output_parsers/xml.py

@@ -1,48 +1,119 @@
-from typing import Union
+import re
+from typing import Literal, Optional, Union
 
 from langchain_core.agents import AgentAction, AgentFinish
+from pydantic import Field
 
 from langchain.agents import AgentOutputParser
 
 
+def _unescape(text: str) -> str:
+    """Convert custom tag delimiters back into XML tags."""
+    replacements = {
+        "[[tool]]": "<tool>",
+        "[[/tool]]": "</tool>",
+        "[[tool_input]]": "<tool_input>",
+        "[[/tool_input]]": "</tool_input>",
+        "[[observation]]": "<observation>",
+        "[[/observation]]": "</observation>",
+    }
+    for repl, orig in replacements.items():
+        text = text.replace(repl, orig)
+    return text
+
+
 class XMLAgentOutputParser(AgentOutputParser):
-    """Parses tool invocations and final answers in XML format.
+    """Parses tool invocations and final answers from XML-formatted agent output.
+
+    This parser extracts structured information from XML tags to determine whether
+    an agent should perform a tool action or provide a final answer. It includes
+    built-in escaping support to safely handle tool names and inputs
+    containing XML special characters.
+
+    Args:
+        escape_format: The escaping format to use when parsing XML content.
+            Supports 'minimal' which uses custom delimiters like [[tool]] to replace
+            XML tags within content, preventing parsing conflicts.
+            Use 'minimal' if using a corresponding encoding format that uses
+            the _escape function when formatting the output (e.g., with format_xml).
+
+    Expected formats:
+        Tool invocation (returns AgentAction):
+            <tool>search</tool>
+            <tool_input>what is 2 + 2</tool_input>
 
-    Expects output to be in one of two formats.
+        Final answer (returns AgentFinish):
+            <final_answer>The answer is 4</final_answer>
 
-    If the output signals that an action should be taken,
-    should be in the below format. This will result in an AgentAction
-    being returned.
+    Note:
+        Minimal escaping allows tool names containing XML tags to be safely
+        represented. For example, a tool named "search<tool>nested</tool>" would be
+        escaped as "search[[tool]]nested[[/tool]]" in the XML and automatically
+        unescaped during parsing.
 
-    ```
-    <tool>search</tool>
-    <tool_input>what is 2 + 2</tool_input>
-    ```
+    Raises:
+        ValueError: If the input doesn't match either expected XML format or
+            contains malformed XML structure.
+    """
+
+    escape_format: Optional[Literal["minimal"]] = Field(default="minimal")
+    """The format to use for escaping XML characters.
 
-    If the output signals that a final answer should be given,
-    should be in the below format. This will result in an AgentFinish
-    being returned.
+    minimal - uses custom delimiters to replace XML tags within content,
+    preventing parsing conflicts. This is the only supported format currently.
 
-    ```
-    <final_answer>Foo</final_answer>
-    ```
+    None - no escaping is applied, which may lead to parsing conflicts.
     """
 
     def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
-        if "</tool>" in text:
-            tool, tool_input = text.split("</tool>")
-            _tool = tool.split("<tool>")[1]
-            _tool_input = tool_input.split("<tool_input>")[1]
-            if "</tool_input>" in _tool_input:
-                _tool_input = _tool_input.split("</tool_input>")[0]
+        # Check for tool invocation first
+        tool_matches = re.findall(r"<tool>(.*?)</tool>", text, re.DOTALL)
+        if tool_matches:
+            if len(tool_matches) != 1:
+                msg = (
+                    f"Malformed tool invocation: expected exactly one <tool> block, "
+                    f"but found {len(tool_matches)}."
+                )
+                raise ValueError(msg)
+            _tool = tool_matches[0]
+
+            # Match optional tool input
+            input_matches = re.findall(
+                r"<tool_input>(.*?)</tool_input>", text, re.DOTALL
+            )
+            if len(input_matches) > 1:
+                msg = (
+                    f"Malformed tool invocation: expected at most one <tool_input> "
+                    f"block, but found {len(input_matches)}."
+                )
+                raise ValueError(msg)
+            _tool_input = input_matches[0] if input_matches else ""
+
+            # Unescape if minimal escape format is used
+            if self.escape_format == "minimal":
+                _tool = _unescape(_tool)
+                _tool_input = _unescape(_tool_input)
+
             return AgentAction(tool=_tool, tool_input=_tool_input, log=text)
-        elif "<final_answer>" in text:
-            _, answer = text.split("<final_answer>")
-            if "</final_answer>" in answer:
-                answer = answer.split("</final_answer>")[0]
+        # Check for final answer
+        if "<final_answer>" in text and "</final_answer>" in text:
+            matches = re.findall(r"<final_answer>(.*?)</final_answer>", text, re.DOTALL)
+            if len(matches) != 1:
+                msg = (
+                    "Malformed output: expected exactly one "
+                    "<final_answer>...</final_answer> block."
+                )
+                raise ValueError(msg)
+            answer = matches[0]
+            # Unescape custom delimiters in final answer
+            if self.escape_format == "minimal":
+                answer = _unescape(answer)
             return AgentFinish(return_values={"output": answer}, log=text)
-        else:
-            raise ValueError
+        msg = (
+            "Malformed output: expected either a tool invocation "
+            "or a final answer in XML format."
+        )
+        raise ValueError(msg)
 
     def get_format_instructions(self) -> str:
         raise NotImplementedError