Code to Produce the Behavior

Oct 13, 2025 by magicalceylontours.com 20 views

Introduction

In this article, we will discuss a bug that occurs when using the @tool decorator with a function assigned to the "post_hook" argument. The assigned function is called before the designated function is executed, which is not the desired behavior according to the documentation. We will explore the code that produces this behavior and provide a solution to fix the issue.

Description of the Bug

When using the @tool decorator with a function assigned to the "post_hook" argument, the assigned function is called before the designated function is executed. This is not the desired behavior, as the documentation states that the post_hook function should be called after the function execution.

Code to Produce the Behavior

The code that produces this behavior is as follows:

from textwrap import dedent
from rich.console import Console
from rich.prompt import Prompt
from agno.agent import Agent
from agno.exceptions import StopAgentRun
from agno.tools import FunctionCall, tool
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.models.openai import OpenAIChat

# This is the console instance used by the print_response method
# We can use this to stop and restart the live display and ask for user confirmation
console = Console()

def pre_hook_function(fc: FunctionCall):
    # Get the live display instance from the console
    live = console._live

    # Stop the live display temporarily so we can ask for user confirmation
    live.stop()  # type: ignore

    # Ask for confirmation
    console.print(f"\nAbout to run [bold blue]{fc.function.name}[/]")
    message = Prompt.ask("Do you want to continue?", choices=["y", "n"], default="y").strip().lower()

    # Restart the live display
    live.start()  # type: ignore

    # If the user does not want to continue, raise a StopExecution exception
    if message == "n":
        raise StopAgentRun(
            "Tool call cancelled by user",
            agent_message="Stopping execution as permission was not granted.",
        )
    
@tool(post_hook=pre_hook_function)
def duckduckgo_news_search(query: str) -> str:
    """
    Search for news articles using DuckDuckGo.
    Args:
        query (str): The search query.
    Returns:
        str: The search results.
    """
    duckduck = DuckDuckGoTools(news=True)
    response = duckduck.duckduckgo_news(query=query)
    return response

    
agent = Agent(
    model=OpenAIChat(id='gpt-4o-mini'),
    instructions=dedent("""\
        You are eqipped with the ability to search for news articles using DuckDuckGo.
    """),
    tools=[duckduckgo_news_search],
    show_tool_calls=True,
    markdown=True,
)

agent.print_response(
    "Search for today's top news", stream=True, console=console
)

Analysis of the Code

The code uses the @tool decorator to assign a function to the "post_hook" argument. The post_hook function is called before the designated function is executed, which is not the desired behavior. The post_hook function is designed to be called after the function execution, not before.

Solution to the Bug

To fix the bug, we need to modify the code to call the post_hook function after the function execution. We can do this by using a wrapper function that calls the post_hook function after the function execution.

from textwrap import dedent
from rich.console import Console
from rich.prompt import Prompt
from agno.agent import Agent
from agno.exceptions import StopAgentRun
from agno.tools import FunctionCall, tool
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.models.openai import OpenAIChat

# This is the console instance used by the print_response method
# We can use this to stop and restart the live display and ask for user confirmation
console = Console()

def pre_hook_function(fc: FunctionCall):
    # Get the live display instance from the console
    live = console._live

    # Stop the live display temporarily so we can ask for user confirmation
    live.stop()  # type: ignore

    # Ask for confirmation
    console.print(f"\nAbout to run [bold blue]{fc.function.name}[/]")
    message = Prompt.ask("Do you want to continue?", choices=["y", "n"], default="y").strip().lower()

    # Restart the live display
    live.start()  # type: ignore

    # If the user does not want to continue, raise a StopExecution exception
    if message == "n":
        raise StopAgentRun(
            "Tool call cancelled by user",
            agent_message="Stopping execution as permission was not granted.",
        )
    
def wrapper_function(fc: FunctionCall):
    # Call the function
    fc.function()
    
    # Call the post_hook function
    pre_hook_function(fc)

@tool(post_hook=wrapper_function)
def duckduckgo_news_search(query: str) -> str:
    """
    Search for news articles using DuckDuckGo.
    Args:
        query (str): The search query.
    Returns:
        str: The search results.
    """
    duckduck = DuckDuckGoTools(news=True)
    response = duckduck.duckduckgo_news(query=query)
    return response

    
agent = Agent(
    model=OpenAIChat(id='gpt-4o-mini'),
    instructions=dedent("""\
        You are eqipped with the ability to search for news articles using DuckDuckGo.
    """),
    tools=[duckduckgo_news_search],
    show_tool_calls=True,
    markdown=True,
)

agent.print_response(
    "Search for today's top news", stream=True, console=console
)

Conclusion

Q: What is the bug in the post_hook function?

A: The bug in the post_hook function is that it is called before the designated function is executed. This is not the desired behavior, as the documentation states that the post_hook function should be called after the function execution.

Q: What is the expected behavior of the post_hook function?

A: The expected behavior of the post_hook function is that it should be called after the function execution. This means that the post_hook function should be executed after the designated function has completed its execution.

Q: How can I fix the bug in the post_hook function?

A: To fix the bug in the post_hook function, you can use a wrapper function that calls the post_hook function after the function execution. This will ensure that the post_hook function is called after the designated function has completed its execution.

Q: What is a wrapper function?

A: A wrapper function is a function that wraps around another function. It calls the inner function and then performs some additional actions. In this case, the wrapper function calls the post_hook function after the function execution.

Q: How do I implement a wrapper function?

A: To implement a wrapper function, you can create a new function that calls the inner function and then performs some additional actions. In this case, the wrapper function calls the post_hook function after the function execution.

Q: What are the benefits of using a wrapper function?

A: The benefits of using a wrapper function include:

Ensuring that the post_hook function is called after the function execution
Providing a way to perform additional actions after the function execution
Making the code more modular and easier to maintain

Q: Can I use a wrapper function with any type of function?

A: Yes, you can use a wrapper function with any type of function. However, the wrapper function should be designed to work with the specific type of function that it is wrapping.

Q: How do I know if I need to use a wrapper function?

A: You may need to use a wrapper function if you need to perform additional actions after a function execution. This can include calling a post_hook function, logging information, or performing some other type of action.

Q: What are some common use cases for wrapper functions?

A: Some common use cases for wrapper functions include:

Calling a post_hook function after a function execution
Logging information after a function execution
Performing some other type of action after a function execution

Q: Can I use a wrapper function to call multiple functions?

A: Yes, you can use a wrapper function to call multiple functions. This can be useful if you need to perform multiple actions after a function execution.

Q: How do I implement a wrapper function to call multiple functions?

A: To implement a wrapper function to call multiple functions, you can create a new function that calls the inner functions and then performs some additional actions. In this case, the wrapper function calls the post_hook function after the function execution.

Q: What are some best practices for using wrapper functions?

A: Some best practices for using wrapper functions include:

Keeping the wrapper function simple and focused on a single task
Using clear and descriptive names for the wrapper function and its variables
Documenting the wrapper function and its behavior
Testing the wrapper function thoroughly to ensure it works correctly

Q: Can I use a wrapper function with a decorator?

A: Yes, you can use a wrapper function with a decorator. This can be useful if you need to perform additional actions after a function execution and you are using a decorator to call the function.

Q: How do I implement a wrapper function with a decorator?

A: To implement a wrapper function with a decorator, you can create a new function that calls the inner function and then performs some additional actions. In this case, the wrapper function calls the post_hook function after the function execution.

Q: What are some common pitfalls to avoid when using wrapper functions?

A: Some common pitfalls to avoid when using wrapper functions include:

Making the wrapper function too complex or difficult to understand
Using unclear or misleading names for the wrapper function and its variables
Failing to document the wrapper function and its behavior
Not testing the wrapper function thoroughly to ensure it works correctly