LangChain ReAct agent — Could not parse LLM output

from langchain.agents import AgentExecutor, create_react_agent
from langchain_openai import ChatOpenAI
from langchain_core.prompts import PromptTemplate
from langchain import hub

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

# Load the standard ReAct prompt
prompt = hub.pull("hwchase17/react")

# Or write your own with explicit examples
custom_prompt = PromptTemplate.from_template("""
Answer the following question using the tools available.

TOOLS:
{tools}

Follow this EXACT format:

Thought: your reasoning about what to do
Action: the tool name (one of [{tool_names}])
Action Input: the input to the tool
Observation: the tool result (system will fill in)
... (repeat Thought/Action/Action Input/Observation as needed)
Thought: I now know the final answer
Final Answer: your final answer to the user

Question: {input}
{agent_scratchpad}
""")

agent = create_react_agent(llm, tools, custom_prompt)

executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=8,
    handle_parsing_errors=True,          # ← retry on parse failure
    # Alternative: pass a callable
    # handle_parsing_errors=lambda e: f"Parsing error: {e}. Please respond in the exact ReAct format.",
    early_stopping_method="generate",
)

result = executor.invoke({"input": "What is the weather in Karachi?"})

# BEFORE — fragile ReAct agent
# from langchain.agents import create_react_agent, AgentExecutor
# from langchain import hub
# prompt = hub.pull("hwchase17/react")
# agent = create_react_agent(llm, tools, prompt)
# executor = AgentExecutor(agent=agent, tools=tools, handle_parsing_errors=True)

# AFTER — robust tool-calling agent
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini")

# The tool-calling agent prompt is simpler — no format-enforcement bloat
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are helpful. Use tools when they help. "
               "When you have enough information, produce the final answer."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_tool_calling_agent(llm, tools, prompt)

executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=8,
    max_execution_time=60,
    early_stopping_method="generate",
    # handle_parsing_errors is unnecessary — tool calls are structured
)

result = executor.invoke({"input": "What is the weather in Karachi?"})
print(result["output"])

# Tool-calling agents also support parallel tool calls when the provider does
llm_parallel = ChatOpenAI(model="gpt-4o-mini")
agent_parallel = create_tool_calling_agent(llm_parallel, tools, prompt)
executor_parallel = AgentExecutor(agent=agent_parallel, tools=tools, ...)

import re
from langchain.agents.output_parsers.react_single_input import ReActSingleInputOutputParser
from langchain_core.agents import AgentAction, AgentFinish
from langchain_core.exceptions import OutputParserException

class LenientReActParser(ReActSingleInputOutputParser):
    """Handles common ReAct format deviations before the strict parser."""

    def parse(self, text: str):
        # Strip markdown code fences that some models emit
        cleaned = re.sub(r"```(?:json|python)?\n?(.+?)\n?```", r"\1", text, flags=re.DOTALL)

        # Sometimes models emit "Thought" without colon — add it
        cleaned = re.sub(r"^Thought(?!:)", "Thought:", cleaned, flags=re.MULTILINE)

        # Sometimes models write "Answer:" instead of "Final Answer:"
        cleaned = re.sub(r"^Answer:", "Final Answer:", cleaned, flags=re.MULTILINE)

        try:
            return super().parse(cleaned)
        except OutputParserException:
            # Fallback: if the text ends without an Action, treat it as final answer
            if "Action:" not in cleaned:
                return AgentFinish(
                    return_values={"output": cleaned.strip()},
                    log=text,
                )
            raise  # re-raise so handle_parsing_errors kicks in

# Use it with the executor
from langchain.agents import create_react_agent
agent = create_react_agent(llm, tools, prompt, output_parser=LenientReActParser())