​
fastmcp.tools.tool_transform

​
Classes

​
ArgTransform

Configuration for transforming a parent tool’s argument.

This class allows fine-grained control over how individual arguments are transformed when creating a new tool from an existing one. You can rename arguments, change their descriptions, add default values, or hide them from clients while passing constants.

Examples:

Rename argument ‘old_name’ to ‘new_name’

ArgTransform(name="new_name")

Change description only

ArgTransform(description="Updated description")

Add a default value (makes argument optional)

ArgTransform(default=42)

Add a default factory (makes argument optional)

ArgTransform(default_factory=lambda: time.time())

Change the type

ArgTransform(type=str)

Hide the argument entirely from clients

ArgTransform(hide=True)

Hide argument but pass a constant value to parent

ArgTransform(hide=True, default="constant_value")

Hide argument but pass a factory-generated value to parent

ArgTransform(hide=True, default_factory=lambda: uuid.uuid4().hex)

Make an optional parameter required (removes any default)

ArgTransform(required=True)

Combine multiple transformations

ArgTransform(name="new_name", description="New desc", default=None, type=int)

​
TransformedTool

A tool that is transformed from another tool.

This class represents a tool that has been created by transforming another tool. It supports argument renaming, schema modification, custom function injection, and provides context for the forward() and forward_raw() functions.

The transformation can be purely schema-based (argument renaming, dropping, etc.) or can include a custom function that uses forward() to call the parent tool with transformed arguments.

Methods:

​
from_tool 

from_tool(cls, tool: Tool, name: str | None = None, description: str | None = None, tags: set[str] | None = None, transform_fn: Callable[..., Any] | None = None, transform_args: dict[str, ArgTransform] | None = None, annotations: ToolAnnotations | None = None, serializer: Callable[[Any], str] | None = None, enabled: bool | None = None) -> TransformedTool

Create a transformed tool from a parent tool.

Args:

  • tool: The parent tool to transform.
  • transform_fn: Optional custom function. Can use forward() and forward_raw() to call the parent tool. Functions with **kwargs receive transformed argument names.
  • name: New name for the tool. Defaults to parent tool’s name.
  • transform_args: Optional transformations for parent tool arguments. Only specified arguments are transformed, others pass through unchanged:
  • Simple rename (str)
  • Complex transformation (rename/description/default/drop) (ArgTransform)
  • Drop the argument (None)
  • description: New description. Defaults to parent’s description.
  • tags: New tags. Defaults to parent’s tags.
  • annotations: New annotations. Defaults to parent’s annotations.
  • serializer: New serializer. Defaults to parent’s serializer.

Returns:

  • TransformedTool with the specified transformations.

Examples:

​
Transform specific arguments only

Tool.from_tool(parent, transform_args={"old": "new"})  # Others unchanged

​
Custom function with partial transforms

async def custom(x: int, y: int) -> str:
    result = await forward(x=x, y=y)
    return f"Custom: {result}"

Tool.from_tool(parent, transform_fn=custom, transform_args={"a": "x", "b": "y"})

​
Using **kwargs (gets all args, transformed and untransformed)

async def flexible(**kwargs) -> str:
    result = await forward(**kwargs)
    return f"Got: {kwargs}"

Tool.from_tool(parent, transform_fn=flexible, transform_args={"a": "x"})