Agent has error calling tool even if is_enabled = True

[NateMoneyLion]

Question

1. I'm using the is_enabled param within the @function_tool decorator to control the tools that are exposed to a user at runtime based on the callable function below to control the value for is_enabled

def _is_cm_enrolled(ctx: RunContextWrapper[AgentContext], agent: AgentBase) -> bool:
    return ctx.context.is_cm_enrolled  # by default is True

2. I always bump into this error if the opening query for the session already calls a tool e.g. "what's my credit score?".

agents.exceptions.ModelBehaviorError: Tool fetch_latest_credit_report" /> not found in agent Agent

Implementation of tool as follows:

@function_tool(is_enabled=_is_cm_enrolled)
async def fetch_latest_credit_report(
    wrapper: RunContextWrapper[AgentContext],
) -> dict | None:
    """
    High level data points e.g.
    - credit score
    - credit utilization rate
    - credit age
    - credit inquiries
    - payment history
    """
    data = await _credit_report_retriever_client._fetch(
          request={
              "user_id": "",
              "request_source": "",
          },
      )

    return data

3. However, if the opening query is something generic like "hello", this error doesn't bubble up.

Am I doing something wrong here?

[ihower]

@NateMoneyLion This happens because the model asks to call fetch_latest_credit_report, but at that time the tool is not registered on the agent due to is_enabled=False. Since the agent no longer has this tool, the SDK raises agents.exceptions.ModelBehaviorError.

In fact, I can’t reproduce this issue with OpenAI models. If the function schema is not provided, OpenAI models usually do not try to call that function.

However, other models behave differently. I can reproduce the same issue with Gemini 2.5 Pro: https://gist.github.com/ihower/39435370e337c03c0ef92dffd42f9af4

So this looks like a model behavior issue. The model seems to remember that the function appeared earlier in the conversation and assumes it is always available, even when it is no longer exposed.

You can try switching to a different model, or adjusting your prompt to make the model avoid calling functions that may not exist.

[NateMoneyLion]

oooh, I'll have a try then.

One thing to note, I did a bit of logging and saw that the fetch _latest_credit_report tool was available

Available tools: ['fetch_latest_credit_report', ...]

However, in the error log, it outputs it as

agents.exceptions.ModelBehaviorError: Tool fetch_latest_credit_report" /> not found in agent Credit Monitoring Agent

Note that the tool name in the error is fetch_latest_credit_report " />. I don't know if this is how the error log should look or if there is a corruption in name-parsing

[ihower]

@NateMoneyLion The SDK does not change the tool name.

This is likely because the model you are using does not support function calling very well, so it returned this incorrect name.

[NateMoneyLion]

I've been testing out Claude Sonnet (jumping between 4 and 4.5) so I don't know if this is an edge case.
Oddly, after trying a lot more, oddly, the tool error comes and goes even with the same query.

I'll try with the OpenAI models.

[ihower]

@NateMoneyLion If you’re using Claude Sonnet, it shouldn’t return a malformed tool name. If you can share a minimal reproducible code, I can help take another look.

[NateMoneyLion]

@ihower ironically, it is the code that you've tested with for Gemini. Let me just paste my exact implementation

import copy
import json
import uuid
from typing import Optional
from uuid import UUID

from agents import (
    Agent,
    ModelSettings,
    OpenAIChatCompletionsModel,
    RunContextWrapper,
    Runner,
)
from openai import AsyncOpenAI

from src.agent.tools import (
    fetch_credit_history,
    fetch_latest_credit_age_data,
    fetch_latest_credit_inquiries_data,
    fetch_latest_credit_report,
    fetch_latest_credit_utilization_data,
    fetch_latest_payment_history_data,
)

from src.schemas.request import AgentContext, AgentResponse


class CreditAgent:
    """Custom Agent for credit insights"""

    def __init__(self, litellm_api_key: str, litellm_api_base: str):
        # attributes
        self.service_name = "Credit Monitoring Agent"
        self.llm_model = "bedrock-claude4.5-sonnet-120s"
        self.instructions = "
        self.tools = [
            fetch_latest_credit_report,
            fetch_credit_history,
            fetch_latest_credit_utilization_data,
            fetch_latest_credit_age_data,
            fetch_latest_credit_inquiries_data,
            fetch_latest_payment_history_data,
        ]

        # infra
        self.litellm_api_key = litellm_api_key
        self.litellm_api_base = litellm_api_base

        # initialize agent
        self._init_agent()

    def __get_openai_client(self) -> AsyncOpenAI:
        """Initialize and return the OpenAI client."""
        return AsyncOpenAI(
            api_key=self.litellm_api_key,
            base_url=self.litellm_api_base,
            max_retries=0,
        )

    def _dynamic_instructions(
        self, ctx: RunContextWrapper[AgentContext], agent: Agent[AgentContext]
    ) -> str:
        """
        Dynamic instructions that incorporate user context.
        Called at runtime before each agent invocation.
        """
        if ctx.context.custom_system_prompt:
            return ctx.context.custom_system_prompt

        return self.instructions

    def _init_agent(self):

        llm = OpenAIChatCompletionsModel(
            model=self.llm_model,
            openai_client=self.__get_openai_client(),
        )

        self._agent = Agent[AgentContext](
            name=self.service_name,
            instructions=self._dynamic_instructions,  # Pass the method as a callable
            model=llm,
            model_settings=ModelSettings(
                temperature=0.0,
                extra_body={"cache": {"no-cache": True, "no-store": True}},
                tool_choice="auto",
            ),
            tools=self.tools,
        )

    def _augment(self, input: str, message_history: list) -> str:
        """
        Augment the prompt with additional context or information.

        In this case, it is augmenting the user's input with message_history (if it exists).
        """
        # consolidate message history (if there is any) and user input to be passed to Agent
        if message_history:
            copy__message_history = copy.deepcopy(message_history)
            copy__message_history.append({"role": "user", "content": input})
            return copy__message_history
        else:
            return [{"role": "user", "content": input}]

    async def ask_agent(
        self,
        question: str,
        user_id: str | None = None,
        context: AgentContext | None = None,
        session_id: Optional[UUID] = None,
    ) -> AgentResponse:
        """
        Ask the agent a question , if session_id is not provided, a new session will be created.
        """
        if not session_id:
            session_id = uuid.uuid4()

        if context is None:
            context = AgentContext(user_id=user_id)

        # insert user_id into AgentContext since it is needed by tools
        context.user_id = user_id

        # strip the question of whitespaces before starting
        question = question.strip()

        message_history = []

        user_data = {}

        context.is_cm_enrolled = True/False (can just hardcode for now)

        # check message history before conversation
        print(f"Before conversation message history:\n{message_history}")

        # prepare message history + user question to be passed into the agent
        input = self._augment(input=question, message_history=message_history)
        # check formatted input
        print(f"Formatted input:\n{input}")

        agent_response = await Runner.run(
            starting_agent=self._agent,
            input=input,
            context=context,
        )

        print(f"Final output:\n{agent_response.final_output}")

        return AgentResponse(result=agent_response.final_output, session_id=session_id)

I've omitted any message history saving logic at the moment