LangChain AgentExecutor — infinite loop, max_iterations reached

from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

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

prompt = ChatPromptTemplate.from_messages([
    ("system",
     "You are helpful. Use tools to gather information. "
     "When you have enough information to answer, PROVIDE THE FINAL ANSWER "
     "immediately — do not keep calling tools."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_tool_calling_agent(model, tools, prompt)

# Every executor needs bounds
executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=8,                    # never more than 8 tool calls
    max_execution_time=60,               # 60 seconds wall clock
    early_stopping_method="generate",    # ask model for final answer if we cap out
    handle_parsing_errors=True,          # gracefully handle parse errors as tool errors
    return_intermediate_steps=True,      # for observability
)

result = executor.invoke({"input": "What is the weather in Karachi?"})
print("output:", result["output"])
print(f"steps taken: {len(result['intermediate_steps'])}")

from langchain_core.tools import tool

@tool
def search(query: str) -> str:
    """Search for information about a topic.

    Args:
        query: What to search for.

    Returns:
        A structured result or a clear "no results" signal.
    """
    results = do_search(query)

    if not results:
        # ❌ WRONG — vague signal invites retry
        # return "No results."
        # return ""
        # return "I could not find anything."

        # ✓ RIGHT — explicit, machine-parseable "empty" signal
        return f"NO_RESULTS for query: {query!r}. Do not retry this query."

    if len(results) > 20:
        # Truncate and be explicit
        return "\n".join(f"{i+1}. {r}" for i, r in enumerate(results[:20])) + \
               f"\n\n[Showing top 20 of {len(results)} total results]"

    return "\n".join(f"{i+1}. {r}" for i, r in enumerate(results))


@tool
def fetch_page(url: str) -> str:
    """Fetch and return the text content of a web page.

    Args:
        url: Full URL to fetch.

    Returns:
        The page text, or an explicit error indicator.
    """
    try:
        return fetch_url(url)  # returns page text
    except TimeoutError:
        # ❌ WRONG — generic error text; model may retry
        # return "Error: timeout occurred while fetching."
        # ✓ RIGHT — explicit non-retry signal
        return f"FETCH_ERROR: TIMEOUT for {url}. The page cannot be reached. Do not retry."
    except HTTPError as e:
        return f"FETCH_ERROR: HTTP {e.status_code} for {url}. Do not retry."
    except Exception as e:
        return f"FETCH_ERROR: {type(e).__name__} for {url}. Do not retry."

from langchain_core.callbacks import BaseCallbackHandler
from langchain.agents import AgentExecutor

class CostLimitCallback(BaseCallbackHandler):
    """Raise when accumulated token cost exceeds a threshold."""

    def __init__(self,
                 input_token_price_per_mtok: float,
                 output_token_price_per_mtok: float,
                 hard_cap_usd: float):
        self.in_price = input_token_price_per_mtok / 1_000_000
        self.out_price = output_token_price_per_mtok / 1_000_000
        self.hard_cap = hard_cap_usd
        self.spent = 0.0

    def on_llm_end(self, response, **kwargs):
        usage = response.llm_output.get("token_usage", {}) if response.llm_output else {}
        in_tokens = usage.get("prompt_tokens", 0) or usage.get("input_tokens", 0)
        out_tokens = usage.get("completion_tokens", 0) or usage.get("output_tokens", 0)
        self.spent += in_tokens * self.in_price + out_tokens * self.out_price
        print(f"[cost] +${in_tokens*self.in_price + out_tokens*self.out_price:.4f} "
              f"total ${self.spent:.4f}")
        if self.spent > self.hard_cap:
            raise RuntimeError(
                f"Cost cap ${self.hard_cap:.2f} exceeded (spent ${self.spent:.2f}). "
                f"Aborting agent."
            )

# Bind to executor
cost_cb = CostLimitCallback(
    input_token_price_per_mtok=15.0,   # e.g. Opus 4.7 input
    output_token_price_per_mtok=75.0,  # e.g. Opus 4.7 output
    hard_cap_usd=0.50,                 # kill anything spending > $0.50 on one request
)

executor = AgentExecutor(
    agent=agent,
    tools=tools,
    max_iterations=15,
    max_execution_time=120,
    early_stopping_method="generate",
    callbacks=[cost_cb],
)

# The callback raises inside the agent loop if cost is exceeded
try:
    result = executor.invoke({"input": "very complex query"})
except RuntimeError as e:
    print(f"Aborted: {e}")