[Bug] GoogleGenaiSamplingHandler: Pydantic title fields in tool schemas cause MALFORMED_FUNCTION_CALL on Gemini 2.5 Flash

[strawgate]

Description

Gemini 2.5 Flash consistently returns MALFORMED_FUNCTION_CALL when a function declaration's parameters_json_schema contains "title" fields — which Pydantic adds by default to every field and object in .json_schema() output.

This affects all ctx.sample(result_type=...) calls when using the GoogleGenaiSamplingHandler with Gemini 2.5 Flash, because FastMCP creates a final_response tool from the Pydantic schema. The sample_impl function calls compress_schema(schema, prune_titles=True) for validation purposes, but the actual tool schema sent to Gemini goes through _convert_tool_to_google_genai which passes tool.inputSchema directly — with titles intact.

Root Cause

Isolated via systematic testing:

# This schema WORKS (no titles):
{"properties": {"items": {"items": {"properties": {"x": {"type": "string"}}, ...}}}}

# This schema FAILS (with titles):
{"properties": {"items": {"title": "Items", "items": {"title": "Item", "properties": {"x": {"title": "X", "type": "string"}}, ...}}}}

• $ref/$defs alone: works fine
• description fields: works fine
• title on any property or object: 100% failure on Gemini 2.5 Flash
• Gemini 2.5 Pro: unaffected (handles titles correctly)
• Gemini JSON mode (response_json_schema): unaffected (handles titles correctly)

Reproduction

from google import genai
from google.genai import types
from pydantic import BaseModel, TypeAdapter

class Item(BaseModel):
    index: int
    label: str

class Result(BaseModel):
    items: list[Item]

# This fails on gemini-2.5-flash:
schema = TypeAdapter(Result).json_schema()  # has "title" fields
tool = types.Tool(function_declarations=[
    types.FunctionDeclaration(name="respond", description=".", parameters_json_schema=schema)
])
resp = genai.Client().models.generate_content(
    model="gemini-2.5-flash",
    contents="Classify: apple, banana",
    config=types.GenerateContentConfig(
        tools=[tool],
        tool_config=types.ToolConfig(
            function_calling_config=types.FunctionCallingConfig(mode="ANY")
        ),
    ),
)
print(resp.candidates[0].finish_reason)  # MALFORMED_FUNCTION_CALL

# Stripping titles fixes it:
def strip_titles(obj):
    if isinstance(obj, dict):
        return {k: strip_titles(v) for k, v in obj.items() if k != "title"}
    if isinstance(obj, list):
        return [strip_titles(i) for i in obj]
    return obj

schema_clean = strip_titles(schema)  # same schema without "title" keys
# Using schema_clean → FinishReason.STOP (works)

Suggested Fix

In _convert_tool_to_google_genai (google_genai.py line ~150), strip title fields from the schema before passing to Gemini:

def _convert_tool_to_google_genai(tool: MCPTool) -> GoogleTool:
    schema = tool.inputSchema
    # Strip 'title' fields — Gemini 2.5 Flash produces MALFORMED_FUNCTION_CALL
    # when schemas contain Pydantic's auto-generated title annotations
    schema = _strip_titles(schema)
    return GoogleTool(
        function_declarations=[
            FunctionDeclaration(
                name=tool.name,
                description=tool.description or "",
                parameters_json_schema=schema,
            )
        ]
    )

Note: compress_schema(schema, prune_titles=True) already exists in run.py and does this — but it's only applied for validation, not for the schema sent to Gemini.

Affected Versions

• fastmcp 3.2.3
• google-genai 1.72.0
• Gemini 2.5 Flash (affected), Gemini 2.5 Pro (not affected)

[marvin-context-protocol]

Claude finished @strawgate's task in 9m 20s —— View job

---

Triage: Strip title fields from tool schemas in GoogleGenaiSamplingHandler

Confirmed valid bug. Gemini 2.5 Flash rejects function declarations containing Pydantic-generated title fields with MALFORMED_FUNCTION_CALL. The fix is to strip titles in _convert_tool_to_google_genai — a one-function change in google_genai.py.

Recommendation

Add a _strip_titles helper to google_genai.py and call it in _convert_tool_to_google_genai before passing the schema to FunctionDeclaration. This is a Gemini-specific workaround that belongs in the Gemini handler, not in generic schema utilities.

Findings

The core issue is real: Gemini 2.5 Flash's function calling API rejects schemas containing "title" fields. Pydantic's .json_schema() adds these by default to every property and object.

Nuance on the reporter's root cause analysis: The reporter states that _convert_tool_to_google_genai passes tool.inputSchema "with titles intact." I verified this is partially true — it depends on how the tool was created:

Tool creation path	Titles stripped?	Why
create_final_response_tool (for result_type=)	Yes	Calls compress_schema(schema, prune_titles=True) at run.py:429
SamplingTool.from_function(fn)	Yes	ParsedFunction.from_function calls compress_schema(..., prune_titles=True) at function_parsing.py:194
SamplingTool.from_callable_tool(tool)	Yes	Inherits from FunctionTool.parameters which was already compressed
SamplingTool(parameters=schema) (direct creation)	No	User provides raw schema — no automatic stripping

So the standard paths already strip titles on the current main branch. However:

1. Direct SamplingTool creation is a valid user-facing API that doesn't strip titles — this IS a real gap
2. The reporter may have been on v3.2.3 where prune_titles=True may not have been present in all paths
3. Even if upstream callers happen to strip titles today, _convert_tool_to_google_genai should not depend on that assumption — defense-in-depth

Why fix in the handler, not upstream: The Anthropic and OpenAI handlers (anthropic.py:365, openai.py:415) also pass tool.inputSchema directly — and that's fine because those providers handle titles correctly. This is a Gemini-specific quirk that belongs in the Gemini handler.

Important: compress_schema() mutates the input dict in-place (via node.pop("title") in _single_pass_optimize). The fix should use a non-mutating approach to avoid side effects on the original tool.inputSchema.

Verification

I verified the behavior by running the schema through FastMCP's actual code paths:

# final_response tool — titles already stripped on main
>>> tool = create_final_response_tool(Result)
>>> '"title"' in json.dumps(tool._to_sdk_tool().inputSchema)
False  # ✓ Already stripped

# Direct SamplingTool creation — titles survive
>>> tool = SamplingTool(name='t', parameters=TypeAdapter(MySchema).json_schema(), fn=lambda **k: k)
>>> '"title"' in json.dumps(tool._to_sdk_tool().inputSchema)
True  # ✗ Titles present — would fail on Gemini 2.5 Flash

Also confirmed compress_schema mutates in-place:

>>> schema_copy = copy.deepcopy(schema)
>>> compress_schema(schema_copy, prune_titles=True)
>>> schema_copy != schema  # True — the copy was mutated

Detailed Action Plan

File to modify: src/fastmcp/client/sampling/handlers/google_genai.py

Step 1: Add a _strip_titles helper function (before _convert_tool_to_google_genai):

def _strip_titles(obj: Any) -> Any:
    """Recursively strip 'title' fields from a JSON schema.

    Gemini 2.5 Flash returns MALFORMED_FUNCTION_CALL when function declaration
    schemas contain 'title' fields (which Pydantic adds by default).
    """
    if isinstance(obj, dict):
        return {k: _strip_titles(v) for k, v in obj.items() if k != "title"}
    if isinstance(obj, list):
        return [_strip_titles(item) for item in obj]
    return obj

This is intentionally simpler than compress_schema — it's a targeted workaround for a specific Gemini issue. It also returns new dicts (no mutation of the original).

Step 2: Use _strip_titles in _convert_tool_to_google_genai (line 144-158):

def _convert_tool_to_google_genai(tool: MCPTool) -> GoogleTool:
    """Convert an MCP Tool to Google GenAI format."""
    schema = _strip_titles(tool.inputSchema)
    return GoogleTool(
        function_declarations=[
            FunctionDeclaration(
                name=tool.name,
                description=tool.description or "",
                parameters_json_schema=schema,
            )
        ]
    )

Step 3: Add from typing import Any import at the top of the file (needed for the type annotation on _strip_titles).

Step 4: Add a test in tests/client/sampling/handlers/test_google_genai_handler.py:

def test_convert_tool_to_google_genai_strips_titles():
    """Gemini 2.5 Flash rejects schemas with 'title' fields."""
    from mcp.types import Tool as MCPTool
    from fastmcp.client.sampling.handlers.google_genai import _convert_tool_to_google_genai
    import json

    tool = MCPTool(
        name="respond",
        description="test",
        inputSchema={
            "title": "Result",
            "type": "object",
            "properties": {
                "items": {
                    "title": "Items",
                    "type": "array",
                    "items": {
                        "title": "Item",
                        "type": "object",
                        "properties": {
                            "x": {"title": "X", "type": "string"}
                        },
                    },
                }
            },
        },
    )

    google_tool = _convert_tool_to_google_genai(tool)
    schema = google_tool.function_declarations[0].parameters_json_schema
    assert "title" not in json.dumps(schema)

Step 5: Run tests:

uv run pytest tests/client/sampling/handlers/test_google_genai_handler.py -v
uv run prek run --all-files

Related Files

File	Relevance	Key Lines
src/fastmcp/client/sampling/handlers/google_genai.py	Fix location — _convert_tool_to_google_genai at L144	144-158
src/fastmcp/utilities/json_schema.py	Existing compress_schema with prune_titles — reference for approach	482-522
src/fastmcp/server/sampling/run.py	Where final_response tool is created with titles already stripped	421-451
tests/client/sampling/handlers/test_google_genai_handler.py	Test file to add the new test

---

Marvin Context Protocol | Type /marvin to interact further

Give us feedback! React with 🚀 if perfect, 👍 if helpful, 👎 if not.