Also facing the same issue. It's a waste of input and output tokens to do a final model round, and adds unnecessary latency and it could be prone to LLM errors after the model regurgitates the output.

Also saw #847 which is the same discussion.

Would love to see if folks have found a short-term workaround for this

In terms of a short term work around, I've found success by

1. Modifying the result_tool_description for less complex use cases.
2. Using few-shot prompting and using result_type, the few shot prompt would look something like this:

messages = [
    {
        "role": "system",
        "content": "You are an AI assistant.",
    },
    {
        "role": "user",
        "content": "I have the following data: ...",
    },
    {
        "role": "assistant",
        "tool_calls": [
            {
                "id": "call_0_generated_uuid",
                "type": "function",
                "function": {
                    "name": "final_result",
                    "arguments": '{"response":["complex_foo": "bar"]}',
                },
            }
        ],
    },
    {
        "role": "tool",
        "tool_call_id": "call_0_generated_uuid",
        "content": '["complex_foo": "bar"]',
    },
    {
        "role": "user",
        "content": 'Your actual user query.',
    },
]

3. Using agent.result_validator as talked about in Returning pydantic result of tool as final_result #847

async def foo_result_validator(
    ctx: GraphRunContext[FooState, FooDeps],
    result: IntermediateFoo,
):
    data = # Your actual tool call here
    return data

I haven't tried, but you may be able to use iter as well, iterate through the nodes and look for the specific ToolCallPart within CallToolsNode, then search through agent._function_tools and terminate with that call.

Yeah, seems like iter with termination at tool node should work. Still having an option in tool decorator would be a better developer experience.

I also spent lot of time investigating how to achieve this.

One work around is abusing deps by storing some state value like the output of tool into it. And send only some bland message like 'executed toolx' as output of tool back to LLM, so it saves on tokens.
But it feels 'dirty' to abuse the dependency injection mechanism. Maybe a state as part of context, in addition to deps would make for a clean solution.

Another solution would be to use pydantic graph itself, and have some sort of root agent, which takes user query and returns a structured output of agent_types.
Based on agent_type, one could either call the function itself and return the output to user. Or use some part of function output to send to another agent. The graph has a state, and this way, there is full control of what to have as part of store and what to send to LLM and then use some combination of state and LLM output to send to user.

+1!

This is so important, I would love to have something like this in pydantic-ai