MCP tool responses: should both content and structuredContent be passed to the LLM?

[jnuvola]

When an MCP tool returns both content and structuredContent, the current implementation passes the entire response object to the LLM context. This happens because current implementation of MCP tool seems to convert the full response via model_dump() and passes this dictionary directly to FunctionResponse without any filtering, resulting unnecessary token consumption (potentially doubling the context used for each tool response).

Questions for discussion:

• Should ADK filter to only pass content to the LLM by default?
• If there's a use case for including structuredContent, should it be opt-in?

Would appreciate thoughts on the intended behavior here.

[adk-bot]

Response from ADK Answering Agent (experimental, answer may be inaccurate)

TLDR: You can use an after_tool_callbacks function to inspect and modify a tool's output before it's sent to the LLM. This allows you to filter out fields like structuredContent to optimize token usage.

---

Hello! That's an excellent question regarding token optimization for tool responses.

You are correct that the default behavior in ADK is to serialize the entire object returned by a tool and include it in the FunctionResponse sent to the model. This provides maximum flexibility, but as you've pointed out, it can be inefficient if the tool returns a rich object with data that isn't needed for the LLM's next reasoning step.

While I couldn't find a specific ADK schema that defines content and structuredContent keys, the general principle of needing to filter a tool's output is a common requirement. ADK provides a clean way to handle this using callbacks.

Using after_tool_callbacks for Filtering

The recommended approach to solve this is to implement an after_tool_callbacks function. This callback intercepts the response from your tool, allowing you to transform it before it's packaged and sent to the LLM.

Here is a conceptual example of how you could define and attach such a callback to your agent:

from google.adk.agents import LlmAgent
from google.adk.events import Event
from google.adk.invocation_context import InvocationContext

def filter_tool_output(
    invocation_context: InvocationContext, event: Event, response: any
) -> any:
    """
    Inspects the tool response. If it's a dictionary containing both
    'content' and 'structuredContent', it returns only the 'content'.
    """
    if (
        isinstance(response, dict)
        and "content" in response
        and "structuredContent" in response
    ):
        # Return only the part the LLM needs
        return response["content"]

    # Otherwise, return the response unmodified
    return response


# When defining your agent, attach the callback
my_agent = LlmAgent(
    # ... other agent parameters
    tools=[...],
    after_tool_callbacks=[filter_tool_output],
)

Answering Your Specific Questions

1. Should ADK filter to only pass content to the LLM by default?
   The current default of passing the entire response ensures that no information is accidentally lost, as ADK cannot know which parts of a tool's output are essential for the model's reasoning. Automatically assuming only a field named content is relevant might be too restrictive for a general-purpose framework.

2. If there's a use case for including structuredContent, should it be opt-in?
   The callback mechanism effectively serves as a way to "opt-in" or "opt-out" of this behavior with full developer control. By default, everything is included. By adding a callback, you are explicitly defining how to trim the response for the LLM, giving you the best of both worlds: your tool can return a rich object for other parts of your application, while you keep the context sent to the LLM lean. [6]

I hope this helps clarify the intended design and provides a practical solution for your use case!