GoogleModel drops WebSearchTool.blocked_domains, though google-genai now exposes GoogleSearch.exclude_domains

[hotheartguy]

Summary

GoogleModel discards WebSearchTool.blocked_domains. The google-genai SDK now
has a field for it — GoogleSearch.exclude_domains — so the mapping is available
but not wired up.

This is the GoogleModel row of the matrix in #6156. That issue was closed after
the Groq row was fixed (_get_native_tools now builds search_settings with
include_domains / exclude_domains); the Google row was left as-is.

Reproduction

Network-free — a MockTransport captures the outgoing body, so no API key is needed.
Verified on pydantic-ai-slim[google]==2.40.0 / google-genai==2.22.0.

import asyncio, json, httpx
from google.genai import Client
from google.genai.types import HttpOptions
from pydantic_ai import WebSearchTool
from pydantic_ai.messages import ModelRequest, UserPromptPart
from pydantic_ai.models import ModelRequestParameters
from pydantic_ai.models.google import GoogleModel
from pydantic_ai.providers.google import GoogleProvider

captured = {}
CANNED = {
    'candidates': [{'content': {'role': 'model', 'parts': [{'text': 'ok'}]}, 'finishReason': 'STOP'}],
    'usageMetadata': {'promptTokenCount': 1, 'candidatesTokenCount': 1, 'totalTokenCount': 2},
    'modelVersion': 'gemini-3.7-flash',
}

async def handler(request: httpx.Request) -> httpx.Response:
    captured['body'] = json.loads(request.content)
    return httpx.Response(200, json=CANNED)

async def main():
    client = Client(
        api_key='not-a-real-key',
        http_options=HttpOptions(async_client_args={'transport': httpx.MockTransport(handler)}),
    )
    model = GoogleModel('gemini-3.7-flash', provider=GoogleProvider(client=client))
    await model.request(
        [ModelRequest(parts=[UserPromptPart(content='hi')])],
        None,
        ModelRequestParameters(native_tools=[WebSearchTool(blocked_domains=['example.com'])]),
    )
    print('sent:', json.dumps(captured['body']['tools']))

asyncio.run(main())

Output:

sent: [{"googleSearch": {}}]

blocked_domains is gone, with no error and no warning.

Cause

models/google.py:744 constructs the tool with no arguments:

if isinstance(tool, WebSearchTool):
    tools.append(ToolDict(google_search=GoogleSearchDict()))

The SDK field exists

>>> from google.genai.types import GoogleSearch
>>> list(GoogleSearch.model_fields)
['search_types', 'blocking_confidence', 'exclude_domains', 'time_range_filter']
>>> GoogleSearch(exclude_domains=['example.com']).model_dump(exclude_none=True)
{'exclude_domains': ['example.com']}

So blocked_domains → exclude_domains is a direct mapping, the same shape as the
Groq fix in #6156.

Suggested fix (sketch)

if isinstance(tool, WebSearchTool):
    google_search = GoogleSearchDict()
    if tool.blocked_domains is not None:
        google_search['exclude_domains'] = tool.blocked_domains
    tools.append(ToolDict(google_search=google_search))

and add Google to the WebSearchTool.blocked_domains docstring's "Supported by" list.

Note allowed_domains has no Google equivalent — GoogleSearch only offers the
exclude side — so that one stays unsupported.

Out of scope (checked, not asking for these)

• max_uses — documented as ignored ("Other native providers ignore it"), and
  GoogleSearch has no equivalent knob. Working as intended.
• Vertex + Gemini 3 grounding — the
  include_server_side_tool_invocations parameter is not supported in Vertex AI
ValueError is already fixed on main by the not self._is_google_cloud guard.
  Mentioned only so it is not re-reported.

[pydanty]

• Relationship resolved
• Existing-work coverage resolved
• Investigation inputs sufficient
• Supported production reachability established
• Contract and historical intent reconciled
• User/project relevance established (not applicable)
• Immediate relief assessed (not applicable)
• Long-term change is net-positive (not applicable)
• Change boundary and invasiveness understood (not applicable)
• Success criteria and integration-level regression tests defined (not applicable)

Decision: not actionable

The behavior is documented and intentional: Google web search supports enablement but no WebSearchTool parameters. The SDK schema field alone does not establish a supported mapping; current Google API paths reject or silently ignore exclude_domains.

Why it matters: Forwarding the field now could turn the documented silent omission into an error for API-key users or a no-op on Vertex, without delivering domain filtering. Revisit if Google and google-genai establish working end-to-end support.

Evidence: The public Agent path reproduces the silent drop, but checked-in docs mark Google web search as having no parameter support and omit Google from blocked_domains support. SDK and history evidence show exclude_domains is not currently a reliable provider capability. No existing work covers this request.

Playground: https://play.pydantic.work/p/qymKzQir

[CaptainAni187]

Opened #8233.

Your repro was spot on — GoogleSearchDict() was constructed empty, so the filter never reached the request. Fixed by populating exclude_domains, mirroring how GroqModel builds search_settings.

One thing worth noting for the wider #6156 matrix: allowed_domains can't be mapped for Google at all. On the installed google-genai, GoogleSearch exposes only ['blocking_confidence', 'exclude_domains', 'search_types', 'time_range_filter'] — there's no include_domains. So I left it dropped and updated the blocked_domains docstring to list Google, keeping allowed_domains' list accurate. Raising a UserError for that case instead of dropping silently might be worth considering, but that felt like a separate decision.

Tests follow the existing _in_config pattern, so no network or cassette needed. 156 → 158 passing.