Temporal: allow cross agent tool registration

[darugar]

Description

In scenarios where agents need to be defined dynamically (example), the list of agent tools cannot be registered by the agent when the temporal worker is created, since the agent is not yet created.

Please decouple tool registration and naming from agent definition and naming in order to allow multiple agents (and dynamically created agents) within a temporal workflow to use the same set of registered tools. A master list of tools would be registered with the temporal workflow at the time of workflow creation, and dynamically created agents could refer to and use the subset of those tools as needed.

For example, if the tool naming (currently something like agent__{name}__tool__{tool_name}) were to not include the agent name and instead be a workflow-wide tool, then dynamic agents could refer to the tool by its name/slug.

It would be nice to have a helper function for temporal workflow tool registration as well.

References

From the slack conversation with @DouweM :

That would be pretty easy to make work -- you can already create a FunctionToolset and then manually wrap it in a TemporalFunctionToolset (currently private) and then pass the temporal_function_toolset.temporal_activities to the worker. The only part that isn't done yet is letting you pass those TemporalFunctionToolsets to TemporalAgent.run(toolsets=...), which would require replacing this error with a check that all the toolsets are properly wrapped for Temporal:

pydantic-ai/pydantic_ai_slim/pydantic_ai/durable_exec/temporal/_agent.py

Lines 898 to 901 in c1213e4

	if toolsets is not None:
	raise UserError(
	'Toolsets cannot be set at agent run time inside a Temporal workflow, it must be set at agent creation time.'
	)

Related to:

• Define TemporalAgents at runtime #3506
• Allow TemporalAgent to switch model at agent.run-time #3537

[DouweM]

@darugar Thanks for filing the issue! This would be pretty easy to make work as I mentioned on Slack. Would you be up for submitting a PR?

It would roughly work like this:

from pydantic_ai import Agent
from pydantic_ai.durable_exec.temporal import (
    PydanticAIPlugin,
    PydanticAIWorkflow,
    TemporalAgent,
    TemporalFunctionToolset,
)
from pydantic_ai.toolsets import FunctionToolset
from temporalio import workflow

agent = Agent(
    "gpt-5",
    instructions="You're an expert in geography.",
    name="geography",  # (10)!
)

temporal_agent = TemporalAgent(agent)  # (1)!

toolset = FunctionToolset()


@toolset.tool
def get_temperature() -> float:
    return 19.4


temporal_toolset = TemporalFunctionToolset(toolset)


@workflow.defn
class GeographyWorkflow(PydanticAIWorkflow):  # (2)!
    __pydantic_ai_agents__ = [temporal_agent]  # (3)!
    __pydantic_ai_toolsets__ = [temporal_toolset]

    @workflow.run
    async def run(self, prompt: str) -> str:
        result = await temporal_agent.run(prompt, toolsets=[temporal_toolset])  # (4)!
        return result.output

That specifically uses TemporalFunctionToolset, but there's already a temporalize_toolset function that also takes MCPServer etc. This way, you can create as many toolsets as you like and choose which to pass in at runtime.

cc @mattbrandman as this is somewhat similar to #3537, although in that case we can't just let you create TemporalModels, as the activity also needs to bind the agent's event stream handler.

[qyinm]

Hi @DouweM,

I've implemented the changes to allow dynamic TemporalWrapperToolset usage as discussed, following the pattern you suggested. I've submitted a PR (#3775) with the implementation and tests.

I would appreciate your review when you have a moment. Thanks!